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 <asm/atomic.h>
25 #include <asm/uaccess.h>
27 #define MEMORY_CLASS_NAME "memory"
29 static struct sysdev_class memory_sysdev_class = {
30 .name = MEMORY_CLASS_NAME,
33 static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
35 return MEMORY_CLASS_NAME;
38 static int memory_uevent(struct kset *kset, struct kobject *obj, struct kobj_uevent_env *env)
45 static struct kset_uevent_ops memory_uevent_ops = {
46 .name = memory_uevent_name,
47 .uevent = memory_uevent,
50 static BLOCKING_NOTIFIER_HEAD(memory_chain);
52 int register_memory_notifier(struct notifier_block *nb)
54 return blocking_notifier_chain_register(&memory_chain, nb);
57 void unregister_memory_notifier(struct notifier_block *nb)
59 blocking_notifier_chain_unregister(&memory_chain, nb);
63 * register_memory - Setup a sysfs device for a memory block
65 int register_memory(struct memory_block *memory, struct mem_section *section,
70 memory->sysdev.cls = &memory_sysdev_class;
71 memory->sysdev.id = __section_nr(section);
73 error = sysdev_register(&memory->sysdev);
76 error = sysfs_create_link(&root->sysdev.kobj,
78 kobject_name(&memory->sysdev.kobj));
84 unregister_memory(struct memory_block *memory, struct mem_section *section,
87 BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
88 BUG_ON(memory->sysdev.id != __section_nr(section));
90 sysdev_unregister(&memory->sysdev);
92 sysfs_remove_link(&root->sysdev.kobj,
93 kobject_name(&memory->sysdev.kobj));
97 * use this as the physical section index that this memsection
101 static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
103 struct memory_block *mem =
104 container_of(dev, struct memory_block, sysdev);
105 return sprintf(buf, "%08lx\n", mem->phys_index);
109 * online, offline, going offline, etc.
111 static ssize_t show_mem_state(struct sys_device *dev, char *buf)
113 struct memory_block *mem =
114 container_of(dev, struct memory_block, sysdev);
118 * We can probably put these states in a nice little array
119 * so that they're not open-coded
121 switch (mem->state) {
123 len = sprintf(buf, "online\n");
126 len = sprintf(buf, "offline\n");
128 case MEM_GOING_OFFLINE:
129 len = sprintf(buf, "going-offline\n");
132 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
141 int memory_notify(unsigned long val, void *v)
143 return blocking_notifier_call_chain(&memory_chain, val, v);
147 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
148 * OK to have direct references to sparsemem variables in here.
151 memory_block_action(struct memory_block *mem, unsigned long action)
154 unsigned long psection;
155 unsigned long start_pfn, start_paddr;
156 struct page *first_page;
158 int old_state = mem->state;
160 psection = mem->phys_index;
161 first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
164 * The probe routines leave the pages reserved, just
165 * as the bootmem code does. Make sure they're still
168 if (action == MEM_ONLINE) {
169 for (i = 0; i < PAGES_PER_SECTION; i++) {
170 if (PageReserved(first_page+i))
173 printk(KERN_WARNING "section number %ld page number %d "
174 "not reserved, was it already online? \n",
182 start_pfn = page_to_pfn(first_page);
183 ret = online_pages(start_pfn, PAGES_PER_SECTION);
186 mem->state = MEM_GOING_OFFLINE;
187 start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
188 ret = remove_memory(start_paddr,
189 PAGES_PER_SECTION << PAGE_SHIFT);
191 mem->state = old_state;
196 printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
197 __FUNCTION__, mem, action, action);
205 static int memory_block_change_state(struct memory_block *mem,
206 unsigned long to_state, unsigned long from_state_req)
209 mutex_lock(&mem->state_mutex);
211 if (mem->state != from_state_req) {
216 ret = memory_block_action(mem, to_state);
218 mem->state = to_state;
221 mutex_unlock(&mem->state_mutex);
226 store_mem_state(struct sys_device *dev, const char *buf, size_t count)
228 struct memory_block *mem;
229 unsigned int phys_section_nr;
232 mem = container_of(dev, struct memory_block, sysdev);
233 phys_section_nr = mem->phys_index;
235 if (!present_section_nr(phys_section_nr))
238 if (!strncmp(buf, "online", min((int)count, 6)))
239 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
240 else if(!strncmp(buf, "offline", min((int)count, 7)))
241 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
249 * phys_device is a bad name for this. What I really want
250 * is a way to differentiate between memory ranges that
251 * are part of physical devices that constitute
252 * a complete removable unit or fru.
253 * i.e. do these ranges belong to the same physical device,
254 * s.t. if I offline all of these sections I can then
255 * remove the physical device?
257 static ssize_t show_phys_device(struct sys_device *dev, char *buf)
259 struct memory_block *mem =
260 container_of(dev, struct memory_block, sysdev);
261 return sprintf(buf, "%d\n", mem->phys_device);
264 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
265 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
266 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
268 #define mem_create_simple_file(mem, attr_name) \
269 sysdev_create_file(&mem->sysdev, &attr_##attr_name)
270 #define mem_remove_simple_file(mem, attr_name) \
271 sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
274 * Block size attribute stuff
277 print_block_size(struct class *class, char *buf)
279 return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
282 static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
284 static int block_size_init(void)
286 return sysfs_create_file(&memory_sysdev_class.kset.kobj,
287 &class_attr_block_size_bytes.attr);
291 * Some architectures will have custom drivers to do this, and
292 * will not need to do it from userspace. The fake hot-add code
293 * as well as ppc64 will do all of their discovery in userspace
294 * and will require this interface.
296 #ifdef CONFIG_ARCH_MEMORY_PROBE
298 memory_probe_store(struct class *class, const char *buf, size_t count)
304 phys_addr = simple_strtoull(buf, NULL, 0);
306 nid = memory_add_physaddr_to_nid(phys_addr);
307 ret = add_memory(nid, phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
314 static CLASS_ATTR(probe, 0700, NULL, memory_probe_store);
316 static int memory_probe_init(void)
318 return sysfs_create_file(&memory_sysdev_class.kset.kobj,
319 &class_attr_probe.attr);
322 static inline int memory_probe_init(void)
329 * Note that phys_device is optional. It is here to allow for
330 * differentiation between which *physical* devices each
331 * section belongs to...
334 static int add_memory_block(unsigned long node_id, struct mem_section *section,
335 unsigned long state, int phys_device)
337 struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
343 mem->phys_index = __section_nr(section);
345 mutex_init(&mem->state_mutex);
346 mem->phys_device = phys_device;
348 ret = register_memory(mem, section, NULL);
350 ret = mem_create_simple_file(mem, phys_index);
352 ret = mem_create_simple_file(mem, state);
354 ret = mem_create_simple_file(mem, phys_device);
360 * For now, we have a linear search to go find the appropriate
361 * memory_block corresponding to a particular phys_index. If
362 * this gets to be a real problem, we can always use a radix
363 * tree or something here.
365 * This could be made generic for all sysdev classes.
367 static struct memory_block *find_memory_block(struct mem_section *section)
369 struct kobject *kobj;
370 struct sys_device *sysdev;
371 struct memory_block *mem;
372 char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
375 * This only works because we know that section == sysdev->id
376 * slightly redundant with sysdev_register()
378 sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
380 kobj = kset_find_obj(&memory_sysdev_class.kset, name);
384 sysdev = container_of(kobj, struct sys_device, kobj);
385 mem = container_of(sysdev, struct memory_block, sysdev);
390 int remove_memory_block(unsigned long node_id, struct mem_section *section,
393 struct memory_block *mem;
395 mem = find_memory_block(section);
396 mem_remove_simple_file(mem, phys_index);
397 mem_remove_simple_file(mem, state);
398 mem_remove_simple_file(mem, phys_device);
399 unregister_memory(mem, section, NULL);
405 * need an interface for the VM to add new memory regions,
406 * but without onlining it.
408 int register_new_memory(struct mem_section *section)
410 return add_memory_block(0, section, MEM_OFFLINE, 0);
413 int unregister_memory_section(struct mem_section *section)
415 if (!present_section(section))
418 return remove_memory_block(0, section, 0);
422 * Initialize the sysfs support for memory devices...
424 int __init memory_dev_init(void)
430 memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
431 ret = sysdev_class_register(&memory_sysdev_class);
436 * Create entries for memory sections that were found
437 * during boot and have been initialized
439 for (i = 0; i < NR_MEM_SECTIONS; i++) {
440 if (!present_section_nr(i))
442 err = add_memory_block(0, __nr_to_section(i), MEM_ONLINE, 0);
447 err = memory_probe_init();
450 err = block_size_init();
455 printk(KERN_ERR "%s() failed: %d\n", __FUNCTION__, ret);