1 /* 2 * Memory subsystem 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/module.h> 14 #include <linux/init.h> 15 #include <linux/topology.h> 16 #include <linux/capability.h> 17 #include <linux/device.h> 18 #include <linux/memory.h> 19 #include <linux/memory_hotplug.h> 20 #include <linux/mm.h> 21 #include <linux/mutex.h> 22 #include <linux/stat.h> 23 #include <linux/slab.h> 24 25 #include <linux/atomic.h> 26 #include <linux/uaccess.h> 27 28 static DEFINE_MUTEX(mem_sysfs_mutex); 29 30 #define MEMORY_CLASS_NAME "memory" 31 32 #define to_memory_block(dev) container_of(dev, struct memory_block, dev) 33 34 static int sections_per_block; 35 36 static inline int base_memory_block_id(int section_nr) 37 { 38 return section_nr / sections_per_block; 39 } 40 41 static int memory_subsys_online(struct device *dev); 42 static int memory_subsys_offline(struct device *dev); 43 44 static struct bus_type memory_subsys = { 45 .name = MEMORY_CLASS_NAME, 46 .dev_name = MEMORY_CLASS_NAME, 47 .online = memory_subsys_online, 48 .offline = memory_subsys_offline, 49 }; 50 51 static BLOCKING_NOTIFIER_HEAD(memory_chain); 52 53 int register_memory_notifier(struct notifier_block *nb) 54 { 55 return blocking_notifier_chain_register(&memory_chain, nb); 56 } 57 EXPORT_SYMBOL(register_memory_notifier); 58 59 void unregister_memory_notifier(struct notifier_block *nb) 60 { 61 blocking_notifier_chain_unregister(&memory_chain, nb); 62 } 63 EXPORT_SYMBOL(unregister_memory_notifier); 64 65 static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain); 66 67 int register_memory_isolate_notifier(struct notifier_block *nb) 68 { 69 return atomic_notifier_chain_register(&memory_isolate_chain, nb); 70 } 71 EXPORT_SYMBOL(register_memory_isolate_notifier); 72 73 void unregister_memory_isolate_notifier(struct notifier_block *nb) 74 { 75 atomic_notifier_chain_unregister(&memory_isolate_chain, nb); 76 } 77 EXPORT_SYMBOL(unregister_memory_isolate_notifier); 78 79 static void memory_block_release(struct device *dev) 80 { 81 struct memory_block *mem = to_memory_block(dev); 82 83 kfree(mem); 84 } 85 86 unsigned long __weak memory_block_size_bytes(void) 87 { 88 return MIN_MEMORY_BLOCK_SIZE; 89 } 90 91 static unsigned long get_memory_block_size(void) 92 { 93 unsigned long block_sz; 94 95 block_sz = memory_block_size_bytes(); 96 97 /* Validate blk_sz is a power of 2 and not less than section size */ 98 if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) { 99 WARN_ON(1); 100 block_sz = MIN_MEMORY_BLOCK_SIZE; 101 } 102 103 return block_sz; 104 } 105 106 /* 107 * use this as the physical section index that this memsection 108 * uses. 109 */ 110 111 static ssize_t show_mem_start_phys_index(struct device *dev, 112 struct device_attribute *attr, char *buf) 113 { 114 struct memory_block *mem = to_memory_block(dev); 115 unsigned long phys_index; 116 117 phys_index = mem->start_section_nr / sections_per_block; 118 return sprintf(buf, "%08lx\n", phys_index); 119 } 120 121 /* 122 * Show whether the section of memory is likely to be hot-removable 123 */ 124 static ssize_t show_mem_removable(struct device *dev, 125 struct device_attribute *attr, char *buf) 126 { 127 unsigned long i, pfn; 128 int ret = 1; 129 struct memory_block *mem = to_memory_block(dev); 130 131 if (mem->state != MEM_ONLINE) 132 goto out; 133 134 for (i = 0; i < sections_per_block; i++) { 135 if (!present_section_nr(mem->start_section_nr + i)) 136 continue; 137 pfn = section_nr_to_pfn(mem->start_section_nr + i); 138 ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION); 139 } 140 141 out: 142 return sprintf(buf, "%d\n", ret); 143 } 144 145 /* 146 * online, offline, going offline, etc. 147 */ 148 static ssize_t show_mem_state(struct device *dev, 149 struct device_attribute *attr, char *buf) 150 { 151 struct memory_block *mem = to_memory_block(dev); 152 ssize_t len = 0; 153 154 /* 155 * We can probably put these states in a nice little array 156 * so that they're not open-coded 157 */ 158 switch (mem->state) { 159 case MEM_ONLINE: 160 len = sprintf(buf, "online\n"); 161 break; 162 case MEM_OFFLINE: 163 len = sprintf(buf, "offline\n"); 164 break; 165 case MEM_GOING_OFFLINE: 166 len = sprintf(buf, "going-offline\n"); 167 break; 168 default: 169 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n", 170 mem->state); 171 WARN_ON(1); 172 break; 173 } 174 175 return len; 176 } 177 178 int memory_notify(unsigned long val, void *v) 179 { 180 return blocking_notifier_call_chain(&memory_chain, val, v); 181 } 182 183 int memory_isolate_notify(unsigned long val, void *v) 184 { 185 return atomic_notifier_call_chain(&memory_isolate_chain, val, v); 186 } 187 188 /* 189 * The probe routines leave the pages reserved, just as the bootmem code does. 190 * Make sure they're still that way. 191 */ 192 static bool pages_correctly_reserved(unsigned long start_pfn) 193 { 194 int i, j; 195 struct page *page; 196 unsigned long pfn = start_pfn; 197 198 /* 199 * memmap between sections is not contiguous except with 200 * SPARSEMEM_VMEMMAP. We lookup the page once per section 201 * and assume memmap is contiguous within each section 202 */ 203 for (i = 0; i < sections_per_block; i++, pfn += PAGES_PER_SECTION) { 204 if (WARN_ON_ONCE(!pfn_valid(pfn))) 205 return false; 206 page = pfn_to_page(pfn); 207 208 for (j = 0; j < PAGES_PER_SECTION; j++) { 209 if (PageReserved(page + j)) 210 continue; 211 212 printk(KERN_WARNING "section number %ld page number %d " 213 "not reserved, was it already online?\n", 214 pfn_to_section_nr(pfn), j); 215 216 return false; 217 } 218 } 219 220 return true; 221 } 222 223 /* 224 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is 225 * OK to have direct references to sparsemem variables in here. 226 * Must already be protected by mem_hotplug_begin(). 227 */ 228 static int 229 memory_block_action(unsigned long phys_index, unsigned long action, int online_type) 230 { 231 unsigned long start_pfn; 232 unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block; 233 int ret; 234 235 start_pfn = section_nr_to_pfn(phys_index); 236 237 switch (action) { 238 case MEM_ONLINE: 239 if (!pages_correctly_reserved(start_pfn)) 240 return -EBUSY; 241 242 ret = online_pages(start_pfn, nr_pages, online_type); 243 break; 244 case MEM_OFFLINE: 245 ret = offline_pages(start_pfn, nr_pages); 246 break; 247 default: 248 WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: " 249 "%ld\n", __func__, phys_index, action, action); 250 ret = -EINVAL; 251 } 252 253 return ret; 254 } 255 256 static int memory_block_change_state(struct memory_block *mem, 257 unsigned long to_state, unsigned long from_state_req) 258 { 259 int ret = 0; 260 261 if (mem->state != from_state_req) 262 return -EINVAL; 263 264 if (to_state == MEM_OFFLINE) 265 mem->state = MEM_GOING_OFFLINE; 266 267 ret = memory_block_action(mem->start_section_nr, to_state, 268 mem->online_type); 269 270 mem->state = ret ? from_state_req : to_state; 271 272 return ret; 273 } 274 275 /* The device lock serializes operations on memory_subsys_[online|offline] */ 276 static int memory_subsys_online(struct device *dev) 277 { 278 struct memory_block *mem = to_memory_block(dev); 279 int ret; 280 281 if (mem->state == MEM_ONLINE) 282 return 0; 283 284 /* 285 * If we are called from store_mem_state(), online_type will be 286 * set >= 0 Otherwise we were called from the device online 287 * attribute and need to set the online_type. 288 */ 289 if (mem->online_type < 0) 290 mem->online_type = MMOP_ONLINE_KEEP; 291 292 /* Already under protection of mem_hotplug_begin() */ 293 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE); 294 295 /* clear online_type */ 296 mem->online_type = -1; 297 298 return ret; 299 } 300 301 static int memory_subsys_offline(struct device *dev) 302 { 303 struct memory_block *mem = to_memory_block(dev); 304 305 if (mem->state == MEM_OFFLINE) 306 return 0; 307 308 /* Can't offline block with non-present sections */ 309 if (mem->section_count != sections_per_block) 310 return -EINVAL; 311 312 return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE); 313 } 314 315 static ssize_t 316 store_mem_state(struct device *dev, 317 struct device_attribute *attr, const char *buf, size_t count) 318 { 319 struct memory_block *mem = to_memory_block(dev); 320 int ret, online_type; 321 322 ret = lock_device_hotplug_sysfs(); 323 if (ret) 324 return ret; 325 326 if (sysfs_streq(buf, "online_kernel")) 327 online_type = MMOP_ONLINE_KERNEL; 328 else if (sysfs_streq(buf, "online_movable")) 329 online_type = MMOP_ONLINE_MOVABLE; 330 else if (sysfs_streq(buf, "online")) 331 online_type = MMOP_ONLINE_KEEP; 332 else if (sysfs_streq(buf, "offline")) 333 online_type = MMOP_OFFLINE; 334 else { 335 ret = -EINVAL; 336 goto err; 337 } 338 339 /* 340 * Memory hotplug needs to hold mem_hotplug_begin() for probe to find 341 * the correct memory block to online before doing device_online(dev), 342 * which will take dev->mutex. Take the lock early to prevent an 343 * inversion, memory_subsys_online() callbacks will be implemented by 344 * assuming it's already protected. 345 */ 346 mem_hotplug_begin(); 347 348 switch (online_type) { 349 case MMOP_ONLINE_KERNEL: 350 case MMOP_ONLINE_MOVABLE: 351 case MMOP_ONLINE_KEEP: 352 mem->online_type = online_type; 353 ret = device_online(&mem->dev); 354 break; 355 case MMOP_OFFLINE: 356 ret = device_offline(&mem->dev); 357 break; 358 default: 359 ret = -EINVAL; /* should never happen */ 360 } 361 362 mem_hotplug_done(); 363 err: 364 unlock_device_hotplug(); 365 366 if (ret < 0) 367 return ret; 368 if (ret) 369 return -EINVAL; 370 371 return count; 372 } 373 374 /* 375 * phys_device is a bad name for this. What I really want 376 * is a way to differentiate between memory ranges that 377 * are part of physical devices that constitute 378 * a complete removable unit or fru. 379 * i.e. do these ranges belong to the same physical device, 380 * s.t. if I offline all of these sections I can then 381 * remove the physical device? 382 */ 383 static ssize_t show_phys_device(struct device *dev, 384 struct device_attribute *attr, char *buf) 385 { 386 struct memory_block *mem = to_memory_block(dev); 387 return sprintf(buf, "%d\n", mem->phys_device); 388 } 389 390 #ifdef CONFIG_MEMORY_HOTREMOVE 391 static void print_allowed_zone(char *buf, int nid, unsigned long start_pfn, 392 unsigned long nr_pages, int online_type, 393 struct zone *default_zone) 394 { 395 struct zone *zone; 396 397 zone = zone_for_pfn_range(online_type, nid, start_pfn, nr_pages); 398 if (zone != default_zone) { 399 strcat(buf, " "); 400 strcat(buf, zone->name); 401 } 402 } 403 404 static ssize_t show_valid_zones(struct device *dev, 405 struct device_attribute *attr, char *buf) 406 { 407 struct memory_block *mem = to_memory_block(dev); 408 unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); 409 unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block; 410 unsigned long valid_start_pfn, valid_end_pfn; 411 struct zone *default_zone; 412 int nid; 413 414 /* 415 * The block contains more than one zone can not be offlined. 416 * This can happen e.g. for ZONE_DMA and ZONE_DMA32 417 */ 418 if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages, &valid_start_pfn, &valid_end_pfn)) 419 return sprintf(buf, "none\n"); 420 421 start_pfn = valid_start_pfn; 422 nr_pages = valid_end_pfn - start_pfn; 423 424 /* 425 * Check the existing zone. Make sure that we do that only on the 426 * online nodes otherwise the page_zone is not reliable 427 */ 428 if (mem->state == MEM_ONLINE) { 429 strcat(buf, page_zone(pfn_to_page(start_pfn))->name); 430 goto out; 431 } 432 433 nid = pfn_to_nid(start_pfn); 434 default_zone = zone_for_pfn_range(MMOP_ONLINE_KEEP, nid, start_pfn, nr_pages); 435 strcat(buf, default_zone->name); 436 437 print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_KERNEL, 438 default_zone); 439 print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_MOVABLE, 440 default_zone); 441 out: 442 strcat(buf, "\n"); 443 444 return strlen(buf); 445 } 446 static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL); 447 #endif 448 449 static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL); 450 static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state); 451 static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL); 452 static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL); 453 454 /* 455 * Block size attribute stuff 456 */ 457 static ssize_t 458 print_block_size(struct device *dev, struct device_attribute *attr, 459 char *buf) 460 { 461 return sprintf(buf, "%lx\n", get_memory_block_size()); 462 } 463 464 static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL); 465 466 /* 467 * Memory auto online policy. 468 */ 469 470 static ssize_t 471 show_auto_online_blocks(struct device *dev, struct device_attribute *attr, 472 char *buf) 473 { 474 if (memhp_auto_online) 475 return sprintf(buf, "online\n"); 476 else 477 return sprintf(buf, "offline\n"); 478 } 479 480 static ssize_t 481 store_auto_online_blocks(struct device *dev, struct device_attribute *attr, 482 const char *buf, size_t count) 483 { 484 if (sysfs_streq(buf, "online")) 485 memhp_auto_online = true; 486 else if (sysfs_streq(buf, "offline")) 487 memhp_auto_online = false; 488 else 489 return -EINVAL; 490 491 return count; 492 } 493 494 static DEVICE_ATTR(auto_online_blocks, 0644, show_auto_online_blocks, 495 store_auto_online_blocks); 496 497 /* 498 * Some architectures will have custom drivers to do this, and 499 * will not need to do it from userspace. The fake hot-add code 500 * as well as ppc64 will do all of their discovery in userspace 501 * and will require this interface. 502 */ 503 #ifdef CONFIG_ARCH_MEMORY_PROBE 504 static ssize_t 505 memory_probe_store(struct device *dev, struct device_attribute *attr, 506 const char *buf, size_t count) 507 { 508 u64 phys_addr; 509 int nid, ret; 510 unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block; 511 512 ret = kstrtoull(buf, 0, &phys_addr); 513 if (ret) 514 return ret; 515 516 if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1)) 517 return -EINVAL; 518 519 nid = memory_add_physaddr_to_nid(phys_addr); 520 ret = add_memory(nid, phys_addr, 521 MIN_MEMORY_BLOCK_SIZE * sections_per_block); 522 523 if (ret) 524 goto out; 525 526 ret = count; 527 out: 528 return ret; 529 } 530 531 static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store); 532 #endif 533 534 #ifdef CONFIG_MEMORY_FAILURE 535 /* 536 * Support for offlining pages of memory 537 */ 538 539 /* Soft offline a page */ 540 static ssize_t 541 store_soft_offline_page(struct device *dev, 542 struct device_attribute *attr, 543 const char *buf, size_t count) 544 { 545 int ret; 546 u64 pfn; 547 if (!capable(CAP_SYS_ADMIN)) 548 return -EPERM; 549 if (kstrtoull(buf, 0, &pfn) < 0) 550 return -EINVAL; 551 pfn >>= PAGE_SHIFT; 552 if (!pfn_valid(pfn)) 553 return -ENXIO; 554 ret = soft_offline_page(pfn_to_page(pfn), 0); 555 return ret == 0 ? count : ret; 556 } 557 558 /* Forcibly offline a page, including killing processes. */ 559 static ssize_t 560 store_hard_offline_page(struct device *dev, 561 struct device_attribute *attr, 562 const char *buf, size_t count) 563 { 564 int ret; 565 u64 pfn; 566 if (!capable(CAP_SYS_ADMIN)) 567 return -EPERM; 568 if (kstrtoull(buf, 0, &pfn) < 0) 569 return -EINVAL; 570 pfn >>= PAGE_SHIFT; 571 ret = memory_failure(pfn, 0, 0); 572 return ret ? ret : count; 573 } 574 575 static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page); 576 static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page); 577 #endif 578 579 /* 580 * Note that phys_device is optional. It is here to allow for 581 * differentiation between which *physical* devices each 582 * section belongs to... 583 */ 584 int __weak arch_get_memory_phys_device(unsigned long start_pfn) 585 { 586 return 0; 587 } 588 589 /* 590 * A reference for the returned object is held and the reference for the 591 * hinted object is released. 592 */ 593 struct memory_block *find_memory_block_hinted(struct mem_section *section, 594 struct memory_block *hint) 595 { 596 int block_id = base_memory_block_id(__section_nr(section)); 597 struct device *hintdev = hint ? &hint->dev : NULL; 598 struct device *dev; 599 600 dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev); 601 if (hint) 602 put_device(&hint->dev); 603 if (!dev) 604 return NULL; 605 return to_memory_block(dev); 606 } 607 608 /* 609 * For now, we have a linear search to go find the appropriate 610 * memory_block corresponding to a particular phys_index. If 611 * this gets to be a real problem, we can always use a radix 612 * tree or something here. 613 * 614 * This could be made generic for all device subsystems. 615 */ 616 struct memory_block *find_memory_block(struct mem_section *section) 617 { 618 return find_memory_block_hinted(section, NULL); 619 } 620 621 static struct attribute *memory_memblk_attrs[] = { 622 &dev_attr_phys_index.attr, 623 &dev_attr_state.attr, 624 &dev_attr_phys_device.attr, 625 &dev_attr_removable.attr, 626 #ifdef CONFIG_MEMORY_HOTREMOVE 627 &dev_attr_valid_zones.attr, 628 #endif 629 NULL 630 }; 631 632 static struct attribute_group memory_memblk_attr_group = { 633 .attrs = memory_memblk_attrs, 634 }; 635 636 static const struct attribute_group *memory_memblk_attr_groups[] = { 637 &memory_memblk_attr_group, 638 NULL, 639 }; 640 641 /* 642 * register_memory - Setup a sysfs device for a memory block 643 */ 644 static 645 int register_memory(struct memory_block *memory) 646 { 647 memory->dev.bus = &memory_subsys; 648 memory->dev.id = memory->start_section_nr / sections_per_block; 649 memory->dev.release = memory_block_release; 650 memory->dev.groups = memory_memblk_attr_groups; 651 memory->dev.offline = memory->state == MEM_OFFLINE; 652 653 return device_register(&memory->dev); 654 } 655 656 static int init_memory_block(struct memory_block **memory, 657 struct mem_section *section, unsigned long state) 658 { 659 struct memory_block *mem; 660 unsigned long start_pfn; 661 int scn_nr; 662 int ret = 0; 663 664 mem = kzalloc(sizeof(*mem), GFP_KERNEL); 665 if (!mem) 666 return -ENOMEM; 667 668 scn_nr = __section_nr(section); 669 mem->start_section_nr = 670 base_memory_block_id(scn_nr) * sections_per_block; 671 mem->end_section_nr = mem->start_section_nr + sections_per_block - 1; 672 mem->state = state; 673 start_pfn = section_nr_to_pfn(mem->start_section_nr); 674 mem->phys_device = arch_get_memory_phys_device(start_pfn); 675 676 ret = register_memory(mem); 677 678 *memory = mem; 679 return ret; 680 } 681 682 static int add_memory_block(int base_section_nr) 683 { 684 struct memory_block *mem; 685 int i, ret, section_count = 0, section_nr; 686 687 for (i = base_section_nr; 688 (i < base_section_nr + sections_per_block) && i < NR_MEM_SECTIONS; 689 i++) { 690 if (!present_section_nr(i)) 691 continue; 692 if (section_count == 0) 693 section_nr = i; 694 section_count++; 695 } 696 697 if (section_count == 0) 698 return 0; 699 ret = init_memory_block(&mem, __nr_to_section(section_nr), MEM_ONLINE); 700 if (ret) 701 return ret; 702 mem->section_count = section_count; 703 return 0; 704 } 705 706 /* 707 * need an interface for the VM to add new memory regions, 708 * but without onlining it. 709 */ 710 int register_new_memory(int nid, struct mem_section *section) 711 { 712 int ret = 0; 713 struct memory_block *mem; 714 715 mutex_lock(&mem_sysfs_mutex); 716 717 mem = find_memory_block(section); 718 if (mem) { 719 mem->section_count++; 720 put_device(&mem->dev); 721 } else { 722 ret = init_memory_block(&mem, section, MEM_OFFLINE); 723 if (ret) 724 goto out; 725 mem->section_count++; 726 } 727 728 if (mem->section_count == sections_per_block) 729 ret = register_mem_sect_under_node(mem, nid); 730 out: 731 mutex_unlock(&mem_sysfs_mutex); 732 return ret; 733 } 734 735 #ifdef CONFIG_MEMORY_HOTREMOVE 736 static void 737 unregister_memory(struct memory_block *memory) 738 { 739 BUG_ON(memory->dev.bus != &memory_subsys); 740 741 /* drop the ref. we got in remove_memory_block() */ 742 put_device(&memory->dev); 743 device_unregister(&memory->dev); 744 } 745 746 static int remove_memory_section(unsigned long node_id, 747 struct mem_section *section, int phys_device) 748 { 749 struct memory_block *mem; 750 751 mutex_lock(&mem_sysfs_mutex); 752 753 /* 754 * Some users of the memory hotplug do not want/need memblock to 755 * track all sections. Skip over those. 756 */ 757 mem = find_memory_block(section); 758 if (!mem) 759 goto out_unlock; 760 761 unregister_mem_sect_under_nodes(mem, __section_nr(section)); 762 763 mem->section_count--; 764 if (mem->section_count == 0) 765 unregister_memory(mem); 766 else 767 put_device(&mem->dev); 768 769 out_unlock: 770 mutex_unlock(&mem_sysfs_mutex); 771 return 0; 772 } 773 774 int unregister_memory_section(struct mem_section *section) 775 { 776 if (!present_section(section)) 777 return -EINVAL; 778 779 return remove_memory_section(0, section, 0); 780 } 781 #endif /* CONFIG_MEMORY_HOTREMOVE */ 782 783 /* return true if the memory block is offlined, otherwise, return false */ 784 bool is_memblock_offlined(struct memory_block *mem) 785 { 786 return mem->state == MEM_OFFLINE; 787 } 788 789 static struct attribute *memory_root_attrs[] = { 790 #ifdef CONFIG_ARCH_MEMORY_PROBE 791 &dev_attr_probe.attr, 792 #endif 793 794 #ifdef CONFIG_MEMORY_FAILURE 795 &dev_attr_soft_offline_page.attr, 796 &dev_attr_hard_offline_page.attr, 797 #endif 798 799 &dev_attr_block_size_bytes.attr, 800 &dev_attr_auto_online_blocks.attr, 801 NULL 802 }; 803 804 static struct attribute_group memory_root_attr_group = { 805 .attrs = memory_root_attrs, 806 }; 807 808 static const struct attribute_group *memory_root_attr_groups[] = { 809 &memory_root_attr_group, 810 NULL, 811 }; 812 813 /* 814 * Initialize the sysfs support for memory devices... 815 */ 816 int __init memory_dev_init(void) 817 { 818 unsigned int i; 819 int ret; 820 int err; 821 unsigned long block_sz; 822 823 ret = subsys_system_register(&memory_subsys, memory_root_attr_groups); 824 if (ret) 825 goto out; 826 827 block_sz = get_memory_block_size(); 828 sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE; 829 830 /* 831 * Create entries for memory sections that were found 832 * during boot and have been initialized 833 */ 834 mutex_lock(&mem_sysfs_mutex); 835 for (i = 0; i < NR_MEM_SECTIONS; i += sections_per_block) { 836 /* Don't iterate over sections we know are !present: */ 837 if (i > __highest_present_section_nr) 838 break; 839 840 err = add_memory_block(i); 841 if (!ret) 842 ret = err; 843 } 844 mutex_unlock(&mem_sysfs_mutex); 845 846 out: 847 if (ret) 848 printk(KERN_ERR "%s() failed: %d\n", __func__, ret); 849 return ret; 850 } 851