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 32static struct sysdev_class memory_sysdev_class = { 33 .name = MEMORY_CLASS_NAME, 34}; 35 36static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj) 37{ 38 return MEMORY_CLASS_NAME; 39} 40 41static 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 48static const struct kset_uevent_ops memory_uevent_ops = { 49 .name = memory_uevent_name, 50 .uevent = memory_uevent, 51}; 52 53static BLOCKING_NOTIFIER_HEAD(memory_chain); 54 55int register_memory_notifier(struct notifier_block *nb) 56{ 57 return blocking_notifier_chain_register(&memory_chain, nb); 58} 59EXPORT_SYMBOL(register_memory_notifier); 60 61void unregister_memory_notifier(struct notifier_block *nb) 62{ 63 blocking_notifier_chain_unregister(&memory_chain, nb); 64} 65EXPORT_SYMBOL(unregister_memory_notifier); 66 67static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain); 68 69int register_memory_isolate_notifier(struct notifier_block *nb) 70{ 71 return atomic_notifier_chain_register(&memory_isolate_chain, nb); 72} 73EXPORT_SYMBOL(register_memory_isolate_notifier); 74 75void unregister_memory_isolate_notifier(struct notifier_block *nb) 76{ 77 atomic_notifier_chain_unregister(&memory_isolate_chain, nb); 78} 79EXPORT_SYMBOL(unregister_memory_isolate_notifier); 80 81/* 82 * register_memory - Setup a sysfs device for a memory block 83 */ 84static 85int 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 96static void 97unregister_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 112static 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 */ 123static 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 */ 139static 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 170int memory_notify(unsigned long val, void *v) 171{ 172 return blocking_notifier_call_chain(&memory_chain, val, v); 173} 174 175int 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 */ 184static int 185memory_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 238static 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 253out: 254 mutex_unlock(&mem->state_mutex); 255 return ret; 256} 257 258static ssize_t 259store_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); 276out: 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 */ 291static 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 299static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL); 300static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state); 301static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL); 302static 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 */ 312static ssize_t 313print_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 319static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL); 320 321static 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 334static ssize_t 335memory_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} 352static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store); 353 354static int memory_probe_init(void) 355{ 356 return sysfs_create_file(&memory_sysdev_class.kset.kobj, 357 &class_attr_probe.attr); 358} 359#else 360static 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 */ 372static ssize_t 373store_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. */ 391static ssize_t 392store_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 407static CLASS_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page); 408static CLASS_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page); 409 410static __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 422static 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 */ 433int __weak arch_get_memory_phys_device(unsigned long start_pfn) 434{ 435 return 0; 436} 437 438static 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 */ 479struct 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 502int 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 */ 522int register_new_memory(int nid, struct mem_section *section) 523{ 524 return add_memory_block(nid, section, MEM_OFFLINE, HOTPLUG); 525} 526 527int 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 */ 538int __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; 571out: 572 if (ret) 573 printk(KERN_ERR "%s() failed: %d\n", __func__, ret); 574 return ret; 575} 576