2 * drivers/base/memory.c - basic Memory class support
4 * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
5 * Dave Hansen <haveblue@us.ibm.com>
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.
13 #include <linux/sysdev.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/topology.h>
17 #include <linux/capability.h>
18 #include <linux/device.h>
19 #include <linux/memory.h>
20 #include <linux/kobject.h>
21 #include <linux/memory_hotplug.h>
23 #include <linux/mutex.h>
24 #include <linux/stat.h>
26 #include <asm/atomic.h>
27 #include <asm/uaccess.h>
29 #define MEMORY_CLASS_NAME "memory"
31 static struct sysdev_class memory_sysdev_class
= {
32 .name
= MEMORY_CLASS_NAME
,
35 static const char *memory_uevent_name(struct kset
*kset
, struct kobject
*kobj
)
37 return MEMORY_CLASS_NAME
;
40 static int memory_uevent(struct kset
*kset
, struct kobject
*obj
, struct kobj_uevent_env
*env
)
47 static struct kset_uevent_ops memory_uevent_ops
= {
48 .name
= memory_uevent_name
,
49 .uevent
= memory_uevent
,
52 static BLOCKING_NOTIFIER_HEAD(memory_chain
);
54 int register_memory_notifier(struct notifier_block
*nb
)
56 return blocking_notifier_chain_register(&memory_chain
, nb
);
58 EXPORT_SYMBOL(register_memory_notifier
);
60 void unregister_memory_notifier(struct notifier_block
*nb
)
62 blocking_notifier_chain_unregister(&memory_chain
, nb
);
64 EXPORT_SYMBOL(unregister_memory_notifier
);
66 static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain
);
68 int register_memory_isolate_notifier(struct notifier_block
*nb
)
70 return atomic_notifier_chain_register(&memory_isolate_chain
, nb
);
72 EXPORT_SYMBOL(register_memory_isolate_notifier
);
74 void unregister_memory_isolate_notifier(struct notifier_block
*nb
)
76 atomic_notifier_chain_unregister(&memory_isolate_chain
, nb
);
78 EXPORT_SYMBOL(unregister_memory_isolate_notifier
);
81 * register_memory - Setup a sysfs device for a memory block
84 int register_memory(struct memory_block
*memory
, struct mem_section
*section
)
88 memory
->sysdev
.cls
= &memory_sysdev_class
;
89 memory
->sysdev
.id
= __section_nr(section
);
91 error
= sysdev_register(&memory
->sysdev
);
96 unregister_memory(struct memory_block
*memory
, struct mem_section
*section
)
98 BUG_ON(memory
->sysdev
.cls
!= &memory_sysdev_class
);
99 BUG_ON(memory
->sysdev
.id
!= __section_nr(section
));
101 /* drop the ref. we got in remove_memory_block() */
102 kobject_put(&memory
->sysdev
.kobj
);
103 sysdev_unregister(&memory
->sysdev
);
107 * use this as the physical section index that this memsection
111 static ssize_t
show_mem_phys_index(struct sys_device
*dev
,
112 struct sysdev_attribute
*attr
, char *buf
)
114 struct memory_block
*mem
=
115 container_of(dev
, struct memory_block
, sysdev
);
116 return sprintf(buf
, "%08lx\n", mem
->phys_index
);
120 * Show whether the section of memory is likely to be hot-removable
122 static ssize_t
show_mem_removable(struct sys_device
*dev
,
123 struct sysdev_attribute
*attr
, char *buf
)
125 unsigned long start_pfn
;
127 struct memory_block
*mem
=
128 container_of(dev
, struct memory_block
, sysdev
);
130 start_pfn
= section_nr_to_pfn(mem
->phys_index
);
131 ret
= is_mem_section_removable(start_pfn
, PAGES_PER_SECTION
);
132 return sprintf(buf
, "%d\n", ret
);
136 * online, offline, going offline, etc.
138 static ssize_t
show_mem_state(struct sys_device
*dev
,
139 struct sysdev_attribute
*attr
, char *buf
)
141 struct memory_block
*mem
=
142 container_of(dev
, struct memory_block
, sysdev
);
146 * We can probably put these states in a nice little array
147 * so that they're not open-coded
149 switch (mem
->state
) {
151 len
= sprintf(buf
, "online\n");
154 len
= sprintf(buf
, "offline\n");
156 case MEM_GOING_OFFLINE
:
157 len
= sprintf(buf
, "going-offline\n");
160 len
= sprintf(buf
, "ERROR-UNKNOWN-%ld\n",
169 int memory_notify(unsigned long val
, void *v
)
171 return blocking_notifier_call_chain(&memory_chain
, val
, v
);
174 int memory_isolate_notify(unsigned long val
, void *v
)
176 return atomic_notifier_call_chain(&memory_isolate_chain
, val
, v
);
180 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
181 * OK to have direct references to sparsemem variables in here.
184 memory_block_action(struct memory_block
*mem
, unsigned long action
)
187 unsigned long psection
;
188 unsigned long start_pfn
, start_paddr
;
189 struct page
*first_page
;
191 int old_state
= mem
->state
;
193 psection
= mem
->phys_index
;
194 first_page
= pfn_to_page(psection
<< PFN_SECTION_SHIFT
);
197 * The probe routines leave the pages reserved, just
198 * as the bootmem code does. Make sure they're still
201 if (action
== MEM_ONLINE
) {
202 for (i
= 0; i
< PAGES_PER_SECTION
; i
++) {
203 if (PageReserved(first_page
+i
))
206 printk(KERN_WARNING
"section number %ld page number %d "
207 "not reserved, was it already online? \n",
215 start_pfn
= page_to_pfn(first_page
);
216 ret
= online_pages(start_pfn
, PAGES_PER_SECTION
);
219 mem
->state
= MEM_GOING_OFFLINE
;
220 start_paddr
= page_to_pfn(first_page
) << PAGE_SHIFT
;
221 ret
= remove_memory(start_paddr
,
222 PAGES_PER_SECTION
<< PAGE_SHIFT
);
224 mem
->state
= old_state
;
229 WARN(1, KERN_WARNING
"%s(%p, %ld) unknown action: %ld\n",
230 __func__
, mem
, action
, action
);
237 static int memory_block_change_state(struct memory_block
*mem
,
238 unsigned long to_state
, unsigned long from_state_req
)
241 mutex_lock(&mem
->state_mutex
);
243 if (mem
->state
!= from_state_req
) {
248 ret
= memory_block_action(mem
, to_state
);
250 mem
->state
= to_state
;
253 mutex_unlock(&mem
->state_mutex
);
258 store_mem_state(struct sys_device
*dev
,
259 struct sysdev_attribute
*attr
, const char *buf
, size_t count
)
261 struct memory_block
*mem
;
262 unsigned int phys_section_nr
;
265 mem
= container_of(dev
, struct memory_block
, sysdev
);
266 phys_section_nr
= mem
->phys_index
;
268 if (!present_section_nr(phys_section_nr
))
271 if (!strncmp(buf
, "online", min((int)count
, 6)))
272 ret
= memory_block_change_state(mem
, MEM_ONLINE
, MEM_OFFLINE
);
273 else if(!strncmp(buf
, "offline", min((int)count
, 7)))
274 ret
= memory_block_change_state(mem
, MEM_OFFLINE
, MEM_ONLINE
);
282 * phys_device is a bad name for this. What I really want
283 * is a way to differentiate between memory ranges that
284 * are part of physical devices that constitute
285 * a complete removable unit or fru.
286 * i.e. do these ranges belong to the same physical device,
287 * s.t. if I offline all of these sections I can then
288 * remove the physical device?
290 static ssize_t
show_phys_device(struct sys_device
*dev
,
291 struct sysdev_attribute
*attr
, char *buf
)
293 struct memory_block
*mem
=
294 container_of(dev
, struct memory_block
, sysdev
);
295 return sprintf(buf
, "%d\n", mem
->phys_device
);
298 static SYSDEV_ATTR(phys_index
, 0444, show_mem_phys_index
, NULL
);
299 static SYSDEV_ATTR(state
, 0644, show_mem_state
, store_mem_state
);
300 static SYSDEV_ATTR(phys_device
, 0444, show_phys_device
, NULL
);
301 static SYSDEV_ATTR(removable
, 0444, show_mem_removable
, NULL
);
303 #define mem_create_simple_file(mem, attr_name) \
304 sysdev_create_file(&mem->sysdev, &attr_##attr_name)
305 #define mem_remove_simple_file(mem, attr_name) \
306 sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
309 * Block size attribute stuff
312 print_block_size(struct sysdev_class
*class,
313 struct sysdev_class_attribute
*class_attr
,
316 return sprintf(buf
, "%#lx\n", (unsigned long)PAGES_PER_SECTION
* PAGE_SIZE
);
319 static SYSDEV_CLASS_ATTR(block_size_bytes
, 0444, print_block_size
, NULL
);
321 static int block_size_init(void)
323 return sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
324 &attr_block_size_bytes
.attr
);
328 * Some architectures will have custom drivers to do this, and
329 * will not need to do it from userspace. The fake hot-add code
330 * as well as ppc64 will do all of their discovery in userspace
331 * and will require this interface.
333 #ifdef CONFIG_ARCH_MEMORY_PROBE
335 memory_probe_store(struct sysdev_class
*class,
336 struct sysdev_class_attribute
*class_attr
,
337 const char *buf
, size_t count
)
343 phys_addr
= simple_strtoull(buf
, NULL
, 0);
345 nid
= memory_add_physaddr_to_nid(phys_addr
);
346 ret
= add_memory(nid
, phys_addr
, PAGES_PER_SECTION
<< PAGE_SHIFT
);
353 static SYSDEV_CLASS_ATTR(probe
, S_IWUSR
, NULL
, memory_probe_store
);
355 static int memory_probe_init(void)
357 return sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
361 static inline int memory_probe_init(void)
367 #ifdef CONFIG_MEMORY_FAILURE
369 * Support for offlining pages of memory
372 /* Soft offline a page */
374 store_soft_offline_page(struct sysdev_class
*class,
375 struct sysdev_class_attribute
*class_attr
,
376 const char *buf
, size_t count
)
380 if (!capable(CAP_SYS_ADMIN
))
382 if (strict_strtoull(buf
, 0, &pfn
) < 0)
387 ret
= soft_offline_page(pfn_to_page(pfn
), 0);
388 return ret
== 0 ? count
: ret
;
391 /* Forcibly offline a page, including killing processes. */
393 store_hard_offline_page(struct sysdev_class
*class,
394 struct sysdev_class_attribute
*class_attr
,
395 const char *buf
, size_t count
)
399 if (!capable(CAP_SYS_ADMIN
))
401 if (strict_strtoull(buf
, 0, &pfn
) < 0)
404 ret
= __memory_failure(pfn
, 0, 0);
405 return ret
? ret
: count
;
408 static SYSDEV_CLASS_ATTR(soft_offline_page
, 0644, NULL
, store_soft_offline_page
);
409 static SYSDEV_CLASS_ATTR(hard_offline_page
, 0644, NULL
, store_hard_offline_page
);
411 static __init
int memory_fail_init(void)
415 err
= sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
416 &attr_soft_offline_page
.attr
);
418 err
= sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
419 &attr_hard_offline_page
.attr
);
423 static inline int memory_fail_init(void)
430 * Note that phys_device is optional. It is here to allow for
431 * differentiation between which *physical* devices each
432 * section belongs to...
435 static int add_memory_block(int nid
, struct mem_section
*section
,
436 unsigned long state
, int phys_device
,
437 enum mem_add_context context
)
439 struct memory_block
*mem
= kzalloc(sizeof(*mem
), GFP_KERNEL
);
445 mem
->phys_index
= __section_nr(section
);
447 mutex_init(&mem
->state_mutex
);
448 mem
->phys_device
= phys_device
;
450 ret
= register_memory(mem
, section
);
452 ret
= mem_create_simple_file(mem
, phys_index
);
454 ret
= mem_create_simple_file(mem
, state
);
456 ret
= mem_create_simple_file(mem
, phys_device
);
458 ret
= mem_create_simple_file(mem
, removable
);
460 if (context
== HOTPLUG
)
461 ret
= register_mem_sect_under_node(mem
, nid
);
468 * For now, we have a linear search to go find the appropriate
469 * memory_block corresponding to a particular phys_index. If
470 * this gets to be a real problem, we can always use a radix
471 * tree or something here.
473 * This could be made generic for all sysdev classes.
475 struct memory_block
*find_memory_block(struct mem_section
*section
)
477 struct kobject
*kobj
;
478 struct sys_device
*sysdev
;
479 struct memory_block
*mem
;
480 char name
[sizeof(MEMORY_CLASS_NAME
) + 9 + 1];
483 * This only works because we know that section == sysdev->id
484 * slightly redundant with sysdev_register()
486 sprintf(&name
[0], "%s%d", MEMORY_CLASS_NAME
, __section_nr(section
));
488 kobj
= kset_find_obj(&memory_sysdev_class
.kset
, name
);
492 sysdev
= container_of(kobj
, struct sys_device
, kobj
);
493 mem
= container_of(sysdev
, struct memory_block
, sysdev
);
498 int remove_memory_block(unsigned long node_id
, struct mem_section
*section
,
501 struct memory_block
*mem
;
503 mem
= find_memory_block(section
);
504 unregister_mem_sect_under_nodes(mem
);
505 mem_remove_simple_file(mem
, phys_index
);
506 mem_remove_simple_file(mem
, state
);
507 mem_remove_simple_file(mem
, phys_device
);
508 mem_remove_simple_file(mem
, removable
);
509 unregister_memory(mem
, section
);
515 * need an interface for the VM to add new memory regions,
516 * but without onlining it.
518 int register_new_memory(int nid
, struct mem_section
*section
)
520 return add_memory_block(nid
, section
, MEM_OFFLINE
, 0, HOTPLUG
);
523 int unregister_memory_section(struct mem_section
*section
)
525 if (!present_section(section
))
528 return remove_memory_block(0, section
, 0);
532 * Initialize the sysfs support for memory devices...
534 int __init
memory_dev_init(void)
540 memory_sysdev_class
.kset
.uevent_ops
= &memory_uevent_ops
;
541 ret
= sysdev_class_register(&memory_sysdev_class
);
546 * Create entries for memory sections that were found
547 * during boot and have been initialized
549 for (i
= 0; i
< NR_MEM_SECTIONS
; i
++) {
550 if (!present_section_nr(i
))
552 err
= add_memory_block(0, __nr_to_section(i
), MEM_ONLINE
,
558 err
= memory_probe_init();
561 err
= memory_fail_init();
564 err
= block_size_init();
569 printk(KERN_ERR
"%s() failed: %d\n", __func__
, ret
);