include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / base / memory.c
1 /*
2  * drivers/base/memory.c - basic Memory class support
3  *
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
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>
22 #include <linux/mm.h>
23 #include <linux/mutex.h>
24 #include <linux/stat.h>
25 #include <linux/slab.h>
26
27 #include <asm/atomic.h>
28 #include <asm/uaccess.h>
29
30 #define MEMORY_CLASS_NAME       "memory"
31
32 static struct sysdev_class memory_sysdev_class = {
33         .name = MEMORY_CLASS_NAME,
34 };
35
36 static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
37 {
38         return MEMORY_CLASS_NAME;
39 }
40
41 static int memory_uevent(struct kset *kset, struct kobject *obj, struct kobj_uevent_env *env)
42 {
43         int retval = 0;
44
45         return retval;
46 }
47
48 static const struct kset_uevent_ops memory_uevent_ops = {
49         .name           = memory_uevent_name,
50         .uevent         = memory_uevent,
51 };
52
53 static BLOCKING_NOTIFIER_HEAD(memory_chain);
54
55 int register_memory_notifier(struct notifier_block *nb)
56 {
57         return blocking_notifier_chain_register(&memory_chain, nb);
58 }
59 EXPORT_SYMBOL(register_memory_notifier);
60
61 void unregister_memory_notifier(struct notifier_block *nb)
62 {
63         blocking_notifier_chain_unregister(&memory_chain, nb);
64 }
65 EXPORT_SYMBOL(unregister_memory_notifier);
66
67 static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
68
69 int register_memory_isolate_notifier(struct notifier_block *nb)
70 {
71         return atomic_notifier_chain_register(&memory_isolate_chain, nb);
72 }
73 EXPORT_SYMBOL(register_memory_isolate_notifier);
74
75 void unregister_memory_isolate_notifier(struct notifier_block *nb)
76 {
77         atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
78 }
79 EXPORT_SYMBOL(unregister_memory_isolate_notifier);
80
81 /*
82  * register_memory - Setup a sysfs device for a memory block
83  */
84 static
85 int register_memory(struct memory_block *memory, struct mem_section *section)
86 {
87         int error;
88
89         memory->sysdev.cls = &memory_sysdev_class;
90         memory->sysdev.id = __section_nr(section);
91
92         error = sysdev_register(&memory->sysdev);
93         return error;
94 }
95
96 static void
97 unregister_memory(struct memory_block *memory, struct mem_section *section)
98 {
99         BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
100         BUG_ON(memory->sysdev.id != __section_nr(section));
101
102         /* drop the ref. we got in remove_memory_block() */
103         kobject_put(&memory->sysdev.kobj);
104         sysdev_unregister(&memory->sysdev);
105 }
106
107 /*
108  * use this as the physical section index that this memsection
109  * uses.
110  */
111
112 static ssize_t show_mem_phys_index(struct sys_device *dev,
113                         struct sysdev_attribute *attr, char *buf)
114 {
115         struct memory_block *mem =
116                 container_of(dev, struct memory_block, sysdev);
117         return sprintf(buf, "%08lx\n", mem->phys_index);
118 }
119
120 /*
121  * Show whether the section of memory is likely to be hot-removable
122  */
123 static ssize_t show_mem_removable(struct sys_device *dev,
124                         struct sysdev_attribute *attr, char *buf)
125 {
126         unsigned long start_pfn;
127         int ret;
128         struct memory_block *mem =
129                 container_of(dev, struct memory_block, sysdev);
130
131         start_pfn = section_nr_to_pfn(mem->phys_index);
132         ret = is_mem_section_removable(start_pfn, PAGES_PER_SECTION);
133         return sprintf(buf, "%d\n", ret);
134 }
135
136 /*
137  * online, offline, going offline, etc.
138  */
139 static ssize_t show_mem_state(struct sys_device *dev,
140                         struct sysdev_attribute *attr, char *buf)
141 {
142         struct memory_block *mem =
143                 container_of(dev, struct memory_block, sysdev);
144         ssize_t len = 0;
145
146         /*
147          * We can probably put these states in a nice little array
148          * so that they're not open-coded
149          */
150         switch (mem->state) {
151                 case MEM_ONLINE:
152                         len = sprintf(buf, "online\n");
153                         break;
154                 case MEM_OFFLINE:
155                         len = sprintf(buf, "offline\n");
156                         break;
157                 case MEM_GOING_OFFLINE:
158                         len = sprintf(buf, "going-offline\n");
159                         break;
160                 default:
161                         len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
162                                         mem->state);
163                         WARN_ON(1);
164                         break;
165         }
166
167         return len;
168 }
169
170 int memory_notify(unsigned long val, void *v)
171 {
172         return blocking_notifier_call_chain(&memory_chain, val, v);
173 }
174
175 int memory_isolate_notify(unsigned long val, void *v)
176 {
177         return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
178 }
179
180 /*
181  * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
182  * OK to have direct references to sparsemem variables in here.
183  */
184 static int
185 memory_block_action(struct memory_block *mem, unsigned long action)
186 {
187         int i;
188         unsigned long psection;
189         unsigned long start_pfn, start_paddr;
190         struct page *first_page;
191         int ret;
192         int old_state = mem->state;
193
194         psection = mem->phys_index;
195         first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
196
197         /*
198          * The probe routines leave the pages reserved, just
199          * as the bootmem code does.  Make sure they're still
200          * that way.
201          */
202         if (action == MEM_ONLINE) {
203                 for (i = 0; i < PAGES_PER_SECTION; i++) {
204                         if (PageReserved(first_page+i))
205                                 continue;
206
207                         printk(KERN_WARNING "section number %ld page number %d "
208                                 "not reserved, was it already online? \n",
209                                 psection, i);
210                         return -EBUSY;
211                 }
212         }
213
214         switch (action) {
215                 case MEM_ONLINE:
216                         start_pfn = page_to_pfn(first_page);
217                         ret = online_pages(start_pfn, PAGES_PER_SECTION);
218                         break;
219                 case MEM_OFFLINE:
220                         mem->state = MEM_GOING_OFFLINE;
221                         start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
222                         ret = remove_memory(start_paddr,
223                                             PAGES_PER_SECTION << PAGE_SHIFT);
224                         if (ret) {
225                                 mem->state = old_state;
226                                 break;
227                         }
228                         break;
229                 default:
230                         WARN(1, KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
231                                         __func__, mem, action, action);
232                         ret = -EINVAL;
233         }
234
235         return ret;
236 }
237
238 static int memory_block_change_state(struct memory_block *mem,
239                 unsigned long to_state, unsigned long from_state_req)
240 {
241         int ret = 0;
242         mutex_lock(&mem->state_mutex);
243
244         if (mem->state != from_state_req) {
245                 ret = -EINVAL;
246                 goto out;
247         }
248
249         ret = memory_block_action(mem, to_state);
250         if (!ret)
251                 mem->state = to_state;
252
253 out:
254         mutex_unlock(&mem->state_mutex);
255         return ret;
256 }
257
258 static ssize_t
259 store_mem_state(struct sys_device *dev,
260                 struct sysdev_attribute *attr, const char *buf, size_t count)
261 {
262         struct memory_block *mem;
263         unsigned int phys_section_nr;
264         int ret = -EINVAL;
265
266         mem = container_of(dev, struct memory_block, sysdev);
267         phys_section_nr = mem->phys_index;
268
269         if (!present_section_nr(phys_section_nr))
270                 goto out;
271
272         if (!strncmp(buf, "online", min((int)count, 6)))
273                 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
274         else if(!strncmp(buf, "offline", min((int)count, 7)))
275                 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
276 out:
277         if (ret)
278                 return ret;
279         return count;
280 }
281
282 /*
283  * phys_device is a bad name for this.  What I really want
284  * is a way to differentiate between memory ranges that
285  * are part of physical devices that constitute
286  * a complete removable unit or fru.
287  * i.e. do these ranges belong to the same physical device,
288  * s.t. if I offline all of these sections I can then
289  * remove the physical device?
290  */
291 static ssize_t show_phys_device(struct sys_device *dev,
292                                 struct sysdev_attribute *attr, char *buf)
293 {
294         struct memory_block *mem =
295                 container_of(dev, struct memory_block, sysdev);
296         return sprintf(buf, "%d\n", mem->phys_device);
297 }
298
299 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
300 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
301 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
302 static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
303
304 #define mem_create_simple_file(mem, attr_name)  \
305         sysdev_create_file(&mem->sysdev, &attr_##attr_name)
306 #define mem_remove_simple_file(mem, attr_name)  \
307         sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
308
309 /*
310  * Block size attribute stuff
311  */
312 static ssize_t
313 print_block_size(struct sysdev_class *class, struct sysdev_class_attribute *attr,
314                  char *buf)
315 {
316         return sprintf(buf, "%#lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
317 }
318
319 static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
320
321 static int block_size_init(void)
322 {
323         return sysfs_create_file(&memory_sysdev_class.kset.kobj,
324                                 &attr_block_size_bytes.attr);
325 }
326
327 /*
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.
332  */
333 #ifdef CONFIG_ARCH_MEMORY_PROBE
334 static ssize_t
335 memory_probe_store(struct class *class, struct class_attribute *attr,
336                    const char *buf, size_t count)
337 {
338         u64 phys_addr;
339         int nid;
340         int ret;
341
342         phys_addr = simple_strtoull(buf, NULL, 0);
343
344         nid = memory_add_physaddr_to_nid(phys_addr);
345         ret = add_memory(nid, phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
346
347         if (ret)
348                 count = ret;
349
350         return count;
351 }
352 static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
353
354 static int memory_probe_init(void)
355 {
356         return sysfs_create_file(&memory_sysdev_class.kset.kobj,
357                                 &class_attr_probe.attr);
358 }
359 #else
360 static inline int memory_probe_init(void)
361 {
362         return 0;
363 }
364 #endif
365
366 #ifdef CONFIG_MEMORY_FAILURE
367 /*
368  * Support for offlining pages of memory
369  */
370
371 /* Soft offline a page */
372 static ssize_t
373 store_soft_offline_page(struct class *class,
374                         struct class_attribute *attr,
375                         const char *buf, size_t count)
376 {
377         int ret;
378         u64 pfn;
379         if (!capable(CAP_SYS_ADMIN))
380                 return -EPERM;
381         if (strict_strtoull(buf, 0, &pfn) < 0)
382                 return -EINVAL;
383         pfn >>= PAGE_SHIFT;
384         if (!pfn_valid(pfn))
385                 return -ENXIO;
386         ret = soft_offline_page(pfn_to_page(pfn), 0);
387         return ret == 0 ? count : ret;
388 }
389
390 /* Forcibly offline a page, including killing processes. */
391 static ssize_t
392 store_hard_offline_page(struct class *class,
393                         struct class_attribute *attr,
394                         const char *buf, size_t count)
395 {
396         int ret;
397         u64 pfn;
398         if (!capable(CAP_SYS_ADMIN))
399                 return -EPERM;
400         if (strict_strtoull(buf, 0, &pfn) < 0)
401                 return -EINVAL;
402         pfn >>= PAGE_SHIFT;
403         ret = __memory_failure(pfn, 0, 0);
404         return ret ? ret : count;
405 }
406
407 static CLASS_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
408 static CLASS_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
409
410 static __init int memory_fail_init(void)
411 {
412         int err;
413
414         err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
415                                 &class_attr_soft_offline_page.attr);
416         if (!err)
417                 err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
418                                 &class_attr_hard_offline_page.attr);
419         return err;
420 }
421 #else
422 static inline int memory_fail_init(void)
423 {
424         return 0;
425 }
426 #endif
427
428 /*
429  * Note that phys_device is optional.  It is here to allow for
430  * differentiation between which *physical* devices each
431  * section belongs to...
432  */
433 int __weak arch_get_memory_phys_device(unsigned long start_pfn)
434 {
435         return 0;
436 }
437
438 static int add_memory_block(int nid, struct mem_section *section,
439                         unsigned long state, enum mem_add_context context)
440 {
441         struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
442         unsigned long start_pfn;
443         int ret = 0;
444
445         if (!mem)
446                 return -ENOMEM;
447
448         mem->phys_index = __section_nr(section);
449         mem->state = state;
450         mutex_init(&mem->state_mutex);
451         start_pfn = section_nr_to_pfn(mem->phys_index);
452         mem->phys_device = arch_get_memory_phys_device(start_pfn);
453
454         ret = register_memory(mem, section);
455         if (!ret)
456                 ret = mem_create_simple_file(mem, phys_index);
457         if (!ret)
458                 ret = mem_create_simple_file(mem, state);
459         if (!ret)
460                 ret = mem_create_simple_file(mem, phys_device);
461         if (!ret)
462                 ret = mem_create_simple_file(mem, removable);
463         if (!ret) {
464                 if (context == HOTPLUG)
465                         ret = register_mem_sect_under_node(mem, nid);
466         }
467
468         return ret;
469 }
470
471 /*
472  * For now, we have a linear search to go find the appropriate
473  * memory_block corresponding to a particular phys_index. If
474  * this gets to be a real problem, we can always use a radix
475  * tree or something here.
476  *
477  * This could be made generic for all sysdev classes.
478  */
479 struct memory_block *find_memory_block(struct mem_section *section)
480 {
481         struct kobject *kobj;
482         struct sys_device *sysdev;
483         struct memory_block *mem;
484         char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
485
486         /*
487          * This only works because we know that section == sysdev->id
488          * slightly redundant with sysdev_register()
489          */
490         sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
491
492         kobj = kset_find_obj(&memory_sysdev_class.kset, name);
493         if (!kobj)
494                 return NULL;
495
496         sysdev = container_of(kobj, struct sys_device, kobj);
497         mem = container_of(sysdev, struct memory_block, sysdev);
498
499         return mem;
500 }
501
502 int remove_memory_block(unsigned long node_id, struct mem_section *section,
503                 int phys_device)
504 {
505         struct memory_block *mem;
506
507         mem = find_memory_block(section);
508         unregister_mem_sect_under_nodes(mem);
509         mem_remove_simple_file(mem, phys_index);
510         mem_remove_simple_file(mem, state);
511         mem_remove_simple_file(mem, phys_device);
512         mem_remove_simple_file(mem, removable);
513         unregister_memory(mem, section);
514
515         return 0;
516 }
517
518 /*
519  * need an interface for the VM to add new memory regions,
520  * but without onlining it.
521  */
522 int register_new_memory(int nid, struct mem_section *section)
523 {
524         return add_memory_block(nid, section, MEM_OFFLINE, HOTPLUG);
525 }
526
527 int unregister_memory_section(struct mem_section *section)
528 {
529         if (!present_section(section))
530                 return -EINVAL;
531
532         return remove_memory_block(0, section, 0);
533 }
534
535 /*
536  * Initialize the sysfs support for memory devices...
537  */
538 int __init memory_dev_init(void)
539 {
540         unsigned int i;
541         int ret;
542         int err;
543
544         memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
545         ret = sysdev_class_register(&memory_sysdev_class);
546         if (ret)
547                 goto out;
548
549         /*
550          * Create entries for memory sections that were found
551          * during boot and have been initialized
552          */
553         for (i = 0; i < NR_MEM_SECTIONS; i++) {
554                 if (!present_section_nr(i))
555                         continue;
556                 err = add_memory_block(0, __nr_to_section(i), MEM_ONLINE,
557                                        BOOT);
558                 if (!ret)
559                         ret = err;
560         }
561
562         err = memory_probe_init();
563         if (!ret)
564                 ret = err;
565         err = memory_fail_init();
566         if (!ret)
567                 ret = err;
568         err = block_size_init();
569         if (!ret)
570                 ret = err;
571 out:
572         if (ret)
573                 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
574         return ret;
575 }