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/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>
23 #include <asm/atomic.h>
24 #include <asm/uaccess.h>
26 #define MEMORY_CLASS_NAME "memory"
28 static struct sysdev_class memory_sysdev_class
= {
29 set_kset_name(MEMORY_CLASS_NAME
),
32 static const char *memory_uevent_name(struct kset
*kset
, struct kobject
*kobj
)
34 return MEMORY_CLASS_NAME
;
37 static int memory_uevent(struct kset
*kset
, struct kobject
*kobj
, char **envp
,
38 int num_envp
, char *buffer
, int buffer_size
)
45 static struct kset_uevent_ops memory_uevent_ops
= {
46 .name
= memory_uevent_name
,
47 .uevent
= memory_uevent
,
50 static struct notifier_block
*memory_chain
;
52 static int register_memory_notifier(struct notifier_block
*nb
)
54 return notifier_chain_register(&memory_chain
, nb
);
57 static void unregister_memory_notifier(struct notifier_block
*nb
)
59 notifier_chain_unregister(&memory_chain
, nb
);
63 * register_memory - Setup a sysfs device for a memory block
66 register_memory(struct memory_block
*memory
, struct mem_section
*section
,
71 memory
->sysdev
.cls
= &memory_sysdev_class
;
72 memory
->sysdev
.id
= __section_nr(section
);
74 error
= sysdev_register(&memory
->sysdev
);
77 error
= sysfs_create_link(&root
->sysdev
.kobj
,
79 kobject_name(&memory
->sysdev
.kobj
));
85 unregister_memory(struct memory_block
*memory
, struct mem_section
*section
,
88 BUG_ON(memory
->sysdev
.cls
!= &memory_sysdev_class
);
89 BUG_ON(memory
->sysdev
.id
!= __section_nr(section
));
91 sysdev_unregister(&memory
->sysdev
);
93 sysfs_remove_link(&root
->sysdev
.kobj
,
94 kobject_name(&memory
->sysdev
.kobj
));
98 * use this as the physical section index that this memsection
102 static ssize_t
show_mem_phys_index(struct sys_device
*dev
, char *buf
)
104 struct memory_block
*mem
=
105 container_of(dev
, struct memory_block
, sysdev
);
106 return sprintf(buf
, "%08lx\n", mem
->phys_index
);
110 * online, offline, going offline, etc.
112 static ssize_t
show_mem_state(struct sys_device
*dev
, char *buf
)
114 struct memory_block
*mem
=
115 container_of(dev
, struct memory_block
, sysdev
);
119 * We can probably put these states in a nice little array
120 * so that they're not open-coded
122 switch (mem
->state
) {
124 len
= sprintf(buf
, "online\n");
127 len
= sprintf(buf
, "offline\n");
129 case MEM_GOING_OFFLINE
:
130 len
= sprintf(buf
, "going-offline\n");
133 len
= sprintf(buf
, "ERROR-UNKNOWN-%ld\n",
142 static inline int memory_notify(unsigned long val
, void *v
)
144 return notifier_call_chain(&memory_chain
, val
, v
);
148 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
149 * OK to have direct references to sparsemem variables in here.
152 memory_block_action(struct memory_block
*mem
, unsigned long action
)
155 unsigned long psection
;
156 unsigned long start_pfn
, start_paddr
;
157 struct page
*first_page
;
159 int old_state
= mem
->state
;
161 psection
= mem
->phys_index
;
162 first_page
= pfn_to_page(psection
<< PFN_SECTION_SHIFT
);
165 * The probe routines leave the pages reserved, just
166 * as the bootmem code does. Make sure they're still
169 if (action
== MEM_ONLINE
) {
170 for (i
= 0; i
< PAGES_PER_SECTION
; i
++) {
171 if (PageReserved(first_page
+i
))
174 printk(KERN_WARNING
"section number %ld page number %d "
175 "not reserved, was it already online? \n",
183 start_pfn
= page_to_pfn(first_page
);
184 ret
= online_pages(start_pfn
, PAGES_PER_SECTION
);
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
);
193 mem
->state
= old_state
;
196 memory_notify(MEM_MAPPING_INVALID
, NULL
);
199 printk(KERN_WARNING
"%s(%p, %ld) unknown action: %ld\n",
200 __FUNCTION__
, mem
, action
, action
);
205 * For now, only notify on successful memory operations
208 memory_notify(action
, NULL
);
213 static int memory_block_change_state(struct memory_block
*mem
,
214 unsigned long to_state
, unsigned long from_state_req
)
217 down(&mem
->state_sem
);
219 if (mem
->state
!= from_state_req
) {
224 ret
= memory_block_action(mem
, to_state
);
226 mem
->state
= to_state
;
234 store_mem_state(struct sys_device
*dev
, const char *buf
, size_t count
)
236 struct memory_block
*mem
;
237 unsigned int phys_section_nr
;
240 mem
= container_of(dev
, struct memory_block
, sysdev
);
241 phys_section_nr
= mem
->phys_index
;
243 if (!valid_section_nr(phys_section_nr
))
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
);
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?
265 static ssize_t
show_phys_device(struct sys_device
*dev
, char *buf
)
267 struct memory_block
*mem
=
268 container_of(dev
, struct memory_block
, sysdev
);
269 return sprintf(buf
, "%d\n", mem
->phys_device
);
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
);
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)
282 * Block size attribute stuff
285 print_block_size(struct class *class, char *buf
)
287 return sprintf(buf
, "%lx\n", (unsigned long)PAGES_PER_SECTION
* PAGE_SIZE
);
290 static CLASS_ATTR(block_size_bytes
, 0444, print_block_size
, NULL
);
292 static int block_size_init(void)
294 sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
295 &class_attr_block_size_bytes
.attr
);
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.
305 #ifdef CONFIG_ARCH_MEMORY_PROBE
307 memory_probe_store(struct class *class, const char __user
*buf
, size_t count
)
312 phys_addr
= simple_strtoull(buf
, NULL
, 0);
314 ret
= add_memory(phys_addr
, PAGES_PER_SECTION
<< PAGE_SHIFT
);
321 static CLASS_ATTR(probe
, 0700, NULL
, memory_probe_store
);
323 static int memory_probe_init(void)
325 sysfs_create_file(&memory_sysdev_class
.kset
.kobj
,
326 &class_attr_probe
.attr
);
330 #define memory_probe_init(...) do {} while (0)
334 * Note that phys_device is optional. It is here to allow for
335 * differentiation between which *physical* devices each
336 * section belongs to...
339 static int add_memory_block(unsigned long node_id
, struct mem_section
*section
,
340 unsigned long state
, int phys_device
)
342 struct memory_block
*mem
= kzalloc(sizeof(*mem
), GFP_KERNEL
);
348 mem
->phys_index
= __section_nr(section
);
350 init_MUTEX(&mem
->state_sem
);
351 mem
->phys_device
= phys_device
;
353 ret
= register_memory(mem
, section
, NULL
);
355 ret
= mem_create_simple_file(mem
, phys_index
);
357 ret
= mem_create_simple_file(mem
, state
);
359 ret
= mem_create_simple_file(mem
, phys_device
);
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.
370 * This could be made generic for all sysdev classes.
372 static struct memory_block
*find_memory_block(struct mem_section
*section
)
374 struct kobject
*kobj
;
375 struct sys_device
*sysdev
;
376 struct memory_block
*mem
;
377 char name
[sizeof(MEMORY_CLASS_NAME
) + 9 + 1];
380 * This only works because we know that section == sysdev->id
381 * slightly redundant with sysdev_register()
383 sprintf(&name
[0], "%s%d", MEMORY_CLASS_NAME
, __section_nr(section
));
385 kobj
= kset_find_obj(&memory_sysdev_class
.kset
, name
);
389 sysdev
= container_of(kobj
, struct sys_device
, kobj
);
390 mem
= container_of(sysdev
, struct memory_block
, sysdev
);
395 int remove_memory_block(unsigned long node_id
, struct mem_section
*section
,
398 struct memory_block
*mem
;
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
);
410 * need an interface for the VM to add new memory regions,
411 * but without onlining it.
413 int register_new_memory(struct mem_section
*section
)
415 return add_memory_block(0, section
, MEM_OFFLINE
, 0);
418 int unregister_memory_section(struct mem_section
*section
)
420 if (!valid_section(section
))
423 return remove_memory_block(0, section
, 0);
427 * Initialize the sysfs support for memory devices...
429 int __init
memory_dev_init(void)
434 memory_sysdev_class
.kset
.uevent_ops
= &memory_uevent_ops
;
435 ret
= sysdev_class_register(&memory_sysdev_class
);
438 * Create entries for memory sections that were found
439 * during boot and have been initialized
441 for (i
= 0; i
< NR_MEM_SECTIONS
; i
++) {
442 if (!valid_section_nr(i
))
444 add_memory_block(0, __nr_to_section(i
), MEM_ONLINE
, 0);