Auto-update from upstream
[linux-2.6] / 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/sched.h>        /* capable() */
17 #include <linux/topology.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 <asm/atomic.h>
24 #include <asm/uaccess.h>
25
26 #define MEMORY_CLASS_NAME       "memory"
27
28 static struct sysdev_class memory_sysdev_class = {
29         set_kset_name(MEMORY_CLASS_NAME),
30 };
31
32 static char *memory_hotplug_name(struct kset *kset, struct kobject *kobj)
33 {
34         return MEMORY_CLASS_NAME;
35 }
36
37 static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
38                         int num_envp, char *buffer, int buffer_size)
39 {
40         int retval = 0;
41
42         return retval;
43 }
44
45 static struct kset_hotplug_ops memory_hotplug_ops = {
46         .name           = memory_hotplug_name,
47         .hotplug        = memory_hotplug,
48 };
49
50 static struct notifier_block *memory_chain;
51
52 static int register_memory_notifier(struct notifier_block *nb)
53 {
54         return notifier_chain_register(&memory_chain, nb);
55 }
56
57 static void unregister_memory_notifier(struct notifier_block *nb)
58 {
59         notifier_chain_unregister(&memory_chain, nb);
60 }
61
62 /*
63  * register_memory - Setup a sysfs device for a memory block
64  */
65 static int
66 register_memory(struct memory_block *memory, struct mem_section *section,
67                 struct node *root)
68 {
69         int error;
70
71         memory->sysdev.cls = &memory_sysdev_class;
72         memory->sysdev.id = __section_nr(section);
73
74         error = sysdev_register(&memory->sysdev);
75
76         if (root && !error)
77                 error = sysfs_create_link(&root->sysdev.kobj,
78                                           &memory->sysdev.kobj,
79                                           kobject_name(&memory->sysdev.kobj));
80
81         return error;
82 }
83
84 static void
85 unregister_memory(struct memory_block *memory, struct mem_section *section,
86                 struct node *root)
87 {
88         BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
89         BUG_ON(memory->sysdev.id != __section_nr(section));
90
91         sysdev_unregister(&memory->sysdev);
92         if (root)
93                 sysfs_remove_link(&root->sysdev.kobj,
94                                   kobject_name(&memory->sysdev.kobj));
95 }
96
97 /*
98  * use this as the physical section index that this memsection
99  * uses.
100  */
101
102 static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
103 {
104         struct memory_block *mem =
105                 container_of(dev, struct memory_block, sysdev);
106         return sprintf(buf, "%08lx\n", mem->phys_index);
107 }
108
109 /*
110  * online, offline, going offline, etc.
111  */
112 static ssize_t show_mem_state(struct sys_device *dev, char *buf)
113 {
114         struct memory_block *mem =
115                 container_of(dev, struct memory_block, sysdev);
116         ssize_t len = 0;
117
118         /*
119          * We can probably put these states in a nice little array
120          * so that they're not open-coded
121          */
122         switch (mem->state) {
123                 case MEM_ONLINE:
124                         len = sprintf(buf, "online\n");
125                         break;
126                 case MEM_OFFLINE:
127                         len = sprintf(buf, "offline\n");
128                         break;
129                 case MEM_GOING_OFFLINE:
130                         len = sprintf(buf, "going-offline\n");
131                         break;
132                 default:
133                         len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
134                                         mem->state);
135                         WARN_ON(1);
136                         break;
137         }
138
139         return len;
140 }
141
142 static inline int memory_notify(unsigned long val, void *v)
143 {
144         return notifier_call_chain(&memory_chain, val, v);
145 }
146
147 /*
148  * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
149  * OK to have direct references to sparsemem variables in here.
150  */
151 static int
152 memory_block_action(struct memory_block *mem, unsigned long action)
153 {
154         int i;
155         unsigned long psection;
156         unsigned long start_pfn, start_paddr;
157         struct page *first_page;
158         int ret;
159         int old_state = mem->state;
160
161         psection = mem->phys_index;
162         first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
163
164         /*
165          * The probe routines leave the pages reserved, just
166          * as the bootmem code does.  Make sure they're still
167          * that way.
168          */
169         if (action == MEM_ONLINE) {
170                 for (i = 0; i < PAGES_PER_SECTION; i++) {
171                         if (PageReserved(first_page+i))
172                                 continue;
173
174                         printk(KERN_WARNING "section number %ld page number %d "
175                                 "not reserved, was it already online? \n",
176                                 psection, i);
177                         return -EBUSY;
178                 }
179         }
180
181         switch (action) {
182                 case MEM_ONLINE:
183                         start_pfn = page_to_pfn(first_page);
184                         ret = online_pages(start_pfn, PAGES_PER_SECTION);
185                         break;
186                 case MEM_OFFLINE:
187                         mem->state = MEM_GOING_OFFLINE;
188                         memory_notify(MEM_GOING_OFFLINE, NULL);
189                         start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
190                         ret = remove_memory(start_paddr,
191                                             PAGES_PER_SECTION << PAGE_SHIFT);
192                         if (ret) {
193                                 mem->state = old_state;
194                                 break;
195                         }
196                         memory_notify(MEM_MAPPING_INVALID, NULL);
197                         break;
198                 default:
199                         printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
200                                         __FUNCTION__, mem, action, action);
201                         WARN_ON(1);
202                         ret = -EINVAL;
203         }
204         /*
205          * For now, only notify on successful memory operations
206          */
207         if (!ret)
208                 memory_notify(action, NULL);
209
210         return ret;
211 }
212
213 static int memory_block_change_state(struct memory_block *mem,
214                 unsigned long to_state, unsigned long from_state_req)
215 {
216         int ret = 0;
217         down(&mem->state_sem);
218
219         if (mem->state != from_state_req) {
220                 ret = -EINVAL;
221                 goto out;
222         }
223
224         ret = memory_block_action(mem, to_state);
225         if (!ret)
226                 mem->state = to_state;
227
228 out:
229         up(&mem->state_sem);
230         return ret;
231 }
232
233 static ssize_t
234 store_mem_state(struct sys_device *dev, const char *buf, size_t count)
235 {
236         struct memory_block *mem;
237         unsigned int phys_section_nr;
238         int ret = -EINVAL;
239
240         mem = container_of(dev, struct memory_block, sysdev);
241         phys_section_nr = mem->phys_index;
242
243         if (!valid_section_nr(phys_section_nr))
244                 goto out;
245
246         if (!strncmp(buf, "online", min((int)count, 6)))
247                 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
248         else if(!strncmp(buf, "offline", min((int)count, 7)))
249                 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
250 out:
251         if (ret)
252                 return ret;
253         return count;
254 }
255
256 /*
257  * phys_device is a bad name for this.  What I really want
258  * is a way to differentiate between memory ranges that
259  * are part of physical devices that constitute
260  * a complete removable unit or fru.
261  * i.e. do these ranges belong to the same physical device,
262  * s.t. if I offline all of these sections I can then
263  * remove the physical device?
264  */
265 static ssize_t show_phys_device(struct sys_device *dev, char *buf)
266 {
267         struct memory_block *mem =
268                 container_of(dev, struct memory_block, sysdev);
269         return sprintf(buf, "%d\n", mem->phys_device);
270 }
271
272 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
273 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
274 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
275
276 #define mem_create_simple_file(mem, attr_name)  \
277         sysdev_create_file(&mem->sysdev, &attr_##attr_name)
278 #define mem_remove_simple_file(mem, attr_name)  \
279         sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
280
281 /*
282  * Block size attribute stuff
283  */
284 static ssize_t
285 print_block_size(struct class *class, char *buf)
286 {
287         return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
288 }
289
290 static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
291
292 static int block_size_init(void)
293 {
294         sysfs_create_file(&memory_sysdev_class.kset.kobj,
295                 &class_attr_block_size_bytes.attr);
296         return 0;
297 }
298
299 /*
300  * Some architectures will have custom drivers to do this, and
301  * will not need to do it from userspace.  The fake hot-add code
302  * as well as ppc64 will do all of their discovery in userspace
303  * and will require this interface.
304  */
305 #ifdef CONFIG_ARCH_MEMORY_PROBE
306 static ssize_t
307 memory_probe_store(struct class *class, const char __user *buf, size_t count)
308 {
309         u64 phys_addr;
310         int ret;
311
312         phys_addr = simple_strtoull(buf, NULL, 0);
313
314         ret = add_memory(phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
315
316         if (ret)
317                 count = ret;
318
319         return count;
320 }
321 static CLASS_ATTR(probe, 0700, NULL, memory_probe_store);
322
323 static int memory_probe_init(void)
324 {
325         sysfs_create_file(&memory_sysdev_class.kset.kobj,
326                 &class_attr_probe.attr);
327         return 0;
328 }
329 #else
330 #define memory_probe_init(...)  do {} while (0)
331 #endif
332
333 /*
334  * Note that phys_device is optional.  It is here to allow for
335  * differentiation between which *physical* devices each
336  * section belongs to...
337  */
338
339 static int add_memory_block(unsigned long node_id, struct mem_section *section,
340                      unsigned long state, int phys_device)
341 {
342         struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
343         int ret = 0;
344
345         if (!mem)
346                 return -ENOMEM;
347
348         mem->phys_index = __section_nr(section);
349         mem->state = state;
350         init_MUTEX(&mem->state_sem);
351         mem->phys_device = phys_device;
352
353         ret = register_memory(mem, section, NULL);
354         if (!ret)
355                 ret = mem_create_simple_file(mem, phys_index);
356         if (!ret)
357                 ret = mem_create_simple_file(mem, state);
358         if (!ret)
359                 ret = mem_create_simple_file(mem, phys_device);
360
361         return ret;
362 }
363
364 /*
365  * For now, we have a linear search to go find the appropriate
366  * memory_block corresponding to a particular phys_index. If
367  * this gets to be a real problem, we can always use a radix
368  * tree or something here.
369  *
370  * This could be made generic for all sysdev classes.
371  */
372 static struct memory_block *find_memory_block(struct mem_section *section)
373 {
374         struct kobject *kobj;
375         struct sys_device *sysdev;
376         struct memory_block *mem;
377         char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
378
379         /*
380          * This only works because we know that section == sysdev->id
381          * slightly redundant with sysdev_register()
382          */
383         sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
384
385         kobj = kset_find_obj(&memory_sysdev_class.kset, name);
386         if (!kobj)
387                 return NULL;
388
389         sysdev = container_of(kobj, struct sys_device, kobj);
390         mem = container_of(sysdev, struct memory_block, sysdev);
391
392         return mem;
393 }
394
395 int remove_memory_block(unsigned long node_id, struct mem_section *section,
396                 int phys_device)
397 {
398         struct memory_block *mem;
399
400         mem = find_memory_block(section);
401         mem_remove_simple_file(mem, phys_index);
402         mem_remove_simple_file(mem, state);
403         mem_remove_simple_file(mem, phys_device);
404         unregister_memory(mem, section, NULL);
405
406         return 0;
407 }
408
409 /*
410  * need an interface for the VM to add new memory regions,
411  * but without onlining it.
412  */
413 int register_new_memory(struct mem_section *section)
414 {
415         return add_memory_block(0, section, MEM_OFFLINE, 0);
416 }
417
418 int unregister_memory_section(struct mem_section *section)
419 {
420         if (!valid_section(section))
421                 return -EINVAL;
422
423         return remove_memory_block(0, section, 0);
424 }
425
426 /*
427  * Initialize the sysfs support for memory devices...
428  */
429 int __init memory_dev_init(void)
430 {
431         unsigned int i;
432         int ret;
433
434         memory_sysdev_class.kset.hotplug_ops = &memory_hotplug_ops;
435         ret = sysdev_class_register(&memory_sysdev_class);
436
437         /*
438          * Create entries for memory sections that were found
439          * during boot and have been initialized
440          */
441         for (i = 0; i < NR_MEM_SECTIONS; i++) {
442                 if (!valid_section_nr(i))
443                         continue;
444                 add_memory_block(0, __nr_to_section(i), MEM_ONLINE, 0);
445         }
446
447         memory_probe_init();
448         block_size_init();
449
450         return ret;
451 }