blob: 987604d56c83009cf94c63235d10841bdbf5bd94 [file] [log] [blame]
Dave Hansen3947be12005-10-29 18:16:54 -07001/*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002 * Memory subsystem support
Dave Hansen3947be12005-10-29 18:16:54 -07003 *
4 * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
5 * Dave Hansen <haveblue@us.ibm.com>
6 *
7 * This file provides the necessary infrastructure to represent
8 * a SPARSEMEM-memory-model system's physical memory in /sysfs.
9 * All arch-independent code that assumes MEMORY_HOTPLUG requires
10 * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
11 */
12
Dave Hansen3947be12005-10-29 18:16:54 -070013#include <linux/module.h>
14#include <linux/init.h>
Dave Hansen3947be12005-10-29 18:16:54 -070015#include <linux/topology.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080016#include <linux/capability.h>
Dave Hansen3947be12005-10-29 18:16:54 -070017#include <linux/device.h>
18#include <linux/memory.h>
19#include <linux/kobject.h>
20#include <linux/memory_hotplug.h>
21#include <linux/mm.h>
Daniel Walkerda19cbc2008-02-04 23:35:47 -080022#include <linux/mutex.h>
Shaohua Li9f1b16a2008-10-18 20:27:12 -070023#include <linux/stat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
Shaohua Li9f1b16a2008-10-18 20:27:12 -070025
Arun Sharma600634972011-07-26 16:09:06 -070026#include <linux/atomic.h>
Dave Hansen3947be12005-10-29 18:16:54 -070027#include <asm/uaccess.h>
28
Nathan Fontenot2938ffb2010-10-19 12:45:24 -050029static DEFINE_MUTEX(mem_sysfs_mutex);
30
Dave Hansen3947be12005-10-29 18:16:54 -070031#define MEMORY_CLASS_NAME "memory"
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -060032
33static int sections_per_block;
34
35static inline int base_memory_block_id(int section_nr)
36{
37 return section_nr / sections_per_block;
38}
Dave Hansen3947be12005-10-29 18:16:54 -070039
Kay Sievers10fbcf42011-12-21 14:48:43 -080040static struct bus_type memory_subsys = {
Kay Sieversaf5ca3f2007-12-20 02:09:39 +010041 .name = MEMORY_CLASS_NAME,
Kay Sievers10fbcf42011-12-21 14:48:43 -080042 .dev_name = MEMORY_CLASS_NAME,
Dave Hansen3947be12005-10-29 18:16:54 -070043};
44
Alan Sterne041c682006-03-27 01:16:30 -080045static BLOCKING_NOTIFIER_HEAD(memory_chain);
Dave Hansen3947be12005-10-29 18:16:54 -070046
Andy Whitcroft98a38eb2006-01-06 00:10:35 -080047int register_memory_notifier(struct notifier_block *nb)
Dave Hansen3947be12005-10-29 18:16:54 -070048{
Alan Sterne041c682006-03-27 01:16:30 -080049 return blocking_notifier_chain_register(&memory_chain, nb);
Dave Hansen3947be12005-10-29 18:16:54 -070050}
Hannes Hering3c82c302008-05-07 14:43:01 +020051EXPORT_SYMBOL(register_memory_notifier);
Dave Hansen3947be12005-10-29 18:16:54 -070052
Andy Whitcroft98a38eb2006-01-06 00:10:35 -080053void unregister_memory_notifier(struct notifier_block *nb)
Dave Hansen3947be12005-10-29 18:16:54 -070054{
Alan Sterne041c682006-03-27 01:16:30 -080055 blocking_notifier_chain_unregister(&memory_chain, nb);
Dave Hansen3947be12005-10-29 18:16:54 -070056}
Hannes Hering3c82c302008-05-07 14:43:01 +020057EXPORT_SYMBOL(unregister_memory_notifier);
Dave Hansen3947be12005-10-29 18:16:54 -070058
Robert Jennings925cc712009-12-17 14:44:38 +000059static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
60
61int register_memory_isolate_notifier(struct notifier_block *nb)
62{
63 return atomic_notifier_chain_register(&memory_isolate_chain, nb);
64}
65EXPORT_SYMBOL(register_memory_isolate_notifier);
66
67void unregister_memory_isolate_notifier(struct notifier_block *nb)
68{
69 atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
70}
71EXPORT_SYMBOL(unregister_memory_isolate_notifier);
72
Yasuaki Ishimatsufa7194e2012-12-11 16:00:44 -080073static void memory_block_release(struct device *dev)
74{
75 struct memory_block *mem = container_of(dev, struct memory_block, dev);
76
77 kfree(mem);
78}
79
Dave Hansen3947be12005-10-29 18:16:54 -070080/*
81 * register_memory - Setup a sysfs device for a memory block
82 */
Badari Pulavarty00a41db2008-02-11 09:23:18 -080083static
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -060084int register_memory(struct memory_block *memory)
Dave Hansen3947be12005-10-29 18:16:54 -070085{
86 int error;
87
Kay Sievers10fbcf42011-12-21 14:48:43 -080088 memory->dev.bus = &memory_subsys;
89 memory->dev.id = memory->start_section_nr / sections_per_block;
Yasuaki Ishimatsufa7194e2012-12-11 16:00:44 -080090 memory->dev.release = memory_block_release;
Dave Hansen3947be12005-10-29 18:16:54 -070091
Kay Sievers10fbcf42011-12-21 14:48:43 -080092 error = device_register(&memory->dev);
Dave Hansen3947be12005-10-29 18:16:54 -070093 return error;
94}
95
96static void
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -060097unregister_memory(struct memory_block *memory)
Dave Hansen3947be12005-10-29 18:16:54 -070098{
Kay Sievers10fbcf42011-12-21 14:48:43 -080099 BUG_ON(memory->dev.bus != &memory_subsys);
Dave Hansen3947be12005-10-29 18:16:54 -0700100
Badari Pulavarty00a41db2008-02-11 09:23:18 -0800101 /* drop the ref. we got in remove_memory_block() */
Kay Sievers10fbcf42011-12-21 14:48:43 -0800102 kobject_put(&memory->dev.kobj);
103 device_unregister(&memory->dev);
Dave Hansen3947be12005-10-29 18:16:54 -0700104}
105
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600106unsigned long __weak memory_block_size_bytes(void)
107{
108 return MIN_MEMORY_BLOCK_SIZE;
109}
110
111static unsigned long get_memory_block_size(void)
112{
113 unsigned long block_sz;
114
115 block_sz = memory_block_size_bytes();
116
117 /* Validate blk_sz is a power of 2 and not less than section size */
118 if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) {
119 WARN_ON(1);
120 block_sz = MIN_MEMORY_BLOCK_SIZE;
121 }
122
123 return block_sz;
124}
125
Dave Hansen3947be12005-10-29 18:16:54 -0700126/*
127 * use this as the physical section index that this memsection
128 * uses.
129 */
130
Kay Sievers10fbcf42011-12-21 14:48:43 -0800131static ssize_t show_mem_start_phys_index(struct device *dev,
132 struct device_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700133{
134 struct memory_block *mem =
Kay Sievers10fbcf42011-12-21 14:48:43 -0800135 container_of(dev, struct memory_block, dev);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600136 unsigned long phys_index;
137
138 phys_index = mem->start_section_nr / sections_per_block;
139 return sprintf(buf, "%08lx\n", phys_index);
140}
141
Kay Sievers10fbcf42011-12-21 14:48:43 -0800142static ssize_t show_mem_end_phys_index(struct device *dev,
143 struct device_attribute *attr, char *buf)
Nathan Fontenotd3360162011-01-20 10:44:29 -0600144{
145 struct memory_block *mem =
Kay Sievers10fbcf42011-12-21 14:48:43 -0800146 container_of(dev, struct memory_block, dev);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600147 unsigned long phys_index;
148
149 phys_index = mem->end_section_nr / sections_per_block;
150 return sprintf(buf, "%08lx\n", phys_index);
Dave Hansen3947be12005-10-29 18:16:54 -0700151}
152
153/*
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700154 * Show whether the section of memory is likely to be hot-removable
155 */
Kay Sievers10fbcf42011-12-21 14:48:43 -0800156static ssize_t show_mem_removable(struct device *dev,
157 struct device_attribute *attr, char *buf)
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700158{
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600159 unsigned long i, pfn;
160 int ret = 1;
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700161 struct memory_block *mem =
Kay Sievers10fbcf42011-12-21 14:48:43 -0800162 container_of(dev, struct memory_block, dev);
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700163
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600164 for (i = 0; i < sections_per_block; i++) {
Nathan Fontenotd3360162011-01-20 10:44:29 -0600165 pfn = section_nr_to_pfn(mem->start_section_nr + i);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600166 ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
167 }
168
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700169 return sprintf(buf, "%d\n", ret);
170}
171
172/*
Dave Hansen3947be12005-10-29 18:16:54 -0700173 * online, offline, going offline, etc.
174 */
Kay Sievers10fbcf42011-12-21 14:48:43 -0800175static ssize_t show_mem_state(struct device *dev,
176 struct device_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700177{
178 struct memory_block *mem =
Kay Sievers10fbcf42011-12-21 14:48:43 -0800179 container_of(dev, struct memory_block, dev);
Dave Hansen3947be12005-10-29 18:16:54 -0700180 ssize_t len = 0;
181
182 /*
183 * We can probably put these states in a nice little array
184 * so that they're not open-coded
185 */
186 switch (mem->state) {
187 case MEM_ONLINE:
188 len = sprintf(buf, "online\n");
189 break;
190 case MEM_OFFLINE:
191 len = sprintf(buf, "offline\n");
192 break;
193 case MEM_GOING_OFFLINE:
194 len = sprintf(buf, "going-offline\n");
195 break;
196 default:
197 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
198 mem->state);
199 WARN_ON(1);
200 break;
201 }
202
203 return len;
204}
205
Yasunori Goto7b78d332007-10-21 16:41:36 -0700206int memory_notify(unsigned long val, void *v)
Dave Hansen3947be12005-10-29 18:16:54 -0700207{
Alan Sterne041c682006-03-27 01:16:30 -0800208 return blocking_notifier_call_chain(&memory_chain, val, v);
Dave Hansen3947be12005-10-29 18:16:54 -0700209}
210
Robert Jennings925cc712009-12-17 14:44:38 +0000211int memory_isolate_notify(unsigned long val, void *v)
212{
213 return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
214}
215
Dave Hansen3947be12005-10-29 18:16:54 -0700216/*
Mel Gorman2bbcb8782011-10-17 16:38:20 +0200217 * The probe routines leave the pages reserved, just as the bootmem code does.
218 * Make sure they're still that way.
219 */
220static bool pages_correctly_reserved(unsigned long start_pfn,
221 unsigned long nr_pages)
222{
223 int i, j;
224 struct page *page;
225 unsigned long pfn = start_pfn;
226
227 /*
228 * memmap between sections is not contiguous except with
229 * SPARSEMEM_VMEMMAP. We lookup the page once per section
230 * and assume memmap is contiguous within each section
231 */
232 for (i = 0; i < sections_per_block; i++, pfn += PAGES_PER_SECTION) {
233 if (WARN_ON_ONCE(!pfn_valid(pfn)))
234 return false;
235 page = pfn_to_page(pfn);
236
237 for (j = 0; j < PAGES_PER_SECTION; j++) {
238 if (PageReserved(page + j))
239 continue;
240
241 printk(KERN_WARNING "section number %ld page number %d "
242 "not reserved, was it already online?\n",
243 pfn_to_section_nr(pfn), j);
244
245 return false;
246 }
247 }
248
249 return true;
250}
251
252/*
Dave Hansen3947be12005-10-29 18:16:54 -0700253 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
254 * OK to have direct references to sparsemem variables in here.
255 */
256static int
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800257memory_block_action(unsigned long phys_index, unsigned long action, int online_type)
Dave Hansen3947be12005-10-29 18:16:54 -0700258{
Wen Congyanga16cee12012-10-08 16:33:58 -0700259 unsigned long start_pfn;
Anton Blanchard5409d2c2011-05-11 17:25:14 +1000260 unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
Greg Kroah-Hartmande0ed362011-10-18 14:00:57 -0700261 struct page *first_page;
Dave Hansen3947be12005-10-29 18:16:54 -0700262 int ret;
Dave Hansen3947be12005-10-29 18:16:54 -0700263
Greg Kroah-Hartmande0ed362011-10-18 14:00:57 -0700264 first_page = pfn_to_page(phys_index << PFN_SECTION_SHIFT);
Wen Congyanga16cee12012-10-08 16:33:58 -0700265 start_pfn = page_to_pfn(first_page);
Greg Kroah-Hartmande0ed362011-10-18 14:00:57 -0700266
Dave Hansen3947be12005-10-29 18:16:54 -0700267 switch (action) {
268 case MEM_ONLINE:
Mel Gorman2bbcb8782011-10-17 16:38:20 +0200269 if (!pages_correctly_reserved(start_pfn, nr_pages))
270 return -EBUSY;
271
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800272 ret = online_pages(start_pfn, nr_pages, online_type);
Dave Hansen3947be12005-10-29 18:16:54 -0700273 break;
274 case MEM_OFFLINE:
Wen Congyanga16cee12012-10-08 16:33:58 -0700275 ret = offline_pages(start_pfn, nr_pages);
Dave Hansen3947be12005-10-29 18:16:54 -0700276 break;
277 default:
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600278 WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
279 "%ld\n", __func__, phys_index, action, action);
Dave Hansen3947be12005-10-29 18:16:54 -0700280 ret = -EINVAL;
281 }
Dave Hansen3947be12005-10-29 18:16:54 -0700282
283 return ret;
284}
285
Wen Congyange90bdb72012-10-08 16:34:01 -0700286static int __memory_block_change_state(struct memory_block *mem,
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800287 unsigned long to_state, unsigned long from_state_req,
288 int online_type)
Dave Hansen3947be12005-10-29 18:16:54 -0700289{
Greg Kroah-Hartmande0ed362011-10-18 14:00:57 -0700290 int ret = 0;
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600291
Dave Hansen3947be12005-10-29 18:16:54 -0700292 if (mem->state != from_state_req) {
293 ret = -EINVAL;
294 goto out;
295 }
296
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600297 if (to_state == MEM_OFFLINE)
298 mem->state = MEM_GOING_OFFLINE;
299
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800300 ret = memory_block_action(mem->start_section_nr, to_state, online_type);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600301
Michael Holzheuf5138e42012-01-12 17:20:23 -0800302 if (ret) {
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600303 mem->state = from_state_req;
Michael Holzheuf5138e42012-01-12 17:20:23 -0800304 goto out;
305 }
Dave Hansen3947be12005-10-29 18:16:54 -0700306
Michael Holzheuf5138e42012-01-12 17:20:23 -0800307 mem->state = to_state;
308 switch (mem->state) {
309 case MEM_OFFLINE:
310 kobject_uevent(&mem->dev.kobj, KOBJ_OFFLINE);
311 break;
312 case MEM_ONLINE:
313 kobject_uevent(&mem->dev.kobj, KOBJ_ONLINE);
314 break;
315 default:
316 break;
317 }
Dave Hansen3947be12005-10-29 18:16:54 -0700318out:
Dave Hansen3947be12005-10-29 18:16:54 -0700319 return ret;
320}
321
Wen Congyange90bdb72012-10-08 16:34:01 -0700322static int memory_block_change_state(struct memory_block *mem,
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800323 unsigned long to_state, unsigned long from_state_req,
324 int online_type)
Wen Congyange90bdb72012-10-08 16:34:01 -0700325{
326 int ret;
327
328 mutex_lock(&mem->state_mutex);
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800329 ret = __memory_block_change_state(mem, to_state, from_state_req,
330 online_type);
Wen Congyange90bdb72012-10-08 16:34:01 -0700331 mutex_unlock(&mem->state_mutex);
332
333 return ret;
334}
Dave Hansen3947be12005-10-29 18:16:54 -0700335static ssize_t
Kay Sievers10fbcf42011-12-21 14:48:43 -0800336store_mem_state(struct device *dev,
337 struct device_attribute *attr, const char *buf, size_t count)
Dave Hansen3947be12005-10-29 18:16:54 -0700338{
339 struct memory_block *mem;
Dave Hansen3947be12005-10-29 18:16:54 -0700340 int ret = -EINVAL;
341
Kay Sievers10fbcf42011-12-21 14:48:43 -0800342 mem = container_of(dev, struct memory_block, dev);
Dave Hansen3947be12005-10-29 18:16:54 -0700343
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800344 if (!strncmp(buf, "online_kernel", min_t(int, count, 13)))
345 ret = memory_block_change_state(mem, MEM_ONLINE,
346 MEM_OFFLINE, ONLINE_KERNEL);
347 else if (!strncmp(buf, "online_movable", min_t(int, count, 14)))
348 ret = memory_block_change_state(mem, MEM_ONLINE,
349 MEM_OFFLINE, ONLINE_MOVABLE);
350 else if (!strncmp(buf, "online", min_t(int, count, 6)))
351 ret = memory_block_change_state(mem, MEM_ONLINE,
352 MEM_OFFLINE, ONLINE_KEEP);
353 else if(!strncmp(buf, "offline", min_t(int, count, 7)))
354 ret = memory_block_change_state(mem, MEM_OFFLINE,
355 MEM_ONLINE, -1);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600356
Dave Hansen3947be12005-10-29 18:16:54 -0700357 if (ret)
358 return ret;
359 return count;
360}
361
362/*
363 * phys_device is a bad name for this. What I really want
364 * is a way to differentiate between memory ranges that
365 * are part of physical devices that constitute
366 * a complete removable unit or fru.
367 * i.e. do these ranges belong to the same physical device,
368 * s.t. if I offline all of these sections I can then
369 * remove the physical device?
370 */
Kay Sievers10fbcf42011-12-21 14:48:43 -0800371static ssize_t show_phys_device(struct device *dev,
372 struct device_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700373{
374 struct memory_block *mem =
Kay Sievers10fbcf42011-12-21 14:48:43 -0800375 container_of(dev, struct memory_block, dev);
Dave Hansen3947be12005-10-29 18:16:54 -0700376 return sprintf(buf, "%d\n", mem->phys_device);
377}
378
Kay Sievers10fbcf42011-12-21 14:48:43 -0800379static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
380static DEVICE_ATTR(end_phys_index, 0444, show_mem_end_phys_index, NULL);
381static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
382static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
383static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
Dave Hansen3947be12005-10-29 18:16:54 -0700384
385#define mem_create_simple_file(mem, attr_name) \
Kay Sievers10fbcf42011-12-21 14:48:43 -0800386 device_create_file(&mem->dev, &dev_attr_##attr_name)
Dave Hansen3947be12005-10-29 18:16:54 -0700387#define mem_remove_simple_file(mem, attr_name) \
Kay Sievers10fbcf42011-12-21 14:48:43 -0800388 device_remove_file(&mem->dev, &dev_attr_##attr_name)
Dave Hansen3947be12005-10-29 18:16:54 -0700389
390/*
391 * Block size attribute stuff
392 */
393static ssize_t
Kay Sievers10fbcf42011-12-21 14:48:43 -0800394print_block_size(struct device *dev, struct device_attribute *attr,
Andi Kleen8564a6c2010-01-05 12:48:06 +0100395 char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700396{
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600397 return sprintf(buf, "%lx\n", get_memory_block_size());
Dave Hansen3947be12005-10-29 18:16:54 -0700398}
399
Kay Sievers10fbcf42011-12-21 14:48:43 -0800400static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL);
Dave Hansen3947be12005-10-29 18:16:54 -0700401
402static int block_size_init(void)
403{
Kay Sievers10fbcf42011-12-21 14:48:43 -0800404 return device_create_file(memory_subsys.dev_root,
405 &dev_attr_block_size_bytes);
Dave Hansen3947be12005-10-29 18:16:54 -0700406}
407
408/*
409 * Some architectures will have custom drivers to do this, and
410 * will not need to do it from userspace. The fake hot-add code
411 * as well as ppc64 will do all of their discovery in userspace
412 * and will require this interface.
413 */
414#ifdef CONFIG_ARCH_MEMORY_PROBE
415static ssize_t
Kay Sievers10fbcf42011-12-21 14:48:43 -0800416memory_probe_store(struct device *dev, struct device_attribute *attr,
Andi Kleen28812fe2010-01-05 12:48:07 +0100417 const char *buf, size_t count)
Dave Hansen3947be12005-10-29 18:16:54 -0700418{
419 u64 phys_addr;
Yasunori Gotobc02af92006-06-27 02:53:30 -0700420 int nid;
Nathan Fontenot6add7cd2011-01-31 10:55:23 -0600421 int i, ret;
Anton Blanchard61b94fe2011-09-15 06:26:15 +1000422 unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block;
Dave Hansen3947be12005-10-29 18:16:54 -0700423
424 phys_addr = simple_strtoull(buf, NULL, 0);
425
Anton Blanchard61b94fe2011-09-15 06:26:15 +1000426 if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
427 return -EINVAL;
428
Nathan Fontenot6add7cd2011-01-31 10:55:23 -0600429 for (i = 0; i < sections_per_block; i++) {
430 nid = memory_add_physaddr_to_nid(phys_addr);
431 ret = add_memory(nid, phys_addr,
432 PAGES_PER_SECTION << PAGE_SHIFT);
433 if (ret)
Nikanth Karthikesan9f0af692011-03-24 11:46:18 +0530434 goto out;
Nathan Fontenot6add7cd2011-01-31 10:55:23 -0600435
436 phys_addr += MIN_MEMORY_BLOCK_SIZE;
437 }
Dave Hansen3947be12005-10-29 18:16:54 -0700438
Nikanth Karthikesan9f0af692011-03-24 11:46:18 +0530439 ret = count;
440out:
441 return ret;
Dave Hansen3947be12005-10-29 18:16:54 -0700442}
Kay Sievers10fbcf42011-12-21 14:48:43 -0800443static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
Dave Hansen3947be12005-10-29 18:16:54 -0700444
445static int memory_probe_init(void)
446{
Kay Sievers10fbcf42011-12-21 14:48:43 -0800447 return device_create_file(memory_subsys.dev_root, &dev_attr_probe);
Dave Hansen3947be12005-10-29 18:16:54 -0700448}
449#else
Andrew Morton28ec24e2006-12-06 20:37:29 -0800450static inline int memory_probe_init(void)
451{
452 return 0;
453}
Dave Hansen3947be12005-10-29 18:16:54 -0700454#endif
455
Andi Kleenfacb6012009-12-16 12:20:00 +0100456#ifdef CONFIG_MEMORY_FAILURE
457/*
458 * Support for offlining pages of memory
459 */
460
461/* Soft offline a page */
462static ssize_t
Kay Sievers10fbcf42011-12-21 14:48:43 -0800463store_soft_offline_page(struct device *dev,
464 struct device_attribute *attr,
Andi Kleen28812fe2010-01-05 12:48:07 +0100465 const char *buf, size_t count)
Andi Kleenfacb6012009-12-16 12:20:00 +0100466{
467 int ret;
468 u64 pfn;
469 if (!capable(CAP_SYS_ADMIN))
470 return -EPERM;
471 if (strict_strtoull(buf, 0, &pfn) < 0)
472 return -EINVAL;
473 pfn >>= PAGE_SHIFT;
474 if (!pfn_valid(pfn))
475 return -ENXIO;
476 ret = soft_offline_page(pfn_to_page(pfn), 0);
477 return ret == 0 ? count : ret;
478}
479
480/* Forcibly offline a page, including killing processes. */
481static ssize_t
Kay Sievers10fbcf42011-12-21 14:48:43 -0800482store_hard_offline_page(struct device *dev,
483 struct device_attribute *attr,
Andi Kleen28812fe2010-01-05 12:48:07 +0100484 const char *buf, size_t count)
Andi Kleenfacb6012009-12-16 12:20:00 +0100485{
486 int ret;
487 u64 pfn;
488 if (!capable(CAP_SYS_ADMIN))
489 return -EPERM;
490 if (strict_strtoull(buf, 0, &pfn) < 0)
491 return -EINVAL;
492 pfn >>= PAGE_SHIFT;
Tony Luckcd42f4a2011-12-15 10:48:12 -0800493 ret = memory_failure(pfn, 0, 0);
Andi Kleenfacb6012009-12-16 12:20:00 +0100494 return ret ? ret : count;
495}
496
Kay Sievers10fbcf42011-12-21 14:48:43 -0800497static DEVICE_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
498static DEVICE_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
Andi Kleenfacb6012009-12-16 12:20:00 +0100499
500static __init int memory_fail_init(void)
501{
502 int err;
503
Kay Sievers10fbcf42011-12-21 14:48:43 -0800504 err = device_create_file(memory_subsys.dev_root,
505 &dev_attr_soft_offline_page);
Andi Kleenfacb6012009-12-16 12:20:00 +0100506 if (!err)
Kay Sievers10fbcf42011-12-21 14:48:43 -0800507 err = device_create_file(memory_subsys.dev_root,
508 &dev_attr_hard_offline_page);
Andi Kleenfacb6012009-12-16 12:20:00 +0100509 return err;
510}
511#else
512static inline int memory_fail_init(void)
513{
514 return 0;
515}
516#endif
517
Dave Hansen3947be12005-10-29 18:16:54 -0700518/*
519 * Note that phys_device is optional. It is here to allow for
520 * differentiation between which *physical* devices each
521 * section belongs to...
522 */
Heiko Carstensbc32df02010-03-15 00:35:03 -0400523int __weak arch_get_memory_phys_device(unsigned long start_pfn)
524{
525 return 0;
526}
Dave Hansen3947be12005-10-29 18:16:54 -0700527
Kay Sievers10fbcf42011-12-21 14:48:43 -0800528/*
529 * A reference for the returned object is held and the reference for the
530 * hinted object is released.
531 */
Robin Holt98383032010-09-29 14:00:55 -0500532struct memory_block *find_memory_block_hinted(struct mem_section *section,
533 struct memory_block *hint)
534{
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600535 int block_id = base_memory_block_id(__section_nr(section));
Kay Sievers10fbcf42011-12-21 14:48:43 -0800536 struct device *hintdev = hint ? &hint->dev : NULL;
537 struct device *dev;
Robin Holt98383032010-09-29 14:00:55 -0500538
Kay Sievers10fbcf42011-12-21 14:48:43 -0800539 dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev);
540 if (hint)
541 put_device(&hint->dev);
542 if (!dev)
Robin Holt98383032010-09-29 14:00:55 -0500543 return NULL;
Kay Sievers10fbcf42011-12-21 14:48:43 -0800544 return container_of(dev, struct memory_block, dev);
Robin Holt98383032010-09-29 14:00:55 -0500545}
546
Dave Hansen3947be12005-10-29 18:16:54 -0700547/*
548 * For now, we have a linear search to go find the appropriate
549 * memory_block corresponding to a particular phys_index. If
550 * this gets to be a real problem, we can always use a radix
551 * tree or something here.
552 *
Kay Sievers10fbcf42011-12-21 14:48:43 -0800553 * This could be made generic for all device subsystems.
Dave Hansen3947be12005-10-29 18:16:54 -0700554 */
Gary Hadec04fc582009-01-06 14:39:14 -0800555struct memory_block *find_memory_block(struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -0700556{
Robin Holt98383032010-09-29 14:00:55 -0500557 return find_memory_block_hinted(section, NULL);
Dave Hansen3947be12005-10-29 18:16:54 -0700558}
559
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600560static int init_memory_block(struct memory_block **memory,
561 struct mem_section *section, unsigned long state)
Nathan Fontenote4619c82010-10-19 12:44:20 -0500562{
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600563 struct memory_block *mem;
Nathan Fontenote4619c82010-10-19 12:44:20 -0500564 unsigned long start_pfn;
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600565 int scn_nr;
Nathan Fontenote4619c82010-10-19 12:44:20 -0500566 int ret = 0;
567
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600568 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
Nathan Fontenote4619c82010-10-19 12:44:20 -0500569 if (!mem)
570 return -ENOMEM;
571
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600572 scn_nr = __section_nr(section);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600573 mem->start_section_nr =
574 base_memory_block_id(scn_nr) * sections_per_block;
575 mem->end_section_nr = mem->start_section_nr + sections_per_block - 1;
Nathan Fontenote4619c82010-10-19 12:44:20 -0500576 mem->state = state;
Nathan Fontenot07681212010-10-19 12:46:19 -0500577 mem->section_count++;
Nathan Fontenote4619c82010-10-19 12:44:20 -0500578 mutex_init(&mem->state_mutex);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600579 start_pfn = section_nr_to_pfn(mem->start_section_nr);
Nathan Fontenote4619c82010-10-19 12:44:20 -0500580 mem->phys_device = arch_get_memory_phys_device(start_pfn);
581
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600582 ret = register_memory(mem);
Nathan Fontenote4619c82010-10-19 12:44:20 -0500583 if (!ret)
584 ret = mem_create_simple_file(mem, phys_index);
585 if (!ret)
Nathan Fontenotd3360162011-01-20 10:44:29 -0600586 ret = mem_create_simple_file(mem, end_phys_index);
587 if (!ret)
Nathan Fontenote4619c82010-10-19 12:44:20 -0500588 ret = mem_create_simple_file(mem, state);
589 if (!ret)
590 ret = mem_create_simple_file(mem, phys_device);
591 if (!ret)
592 ret = mem_create_simple_file(mem, removable);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600593
594 *memory = mem;
595 return ret;
596}
597
598static int add_memory_section(int nid, struct mem_section *section,
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800599 struct memory_block **mem_p,
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600600 unsigned long state, enum mem_add_context context)
601{
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800602 struct memory_block *mem = NULL;
603 int scn_nr = __section_nr(section);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600604 int ret = 0;
605
606 mutex_lock(&mem_sysfs_mutex);
607
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800608 if (context == BOOT) {
609 /* same memory block ? */
610 if (mem_p && *mem_p)
611 if (scn_nr >= (*mem_p)->start_section_nr &&
612 scn_nr <= (*mem_p)->end_section_nr) {
613 mem = *mem_p;
614 kobject_get(&mem->dev.kobj);
615 }
616 } else
617 mem = find_memory_block(section);
618
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600619 if (mem) {
620 mem->section_count++;
Kay Sievers10fbcf42011-12-21 14:48:43 -0800621 kobject_put(&mem->dev.kobj);
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800622 } else {
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600623 ret = init_memory_block(&mem, section, state);
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800624 /* store memory_block pointer for next loop */
625 if (!ret && context == BOOT)
626 if (mem_p)
627 *mem_p = mem;
628 }
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600629
Nathan Fontenote4619c82010-10-19 12:44:20 -0500630 if (!ret) {
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600631 if (context == HOTPLUG &&
632 mem->section_count == sections_per_block)
Nathan Fontenote4619c82010-10-19 12:44:20 -0500633 ret = register_mem_sect_under_node(mem, nid);
634 }
635
Nathan Fontenot2938ffb2010-10-19 12:45:24 -0500636 mutex_unlock(&mem_sysfs_mutex);
Nathan Fontenote4619c82010-10-19 12:44:20 -0500637 return ret;
638}
639
Dave Hansen3947be12005-10-29 18:16:54 -0700640int remove_memory_block(unsigned long node_id, struct mem_section *section,
641 int phys_device)
642{
643 struct memory_block *mem;
644
Nathan Fontenot2938ffb2010-10-19 12:45:24 -0500645 mutex_lock(&mem_sysfs_mutex);
Dave Hansen3947be12005-10-29 18:16:54 -0700646 mem = find_memory_block(section);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600647 unregister_mem_sect_under_nodes(mem, __section_nr(section));
Nathan Fontenot07681212010-10-19 12:46:19 -0500648
649 mem->section_count--;
650 if (mem->section_count == 0) {
Nathan Fontenot07681212010-10-19 12:46:19 -0500651 mem_remove_simple_file(mem, phys_index);
Nathan Fontenotd3360162011-01-20 10:44:29 -0600652 mem_remove_simple_file(mem, end_phys_index);
Nathan Fontenot07681212010-10-19 12:46:19 -0500653 mem_remove_simple_file(mem, state);
654 mem_remove_simple_file(mem, phys_device);
655 mem_remove_simple_file(mem, removable);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600656 unregister_memory(mem);
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600657 } else
Kay Sievers10fbcf42011-12-21 14:48:43 -0800658 kobject_put(&mem->dev.kobj);
Dave Hansen3947be12005-10-29 18:16:54 -0700659
Nathan Fontenot2938ffb2010-10-19 12:45:24 -0500660 mutex_unlock(&mem_sysfs_mutex);
Dave Hansen3947be12005-10-29 18:16:54 -0700661 return 0;
662}
663
664/*
665 * need an interface for the VM to add new memory regions,
666 * but without onlining it.
667 */
Gary Hadec04fc582009-01-06 14:39:14 -0800668int register_new_memory(int nid, struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -0700669{
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800670 return add_memory_section(nid, section, NULL, MEM_OFFLINE, HOTPLUG);
Dave Hansen3947be12005-10-29 18:16:54 -0700671}
672
673int unregister_memory_section(struct mem_section *section)
674{
Andy Whitcroft540557b2007-10-16 01:24:11 -0700675 if (!present_section(section))
Dave Hansen3947be12005-10-29 18:16:54 -0700676 return -EINVAL;
677
678 return remove_memory_block(0, section, 0);
679}
680
681/*
Wen Congyange90bdb72012-10-08 16:34:01 -0700682 * offline one memory block. If the memory block has been offlined, do nothing.
683 */
684int offline_memory_block(struct memory_block *mem)
685{
686 int ret = 0;
687
688 mutex_lock(&mem->state_mutex);
689 if (mem->state != MEM_OFFLINE)
Lai Jiangshan511c2ab2012-12-11 16:03:16 -0800690 ret = __memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE, -1);
Wen Congyange90bdb72012-10-08 16:34:01 -0700691 mutex_unlock(&mem->state_mutex);
692
693 return ret;
694}
695
696/*
Dave Hansen3947be12005-10-29 18:16:54 -0700697 * Initialize the sysfs support for memory devices...
698 */
699int __init memory_dev_init(void)
700{
701 unsigned int i;
702 int ret;
Andrew Morton28ec24e2006-12-06 20:37:29 -0800703 int err;
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600704 unsigned long block_sz;
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800705 struct memory_block *mem = NULL;
Dave Hansen3947be12005-10-29 18:16:54 -0700706
Kay Sievers10fbcf42011-12-21 14:48:43 -0800707 ret = subsys_system_register(&memory_subsys, NULL);
Andrew Morton28ec24e2006-12-06 20:37:29 -0800708 if (ret)
709 goto out;
Dave Hansen3947be12005-10-29 18:16:54 -0700710
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600711 block_sz = get_memory_block_size();
712 sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
713
Dave Hansen3947be12005-10-29 18:16:54 -0700714 /*
715 * Create entries for memory sections that were found
716 * during boot and have been initialized
717 */
718 for (i = 0; i < NR_MEM_SECTIONS; i++) {
Andy Whitcroft540557b2007-10-16 01:24:11 -0700719 if (!present_section_nr(i))
Dave Hansen3947be12005-10-29 18:16:54 -0700720 continue;
Yinghai Lu321bf4e2012-01-30 13:57:12 -0800721 /* don't need to reuse memory_block if only one per block */
722 err = add_memory_section(0, __nr_to_section(i),
723 (sections_per_block == 1) ? NULL : &mem,
724 MEM_ONLINE,
Nathan Fontenot0c2c99b2011-01-20 10:43:34 -0600725 BOOT);
Andrew Morton28ec24e2006-12-06 20:37:29 -0800726 if (!ret)
727 ret = err;
Dave Hansen3947be12005-10-29 18:16:54 -0700728 }
729
Andrew Morton28ec24e2006-12-06 20:37:29 -0800730 err = memory_probe_init();
731 if (!ret)
732 ret = err;
Andi Kleenfacb6012009-12-16 12:20:00 +0100733 err = memory_fail_init();
734 if (!ret)
735 ret = err;
Andrew Morton28ec24e2006-12-06 20:37:29 -0800736 err = block_size_init();
737 if (!ret)
738 ret = err;
739out:
740 if (ret)
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800741 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
Dave Hansen3947be12005-10-29 18:16:54 -0700742 return ret;
743}