blob: 989429cfed88a7395f38a4d1dd44d8d8ff8745ac [file] [log] [blame]
Dave Hansen3947be12005-10-29 18:16:54 -07001/*
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>
Dave Hansen3947be12005-10-29 18:16:54 -070016#include <linux/topology.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080017#include <linux/capability.h>
Dave Hansen3947be12005-10-29 18:16:54 -070018#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>
Daniel Walkerda19cbc2008-02-04 23:35:47 -080023#include <linux/mutex.h>
Shaohua Li9f1b16a2008-10-18 20:27:12 -070024#include <linux/stat.h>
25
Dave Hansen3947be12005-10-29 18:16:54 -070026#include <asm/atomic.h>
27#include <asm/uaccess.h>
28
29#define MEMORY_CLASS_NAME "memory"
30
31static struct sysdev_class memory_sysdev_class = {
Kay Sieversaf5ca3f2007-12-20 02:09:39 +010032 .name = MEMORY_CLASS_NAME,
Dave Hansen3947be12005-10-29 18:16:54 -070033};
Dave Hansen3947be12005-10-29 18:16:54 -070034
Kay Sievers312c0042005-11-16 09:00:00 +010035static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
Dave Hansen3947be12005-10-29 18:16:54 -070036{
37 return MEMORY_CLASS_NAME;
38}
39
Al Viro9ec0fd42007-10-14 06:53:45 +010040static int memory_uevent(struct kset *kset, struct kobject *obj, struct kobj_uevent_env *env)
Dave Hansen3947be12005-10-29 18:16:54 -070041{
42 int retval = 0;
43
44 return retval;
45}
46
Kay Sievers312c0042005-11-16 09:00:00 +010047static struct kset_uevent_ops memory_uevent_ops = {
48 .name = memory_uevent_name,
49 .uevent = memory_uevent,
Dave Hansen3947be12005-10-29 18:16:54 -070050};
51
Alan Sterne041c682006-03-27 01:16:30 -080052static BLOCKING_NOTIFIER_HEAD(memory_chain);
Dave Hansen3947be12005-10-29 18:16:54 -070053
Andy Whitcroft98a38eb2006-01-06 00:10:35 -080054int register_memory_notifier(struct notifier_block *nb)
Dave Hansen3947be12005-10-29 18:16:54 -070055{
Alan Sterne041c682006-03-27 01:16:30 -080056 return blocking_notifier_chain_register(&memory_chain, nb);
Dave Hansen3947be12005-10-29 18:16:54 -070057}
Hannes Hering3c82c302008-05-07 14:43:01 +020058EXPORT_SYMBOL(register_memory_notifier);
Dave Hansen3947be12005-10-29 18:16:54 -070059
Andy Whitcroft98a38eb2006-01-06 00:10:35 -080060void unregister_memory_notifier(struct notifier_block *nb)
Dave Hansen3947be12005-10-29 18:16:54 -070061{
Alan Sterne041c682006-03-27 01:16:30 -080062 blocking_notifier_chain_unregister(&memory_chain, nb);
Dave Hansen3947be12005-10-29 18:16:54 -070063}
Hannes Hering3c82c302008-05-07 14:43:01 +020064EXPORT_SYMBOL(unregister_memory_notifier);
Dave Hansen3947be12005-10-29 18:16:54 -070065
66/*
67 * register_memory - Setup a sysfs device for a memory block
68 */
Badari Pulavarty00a41db2008-02-11 09:23:18 -080069static
70int register_memory(struct memory_block *memory, struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -070071{
72 int error;
73
74 memory->sysdev.cls = &memory_sysdev_class;
75 memory->sysdev.id = __section_nr(section);
76
77 error = sysdev_register(&memory->sysdev);
Dave Hansen3947be12005-10-29 18:16:54 -070078 return error;
79}
80
81static void
Badari Pulavarty00a41db2008-02-11 09:23:18 -080082unregister_memory(struct memory_block *memory, struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -070083{
84 BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
85 BUG_ON(memory->sysdev.id != __section_nr(section));
86
Badari Pulavarty00a41db2008-02-11 09:23:18 -080087 /* drop the ref. we got in remove_memory_block() */
88 kobject_put(&memory->sysdev.kobj);
Dave Hansen3947be12005-10-29 18:16:54 -070089 sysdev_unregister(&memory->sysdev);
Dave Hansen3947be12005-10-29 18:16:54 -070090}
91
92/*
93 * use this as the physical section index that this memsection
94 * uses.
95 */
96
Andi Kleen4a0b2b42008-07-01 18:48:41 +020097static ssize_t show_mem_phys_index(struct sys_device *dev,
98 struct sysdev_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -070099{
100 struct memory_block *mem =
101 container_of(dev, struct memory_block, sysdev);
102 return sprintf(buf, "%08lx\n", mem->phys_index);
103}
104
105/*
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700106 * Show whether the section of memory is likely to be hot-removable
107 */
Stephen Rothwell1f07be12008-07-28 11:05:04 +1000108static ssize_t show_mem_removable(struct sys_device *dev,
109 struct sysdev_attribute *attr, char *buf)
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700110{
111 unsigned long start_pfn;
112 int ret;
113 struct memory_block *mem =
114 container_of(dev, struct memory_block, sysdev);
115
116 start_pfn = section_nr_to_pfn(mem->phys_index);
117 ret = is_mem_section_removable(start_pfn, PAGES_PER_SECTION);
118 return sprintf(buf, "%d\n", ret);
119}
120
121/*
Dave Hansen3947be12005-10-29 18:16:54 -0700122 * online, offline, going offline, etc.
123 */
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200124static ssize_t show_mem_state(struct sys_device *dev,
125 struct sysdev_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700126{
127 struct memory_block *mem =
128 container_of(dev, struct memory_block, sysdev);
129 ssize_t len = 0;
130
131 /*
132 * We can probably put these states in a nice little array
133 * so that they're not open-coded
134 */
135 switch (mem->state) {
136 case MEM_ONLINE:
137 len = sprintf(buf, "online\n");
138 break;
139 case MEM_OFFLINE:
140 len = sprintf(buf, "offline\n");
141 break;
142 case MEM_GOING_OFFLINE:
143 len = sprintf(buf, "going-offline\n");
144 break;
145 default:
146 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
147 mem->state);
148 WARN_ON(1);
149 break;
150 }
151
152 return len;
153}
154
Yasunori Goto7b78d332007-10-21 16:41:36 -0700155int memory_notify(unsigned long val, void *v)
Dave Hansen3947be12005-10-29 18:16:54 -0700156{
Alan Sterne041c682006-03-27 01:16:30 -0800157 return blocking_notifier_call_chain(&memory_chain, val, v);
Dave Hansen3947be12005-10-29 18:16:54 -0700158}
159
160/*
161 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
162 * OK to have direct references to sparsemem variables in here.
163 */
164static int
165memory_block_action(struct memory_block *mem, unsigned long action)
166{
167 int i;
168 unsigned long psection;
169 unsigned long start_pfn, start_paddr;
170 struct page *first_page;
171 int ret;
172 int old_state = mem->state;
173
174 psection = mem->phys_index;
175 first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
176
177 /*
178 * The probe routines leave the pages reserved, just
179 * as the bootmem code does. Make sure they're still
180 * that way.
181 */
182 if (action == MEM_ONLINE) {
183 for (i = 0; i < PAGES_PER_SECTION; i++) {
184 if (PageReserved(first_page+i))
185 continue;
186
187 printk(KERN_WARNING "section number %ld page number %d "
188 "not reserved, was it already online? \n",
189 psection, i);
190 return -EBUSY;
191 }
192 }
193
194 switch (action) {
195 case MEM_ONLINE:
196 start_pfn = page_to_pfn(first_page);
197 ret = online_pages(start_pfn, PAGES_PER_SECTION);
198 break;
199 case MEM_OFFLINE:
200 mem->state = MEM_GOING_OFFLINE;
Dave Hansen3947be12005-10-29 18:16:54 -0700201 start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
202 ret = remove_memory(start_paddr,
203 PAGES_PER_SECTION << PAGE_SHIFT);
204 if (ret) {
205 mem->state = old_state;
206 break;
207 }
Dave Hansen3947be12005-10-29 18:16:54 -0700208 break;
209 default:
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700210 WARN(1, KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800211 __func__, mem, action, action);
Dave Hansen3947be12005-10-29 18:16:54 -0700212 ret = -EINVAL;
213 }
Dave Hansen3947be12005-10-29 18:16:54 -0700214
215 return ret;
216}
217
218static int memory_block_change_state(struct memory_block *mem,
219 unsigned long to_state, unsigned long from_state_req)
220{
221 int ret = 0;
Daniel Walkerda19cbc2008-02-04 23:35:47 -0800222 mutex_lock(&mem->state_mutex);
Dave Hansen3947be12005-10-29 18:16:54 -0700223
224 if (mem->state != from_state_req) {
225 ret = -EINVAL;
226 goto out;
227 }
228
229 ret = memory_block_action(mem, to_state);
230 if (!ret)
231 mem->state = to_state;
232
233out:
Daniel Walkerda19cbc2008-02-04 23:35:47 -0800234 mutex_unlock(&mem->state_mutex);
Dave Hansen3947be12005-10-29 18:16:54 -0700235 return ret;
236}
237
238static ssize_t
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200239store_mem_state(struct sys_device *dev,
240 struct sysdev_attribute *attr, const char *buf, size_t count)
Dave Hansen3947be12005-10-29 18:16:54 -0700241{
242 struct memory_block *mem;
243 unsigned int phys_section_nr;
244 int ret = -EINVAL;
245
246 mem = container_of(dev, struct memory_block, sysdev);
247 phys_section_nr = mem->phys_index;
248
Andy Whitcroft540557b2007-10-16 01:24:11 -0700249 if (!present_section_nr(phys_section_nr))
Dave Hansen3947be12005-10-29 18:16:54 -0700250 goto out;
251
252 if (!strncmp(buf, "online", min((int)count, 6)))
253 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
254 else if(!strncmp(buf, "offline", min((int)count, 7)))
255 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
256out:
257 if (ret)
258 return ret;
259 return count;
260}
261
262/*
263 * phys_device is a bad name for this. What I really want
264 * is a way to differentiate between memory ranges that
265 * are part of physical devices that constitute
266 * a complete removable unit or fru.
267 * i.e. do these ranges belong to the same physical device,
268 * s.t. if I offline all of these sections I can then
269 * remove the physical device?
270 */
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200271static ssize_t show_phys_device(struct sys_device *dev,
272 struct sysdev_attribute *attr, char *buf)
Dave Hansen3947be12005-10-29 18:16:54 -0700273{
274 struct memory_block *mem =
275 container_of(dev, struct memory_block, sysdev);
276 return sprintf(buf, "%d\n", mem->phys_device);
277}
278
279static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
280static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
281static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700282static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
Dave Hansen3947be12005-10-29 18:16:54 -0700283
284#define mem_create_simple_file(mem, attr_name) \
285 sysdev_create_file(&mem->sysdev, &attr_##attr_name)
286#define mem_remove_simple_file(mem, attr_name) \
287 sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
288
289/*
290 * Block size attribute stuff
291 */
292static ssize_t
293print_block_size(struct class *class, char *buf)
294{
295 return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
296}
297
298static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
299
300static int block_size_init(void)
301{
Andrew Morton28ec24e2006-12-06 20:37:29 -0800302 return sysfs_create_file(&memory_sysdev_class.kset.kobj,
303 &class_attr_block_size_bytes.attr);
Dave Hansen3947be12005-10-29 18:16:54 -0700304}
305
306/*
307 * Some architectures will have custom drivers to do this, and
308 * will not need to do it from userspace. The fake hot-add code
309 * as well as ppc64 will do all of their discovery in userspace
310 * and will require this interface.
311 */
312#ifdef CONFIG_ARCH_MEMORY_PROBE
313static ssize_t
Al Virobe7ee9b2006-02-01 06:06:16 -0500314memory_probe_store(struct class *class, const char *buf, size_t count)
Dave Hansen3947be12005-10-29 18:16:54 -0700315{
316 u64 phys_addr;
Yasunori Gotobc02af92006-06-27 02:53:30 -0700317 int nid;
Dave Hansen3947be12005-10-29 18:16:54 -0700318 int ret;
319
320 phys_addr = simple_strtoull(buf, NULL, 0);
321
Yasunori Gotobc02af92006-06-27 02:53:30 -0700322 nid = memory_add_physaddr_to_nid(phys_addr);
323 ret = add_memory(nid, phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
Dave Hansen3947be12005-10-29 18:16:54 -0700324
325 if (ret)
326 count = ret;
327
328 return count;
329}
Shaohua Li9f1b16a2008-10-18 20:27:12 -0700330static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
Dave Hansen3947be12005-10-29 18:16:54 -0700331
332static int memory_probe_init(void)
333{
Andrew Morton28ec24e2006-12-06 20:37:29 -0800334 return sysfs_create_file(&memory_sysdev_class.kset.kobj,
335 &class_attr_probe.attr);
Dave Hansen3947be12005-10-29 18:16:54 -0700336}
337#else
Andrew Morton28ec24e2006-12-06 20:37:29 -0800338static inline int memory_probe_init(void)
339{
340 return 0;
341}
Dave Hansen3947be12005-10-29 18:16:54 -0700342#endif
343
344/*
345 * Note that phys_device is optional. It is here to allow for
346 * differentiation between which *physical* devices each
347 * section belongs to...
348 */
349
Gary Hadec04fc582009-01-06 14:39:14 -0800350static int add_memory_block(int nid, struct mem_section *section,
351 unsigned long state, int phys_device,
352 enum mem_add_context context)
Dave Hansen3947be12005-10-29 18:16:54 -0700353{
Dave Hansen0b0acbe2005-10-29 18:16:55 -0700354 struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
Dave Hansen3947be12005-10-29 18:16:54 -0700355 int ret = 0;
356
357 if (!mem)
358 return -ENOMEM;
359
Dave Hansen3947be12005-10-29 18:16:54 -0700360 mem->phys_index = __section_nr(section);
361 mem->state = state;
Daniel Walkerda19cbc2008-02-04 23:35:47 -0800362 mutex_init(&mem->state_mutex);
Dave Hansen3947be12005-10-29 18:16:54 -0700363 mem->phys_device = phys_device;
364
Badari Pulavarty00a41db2008-02-11 09:23:18 -0800365 ret = register_memory(mem, section);
Dave Hansen3947be12005-10-29 18:16:54 -0700366 if (!ret)
367 ret = mem_create_simple_file(mem, phys_index);
368 if (!ret)
369 ret = mem_create_simple_file(mem, state);
370 if (!ret)
371 ret = mem_create_simple_file(mem, phys_device);
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700372 if (!ret)
373 ret = mem_create_simple_file(mem, removable);
Gary Hadec04fc582009-01-06 14:39:14 -0800374 if (!ret) {
375 if (context == HOTPLUG)
376 ret = register_mem_sect_under_node(mem, nid);
377 }
Dave Hansen3947be12005-10-29 18:16:54 -0700378
379 return ret;
380}
381
382/*
383 * For now, we have a linear search to go find the appropriate
384 * memory_block corresponding to a particular phys_index. If
385 * this gets to be a real problem, we can always use a radix
386 * tree or something here.
387 *
388 * This could be made generic for all sysdev classes.
389 */
Gary Hadec04fc582009-01-06 14:39:14 -0800390struct memory_block *find_memory_block(struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -0700391{
392 struct kobject *kobj;
393 struct sys_device *sysdev;
394 struct memory_block *mem;
395 char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
396
397 /*
398 * This only works because we know that section == sysdev->id
399 * slightly redundant with sysdev_register()
400 */
401 sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
402
403 kobj = kset_find_obj(&memory_sysdev_class.kset, name);
404 if (!kobj)
405 return NULL;
406
407 sysdev = container_of(kobj, struct sys_device, kobj);
408 mem = container_of(sysdev, struct memory_block, sysdev);
409
410 return mem;
411}
412
413int remove_memory_block(unsigned long node_id, struct mem_section *section,
414 int phys_device)
415{
416 struct memory_block *mem;
417
418 mem = find_memory_block(section);
Gary Hadec04fc582009-01-06 14:39:14 -0800419 unregister_mem_sect_under_nodes(mem);
Dave Hansen3947be12005-10-29 18:16:54 -0700420 mem_remove_simple_file(mem, phys_index);
421 mem_remove_simple_file(mem, state);
422 mem_remove_simple_file(mem, phys_device);
Badari Pulavarty5c755e92008-07-23 21:28:19 -0700423 mem_remove_simple_file(mem, removable);
Badari Pulavarty00a41db2008-02-11 09:23:18 -0800424 unregister_memory(mem, section);
Dave Hansen3947be12005-10-29 18:16:54 -0700425
426 return 0;
427}
428
429/*
430 * need an interface for the VM to add new memory regions,
431 * but without onlining it.
432 */
Gary Hadec04fc582009-01-06 14:39:14 -0800433int register_new_memory(int nid, struct mem_section *section)
Dave Hansen3947be12005-10-29 18:16:54 -0700434{
Gary Hadec04fc582009-01-06 14:39:14 -0800435 return add_memory_block(nid, section, MEM_OFFLINE, 0, HOTPLUG);
Dave Hansen3947be12005-10-29 18:16:54 -0700436}
437
438int unregister_memory_section(struct mem_section *section)
439{
Andy Whitcroft540557b2007-10-16 01:24:11 -0700440 if (!present_section(section))
Dave Hansen3947be12005-10-29 18:16:54 -0700441 return -EINVAL;
442
443 return remove_memory_block(0, section, 0);
444}
445
446/*
447 * Initialize the sysfs support for memory devices...
448 */
449int __init memory_dev_init(void)
450{
451 unsigned int i;
452 int ret;
Andrew Morton28ec24e2006-12-06 20:37:29 -0800453 int err;
Dave Hansen3947be12005-10-29 18:16:54 -0700454
Kay Sievers312c0042005-11-16 09:00:00 +0100455 memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
Dave Hansen3947be12005-10-29 18:16:54 -0700456 ret = sysdev_class_register(&memory_sysdev_class);
Andrew Morton28ec24e2006-12-06 20:37:29 -0800457 if (ret)
458 goto out;
Dave Hansen3947be12005-10-29 18:16:54 -0700459
460 /*
461 * Create entries for memory sections that were found
462 * during boot and have been initialized
463 */
464 for (i = 0; i < NR_MEM_SECTIONS; i++) {
Andy Whitcroft540557b2007-10-16 01:24:11 -0700465 if (!present_section_nr(i))
Dave Hansen3947be12005-10-29 18:16:54 -0700466 continue;
Gary Hadec04fc582009-01-06 14:39:14 -0800467 err = add_memory_block(0, __nr_to_section(i), MEM_ONLINE,
468 0, BOOT);
Andrew Morton28ec24e2006-12-06 20:37:29 -0800469 if (!ret)
470 ret = err;
Dave Hansen3947be12005-10-29 18:16:54 -0700471 }
472
Andrew Morton28ec24e2006-12-06 20:37:29 -0800473 err = memory_probe_init();
474 if (!ret)
475 ret = err;
476 err = block_size_init();
477 if (!ret)
478 ret = err;
479out:
480 if (ret)
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800481 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
Dave Hansen3947be12005-10-29 18:16:54 -0700482 return ret;
483}