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
);
56 EXPORT_SYMBOL(register_memory_notifier
);
58 void unregister_memory_notifier(struct notifier_block
*nb
)
60 blocking_notifier_chain_unregister(&memory_chain
, nb
);
62 EXPORT_SYMBOL(unregister_memory_notifier
);
65 * register_memory - Setup a sysfs device for a memory block
68 int register_memory(struct memory_block
*memory
, struct mem_section
*section
)
72 memory
->sysdev
.cls
= &memory_sysdev_class
;
73 memory
->sysdev
.id
= __section_nr(section
);
75 error
= sysdev_register(&memory
->sysdev
);
80 unregister_memory(struct memory_block
*memory
, struct mem_section
*section
)
82 BUG_ON(memory
->sysdev
.cls
!= &memory_sysdev_class
);
83 BUG_ON(memory
->sysdev
.id
!= __section_nr(section
));
85 /* drop the ref. we got in remove_memory_block() */
86 kobject_put(&memory
->sysdev
.kobj
);
87 sysdev_unregister(&memory
->sysdev
);
91 * use this as the physical section index that this memsection
95 static ssize_t
show_mem_phys_index(struct sys_device
*dev
,
96 struct sysdev_attribute
*attr
, char *buf
)
98 struct memory_block
*mem
=
99 container_of(dev
, struct memory_block
, sysdev
);
100 return sprintf(buf
, "%08lx\n", mem
->phys_index
);
104 * online, offline, going offline, etc.
106 static ssize_t
show_mem_state(struct sys_device
*dev
,
107 struct sysdev_attribute
*attr
, char *buf
)
109 struct memory_block
*mem
=
110 container_of(dev
, struct memory_block
, sysdev
);
114 * We can probably put these states in a nice little array
115 * so that they're not open-coded
117 switch (mem
->state
) {
119 len
= sprintf(buf
, "online\n");
122 len
= sprintf(buf
, "offline\n");
124 case MEM_GOING_OFFLINE
:
125 len
= sprintf(buf
, "going-offline\n");
128 len
= sprintf(buf
, "ERROR-UNKNOWN-%ld\n",
137 int memory_notify(unsigned long val
, void *v
)
139 return blocking_notifier_call_chain(&memory_chain
, val
, v
);
143 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
144 * OK to have direct references to sparsemem variables in here.
147 memory_block_action(struct memory_block
*mem
, unsigned long action
)
150 unsigned long psection
;
151 unsigned long start_pfn
, start_paddr
;
152 struct page
*first_page
;
154 int old_state
= mem
->state
;
156 psection
= mem
->phys_index
;
157 first_page
= pfn_to_page(psection
<< PFN_SECTION_SHIFT
);
160 * The probe routines leave the pages reserved, just
161 * as the bootmem code does. Make sure they're still
164 if (action
== MEM_ONLINE
) {
165 for (i
= 0; i
< PAGES_PER_SECTION
; i
++) {
166 if (PageReserved(first_page
+i
))
169 printk(KERN_WARNING
"section number %ld page number %d "
170 "not reserved, was it already online? \n",
178 start_pfn
= page_to_pfn(first_page
);
179 ret
= online_pages(start_pfn
, PAGES_PER_SECTION
);
182 mem
->state
= MEM_GOING_OFFLINE
;
183 start_paddr
= page_to_pfn(first_page
) << PAGE_SHIFT
;
184 ret
= remove_memory(start_paddr
,
185 PAGES_PER_SECTION
<< PAGE_SHIFT
);
187 mem
->state
= old_state
;
192 printk(KERN_WARNING
"%s(%p, %ld) unknown action: %ld\n",
193 __func__
, mem
, action
, action
);
201 static int memory_block_change_state(struct memory_block
*mem
,
202 unsigned long to_state
, unsigned long from_state_req
)
205 mutex_lock(&mem
->state_mutex
);
207 if (mem
->state
!= from_state_req
) {
212 ret
= memory_block_action(mem
, to_state
);
214 mem
->state
= to_state
;
217 mutex_unlock(&mem
->state_mutex
);
222 store_mem_state(struct sys_device
*dev
,
223 struct sysdev_attribute
*attr
, const char *buf
, size_t count
)
225 struct memory_block
*mem
;
226 unsigned int phys_section_nr
;
229 mem
= container_of(dev
, struct memory_block
, sysdev
);
230 phys_section_nr
= mem
->phys_index
;
232 if (!present_section_nr(phys_section_nr
))
235 if (!strncmp(buf
, "online", min((int)count
, 6)))
236 ret
= memory_block_change_state(mem
, MEM_ONLINE
, MEM_OFFLINE
);
237 else if(!strncmp(buf
, "offline", min((int)count
, 7)))
238 ret
= memory_block_change_state(mem
, MEM_OFFLINE
, MEM_ONLINE
);
246 * phys_device is a bad name for this. What I really want
247 * is a way to differentiate between memory ranges that
248 * are part of physical devices that constitute
249 * a complete removable unit or fru.
250 * i.e. do these ranges belong to the same physical device,
251 * s.t. if I offline all of these sections I can then
252 * remove the physical device?
254 static ssize_t
show_phys_device(struct sys_device
*dev
,
255 struct sysdev_attribute
*attr
, char *buf
)
257 struct memory_block
*mem
=
258 container_of(dev
, struct memory_block
, sysdev
);
259 return sprintf(buf
, "%d\n", mem
->phys_device
);
262 static SYSDEV_ATTR(phys_index
, 0444, show_mem_phys_index
, NULL
);
263 static SYSDEV_ATTR(state
, 0644, show_mem_state
, store_mem_state
);
264 static SYSDEV_ATTR(phys_device
, 0444, show_phys_device
, NULL
);
266 #define mem_create_simple_file(mem, attr_name) \
267 sysdev_create_file(&mem->sysdev, &attr_##attr_name)
268 #define mem_remove_simple_file(mem, attr_name) \
269 sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
272 * Block size attribute stuff
275 print_block_size(struct class *class, char *buf
)
277 return sprintf(buf
, "%lx\n", (unsigned long)PAGES_PER_SECTION
* PAGE_SIZE
);
280 static CLASS_ATTR(block_size_bytes
, 0444, print_block_size
, NULL
);
282 static int block_size_init(void)
284 return sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
285 &class_attr_block_size_bytes
.attr
);
289 * Some architectures will have custom drivers to do this, and
290 * will not need to do it from userspace. The fake hot-add code
291 * as well as ppc64 will do all of their discovery in userspace
292 * and will require this interface.
294 #ifdef CONFIG_ARCH_MEMORY_PROBE
296 memory_probe_store(struct class *class, const char *buf
, size_t count
)
302 phys_addr
= simple_strtoull(buf
, NULL
, 0);
304 nid
= memory_add_physaddr_to_nid(phys_addr
);
305 ret
= add_memory(nid
, phys_addr
, PAGES_PER_SECTION
<< PAGE_SHIFT
);
312 static CLASS_ATTR(probe
, 0700, NULL
, memory_probe_store
);
314 static int memory_probe_init(void)
316 return sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
317 &class_attr_probe
.attr
);
320 static inline int memory_probe_init(void)
327 * Note that phys_device is optional. It is here to allow for
328 * differentiation between which *physical* devices each
329 * section belongs to...
332 static int add_memory_block(unsigned long node_id
, struct mem_section
*section
,
333 unsigned long state
, int phys_device
)
335 struct memory_block
*mem
= kzalloc(sizeof(*mem
), GFP_KERNEL
);
341 mem
->phys_index
= __section_nr(section
);
343 mutex_init(&mem
->state_mutex
);
344 mem
->phys_device
= phys_device
;
346 ret
= register_memory(mem
, section
);
348 ret
= mem_create_simple_file(mem
, phys_index
);
350 ret
= mem_create_simple_file(mem
, state
);
352 ret
= mem_create_simple_file(mem
, phys_device
);
358 * For now, we have a linear search to go find the appropriate
359 * memory_block corresponding to a particular phys_index. If
360 * this gets to be a real problem, we can always use a radix
361 * tree or something here.
363 * This could be made generic for all sysdev classes.
365 static struct memory_block
*find_memory_block(struct mem_section
*section
)
367 struct kobject
*kobj
;
368 struct sys_device
*sysdev
;
369 struct memory_block
*mem
;
370 char name
[sizeof(MEMORY_CLASS_NAME
) + 9 + 1];
373 * This only works because we know that section == sysdev->id
374 * slightly redundant with sysdev_register()
376 sprintf(&name
[0], "%s%d", MEMORY_CLASS_NAME
, __section_nr(section
));
378 kobj
= kset_find_obj(&memory_sysdev_class
.kset
, name
);
382 sysdev
= container_of(kobj
, struct sys_device
, kobj
);
383 mem
= container_of(sysdev
, struct memory_block
, sysdev
);
388 int remove_memory_block(unsigned long node_id
, struct mem_section
*section
,
391 struct memory_block
*mem
;
393 mem
= find_memory_block(section
);
394 mem_remove_simple_file(mem
, phys_index
);
395 mem_remove_simple_file(mem
, state
);
396 mem_remove_simple_file(mem
, phys_device
);
397 unregister_memory(mem
, section
);
403 * need an interface for the VM to add new memory regions,
404 * but without onlining it.
406 int register_new_memory(struct mem_section
*section
)
408 return add_memory_block(0, section
, MEM_OFFLINE
, 0);
411 int unregister_memory_section(struct mem_section
*section
)
413 if (!present_section(section
))
416 return remove_memory_block(0, section
, 0);
420 * Initialize the sysfs support for memory devices...
422 int __init
memory_dev_init(void)
428 memory_sysdev_class
.kset
.uevent_ops
= &memory_uevent_ops
;
429 ret
= sysdev_class_register(&memory_sysdev_class
);
434 * Create entries for memory sections that were found
435 * during boot and have been initialized
437 for (i
= 0; i
< NR_MEM_SECTIONS
; i
++) {
438 if (!present_section_nr(i
))
440 err
= add_memory_block(0, __nr_to_section(i
), MEM_ONLINE
, 0);
445 err
= memory_probe_init();
448 err
= block_size_init();
453 printk(KERN_ERR
"%s() failed: %d\n", __func__
, ret
);