memory_hotplug.c revision 2f7f24eca31c4fc2fdb134b2ef743ccd67cfb9a9
1/* 2 * linux/mm/memory_hotplug.c 3 * 4 * Copyright (C) 5 */ 6 7#include <linux/stddef.h> 8#include <linux/mm.h> 9#include <linux/swap.h> 10#include <linux/interrupt.h> 11#include <linux/pagemap.h> 12#include <linux/bootmem.h> 13#include <linux/compiler.h> 14#include <linux/module.h> 15#include <linux/pagevec.h> 16#include <linux/writeback.h> 17#include <linux/slab.h> 18#include <linux/sysctl.h> 19#include <linux/cpu.h> 20#include <linux/memory.h> 21#include <linux/memory_hotplug.h> 22#include <linux/highmem.h> 23#include <linux/vmalloc.h> 24#include <linux/ioport.h> 25#include <linux/cpuset.h> 26#include <linux/delay.h> 27#include <linux/migrate.h> 28#include <linux/page-isolation.h> 29 30#include <asm/tlbflush.h> 31 32#include "internal.h" 33 34/* add this memory to iomem resource */ 35static struct resource *register_memory_resource(u64 start, u64 size) 36{ 37 struct resource *res; 38 res = kzalloc(sizeof(struct resource), GFP_KERNEL); 39 BUG_ON(!res); 40 41 res->name = "System RAM"; 42 res->start = start; 43 res->end = start + size - 1; 44 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 45 if (request_resource(&iomem_resource, res) < 0) { 46 printk("System RAM resource %llx - %llx cannot be added\n", 47 (unsigned long long)res->start, (unsigned long long)res->end); 48 kfree(res); 49 res = NULL; 50 } 51 return res; 52} 53 54static void release_memory_resource(struct resource *res) 55{ 56 if (!res) 57 return; 58 release_resource(res); 59 kfree(res); 60 return; 61} 62 63#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE 64#ifndef CONFIG_SPARSEMEM_VMEMMAP 65static void get_page_bootmem(unsigned long info, struct page *page, int type) 66{ 67 atomic_set(&page->_mapcount, type); 68 SetPagePrivate(page); 69 set_page_private(page, info); 70 atomic_inc(&page->_count); 71} 72 73void put_page_bootmem(struct page *page) 74{ 75 int type; 76 77 type = atomic_read(&page->_mapcount); 78 BUG_ON(type >= -1); 79 80 if (atomic_dec_return(&page->_count) == 1) { 81 ClearPagePrivate(page); 82 set_page_private(page, 0); 83 reset_page_mapcount(page); 84 __free_pages_bootmem(page, 0); 85 } 86 87} 88 89static void register_page_bootmem_info_section(unsigned long start_pfn) 90{ 91 unsigned long *usemap, mapsize, section_nr, i; 92 struct mem_section *ms; 93 struct page *page, *memmap; 94 95 if (!pfn_valid(start_pfn)) 96 return; 97 98 section_nr = pfn_to_section_nr(start_pfn); 99 ms = __nr_to_section(section_nr); 100 101 /* Get section's memmap address */ 102 memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr); 103 104 /* 105 * Get page for the memmap's phys address 106 * XXX: need more consideration for sparse_vmemmap... 107 */ 108 page = virt_to_page(memmap); 109 mapsize = sizeof(struct page) * PAGES_PER_SECTION; 110 mapsize = PAGE_ALIGN(mapsize) >> PAGE_SHIFT; 111 112 /* remember memmap's page */ 113 for (i = 0; i < mapsize; i++, page++) 114 get_page_bootmem(section_nr, page, SECTION_INFO); 115 116 usemap = __nr_to_section(section_nr)->pageblock_flags; 117 page = virt_to_page(usemap); 118 119 mapsize = PAGE_ALIGN(usemap_size()) >> PAGE_SHIFT; 120 121 for (i = 0; i < mapsize; i++, page++) 122 get_page_bootmem(section_nr, page, MIX_SECTION_INFO); 123 124} 125 126void register_page_bootmem_info_node(struct pglist_data *pgdat) 127{ 128 unsigned long i, pfn, end_pfn, nr_pages; 129 int node = pgdat->node_id; 130 struct page *page; 131 struct zone *zone; 132 133 nr_pages = PAGE_ALIGN(sizeof(struct pglist_data)) >> PAGE_SHIFT; 134 page = virt_to_page(pgdat); 135 136 for (i = 0; i < nr_pages; i++, page++) 137 get_page_bootmem(node, page, NODE_INFO); 138 139 zone = &pgdat->node_zones[0]; 140 for (; zone < pgdat->node_zones + MAX_NR_ZONES - 1; zone++) { 141 if (zone->wait_table) { 142 nr_pages = zone->wait_table_hash_nr_entries 143 * sizeof(wait_queue_head_t); 144 nr_pages = PAGE_ALIGN(nr_pages) >> PAGE_SHIFT; 145 page = virt_to_page(zone->wait_table); 146 147 for (i = 0; i < nr_pages; i++, page++) 148 get_page_bootmem(node, page, NODE_INFO); 149 } 150 } 151 152 pfn = pgdat->node_start_pfn; 153 end_pfn = pfn + pgdat->node_spanned_pages; 154 155 /* register_section info */ 156 for (; pfn < end_pfn; pfn += PAGES_PER_SECTION) 157 register_page_bootmem_info_section(pfn); 158 159} 160#endif /* !CONFIG_SPARSEMEM_VMEMMAP */ 161 162static void grow_zone_span(struct zone *zone, unsigned long start_pfn, 163 unsigned long end_pfn) 164{ 165 unsigned long old_zone_end_pfn; 166 167 zone_span_writelock(zone); 168 169 old_zone_end_pfn = zone->zone_start_pfn + zone->spanned_pages; 170 if (start_pfn < zone->zone_start_pfn) 171 zone->zone_start_pfn = start_pfn; 172 173 zone->spanned_pages = max(old_zone_end_pfn, end_pfn) - 174 zone->zone_start_pfn; 175 176 zone_span_writeunlock(zone); 177} 178 179static void grow_pgdat_span(struct pglist_data *pgdat, unsigned long start_pfn, 180 unsigned long end_pfn) 181{ 182 unsigned long old_pgdat_end_pfn = 183 pgdat->node_start_pfn + pgdat->node_spanned_pages; 184 185 if (start_pfn < pgdat->node_start_pfn) 186 pgdat->node_start_pfn = start_pfn; 187 188 pgdat->node_spanned_pages = max(old_pgdat_end_pfn, end_pfn) - 189 pgdat->node_start_pfn; 190} 191 192static int __add_zone(struct zone *zone, unsigned long phys_start_pfn) 193{ 194 struct pglist_data *pgdat = zone->zone_pgdat; 195 int nr_pages = PAGES_PER_SECTION; 196 int nid = pgdat->node_id; 197 int zone_type; 198 unsigned long flags; 199 200 zone_type = zone - pgdat->node_zones; 201 if (!zone->wait_table) { 202 int ret; 203 204 ret = init_currently_empty_zone(zone, phys_start_pfn, 205 nr_pages, MEMMAP_HOTPLUG); 206 if (ret) 207 return ret; 208 } 209 pgdat_resize_lock(zone->zone_pgdat, &flags); 210 grow_zone_span(zone, phys_start_pfn, phys_start_pfn + nr_pages); 211 grow_pgdat_span(zone->zone_pgdat, phys_start_pfn, 212 phys_start_pfn + nr_pages); 213 pgdat_resize_unlock(zone->zone_pgdat, &flags); 214 memmap_init_zone(nr_pages, nid, zone_type, 215 phys_start_pfn, MEMMAP_HOTPLUG); 216 return 0; 217} 218 219static int __add_section(struct zone *zone, unsigned long phys_start_pfn) 220{ 221 int nr_pages = PAGES_PER_SECTION; 222 int ret; 223 224 if (pfn_valid(phys_start_pfn)) 225 return -EEXIST; 226 227 ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages); 228 229 if (ret < 0) 230 return ret; 231 232 ret = __add_zone(zone, phys_start_pfn); 233 234 if (ret < 0) 235 return ret; 236 237 return register_new_memory(__pfn_to_section(phys_start_pfn)); 238} 239 240#ifdef CONFIG_SPARSEMEM_VMEMMAP 241static int __remove_section(struct zone *zone, struct mem_section *ms) 242{ 243 /* 244 * XXX: Freeing memmap with vmemmap is not implement yet. 245 * This should be removed later. 246 */ 247 return -EBUSY; 248} 249#else 250static int __remove_section(struct zone *zone, struct mem_section *ms) 251{ 252 unsigned long flags; 253 struct pglist_data *pgdat = zone->zone_pgdat; 254 int ret = -EINVAL; 255 256 if (!valid_section(ms)) 257 return ret; 258 259 ret = unregister_memory_section(ms); 260 if (ret) 261 return ret; 262 263 pgdat_resize_lock(pgdat, &flags); 264 sparse_remove_one_section(zone, ms); 265 pgdat_resize_unlock(pgdat, &flags); 266 return 0; 267} 268#endif 269 270/* 271 * Reasonably generic function for adding memory. It is 272 * expected that archs that support memory hotplug will 273 * call this function after deciding the zone to which to 274 * add the new pages. 275 */ 276int __add_pages(struct zone *zone, unsigned long phys_start_pfn, 277 unsigned long nr_pages) 278{ 279 unsigned long i; 280 int err = 0; 281 int start_sec, end_sec; 282 /* during initialize mem_map, align hot-added range to section */ 283 start_sec = pfn_to_section_nr(phys_start_pfn); 284 end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1); 285 286 for (i = start_sec; i <= end_sec; i++) { 287 err = __add_section(zone, i << PFN_SECTION_SHIFT); 288 289 /* 290 * EEXIST is finally dealt with by ioresource collision 291 * check. see add_memory() => register_memory_resource() 292 * Warning will be printed if there is collision. 293 */ 294 if (err && (err != -EEXIST)) 295 break; 296 err = 0; 297 } 298 299 return err; 300} 301EXPORT_SYMBOL_GPL(__add_pages); 302 303/** 304 * __remove_pages() - remove sections of pages from a zone 305 * @zone: zone from which pages need to be removed 306 * @phys_start_pfn: starting pageframe (must be aligned to start of a section) 307 * @nr_pages: number of pages to remove (must be multiple of section size) 308 * 309 * Generic helper function to remove section mappings and sysfs entries 310 * for the section of the memory we are removing. Caller needs to make 311 * sure that pages are marked reserved and zones are adjust properly by 312 * calling offline_pages(). 313 */ 314int __remove_pages(struct zone *zone, unsigned long phys_start_pfn, 315 unsigned long nr_pages) 316{ 317 unsigned long i, ret = 0; 318 int sections_to_remove; 319 320 /* 321 * We can only remove entire sections 322 */ 323 BUG_ON(phys_start_pfn & ~PAGE_SECTION_MASK); 324 BUG_ON(nr_pages % PAGES_PER_SECTION); 325 326 release_mem_region(phys_start_pfn << PAGE_SHIFT, nr_pages * PAGE_SIZE); 327 328 sections_to_remove = nr_pages / PAGES_PER_SECTION; 329 for (i = 0; i < sections_to_remove; i++) { 330 unsigned long pfn = phys_start_pfn + i*PAGES_PER_SECTION; 331 ret = __remove_section(zone, __pfn_to_section(pfn)); 332 if (ret) 333 break; 334 } 335 return ret; 336} 337EXPORT_SYMBOL_GPL(__remove_pages); 338 339void online_page(struct page *page) 340{ 341 totalram_pages++; 342 num_physpages++; 343 344#ifdef CONFIG_HIGHMEM 345 if (PageHighMem(page)) 346 totalhigh_pages++; 347#endif 348 349#ifdef CONFIG_FLATMEM 350 max_mapnr = max(page_to_pfn(page), max_mapnr); 351#endif 352 353 ClearPageReserved(page); 354 init_page_count(page); 355 __free_page(page); 356} 357 358static int online_pages_range(unsigned long start_pfn, unsigned long nr_pages, 359 void *arg) 360{ 361 unsigned long i; 362 unsigned long onlined_pages = *(unsigned long *)arg; 363 struct page *page; 364 if (PageReserved(pfn_to_page(start_pfn))) 365 for (i = 0; i < nr_pages; i++) { 366 page = pfn_to_page(start_pfn + i); 367 online_page(page); 368 onlined_pages++; 369 } 370 *(unsigned long *)arg = onlined_pages; 371 return 0; 372} 373 374 375int online_pages(unsigned long pfn, unsigned long nr_pages) 376{ 377 unsigned long onlined_pages = 0; 378 struct zone *zone; 379 int need_zonelists_rebuild = 0; 380 int nid; 381 int ret; 382 struct memory_notify arg; 383 384 arg.start_pfn = pfn; 385 arg.nr_pages = nr_pages; 386 arg.status_change_nid = -1; 387 388 nid = page_to_nid(pfn_to_page(pfn)); 389 if (node_present_pages(nid) == 0) 390 arg.status_change_nid = nid; 391 392 ret = memory_notify(MEM_GOING_ONLINE, &arg); 393 ret = notifier_to_errno(ret); 394 if (ret) { 395 memory_notify(MEM_CANCEL_ONLINE, &arg); 396 return ret; 397 } 398 /* 399 * This doesn't need a lock to do pfn_to_page(). 400 * The section can't be removed here because of the 401 * memory_block->state_mutex. 402 */ 403 zone = page_zone(pfn_to_page(pfn)); 404 /* 405 * If this zone is not populated, then it is not in zonelist. 406 * This means the page allocator ignores this zone. 407 * So, zonelist must be updated after online. 408 */ 409 if (!populated_zone(zone)) 410 need_zonelists_rebuild = 1; 411 412 ret = walk_memory_resource(pfn, nr_pages, &onlined_pages, 413 online_pages_range); 414 if (ret) { 415 printk(KERN_DEBUG "online_pages %lx at %lx failed\n", 416 nr_pages, pfn); 417 memory_notify(MEM_CANCEL_ONLINE, &arg); 418 return ret; 419 } 420 421 zone->present_pages += onlined_pages; 422 zone->zone_pgdat->node_present_pages += onlined_pages; 423 424 setup_per_zone_pages_min(); 425 if (onlined_pages) { 426 kswapd_run(zone_to_nid(zone)); 427 node_set_state(zone_to_nid(zone), N_HIGH_MEMORY); 428 } 429 430 if (need_zonelists_rebuild) 431 build_all_zonelists(); 432 else 433 vm_total_pages = nr_free_pagecache_pages(); 434 435 writeback_set_ratelimit(); 436 437 if (onlined_pages) 438 memory_notify(MEM_ONLINE, &arg); 439 440 return 0; 441} 442#endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */ 443 444static pg_data_t *hotadd_new_pgdat(int nid, u64 start) 445{ 446 struct pglist_data *pgdat; 447 unsigned long zones_size[MAX_NR_ZONES] = {0}; 448 unsigned long zholes_size[MAX_NR_ZONES] = {0}; 449 unsigned long start_pfn = start >> PAGE_SHIFT; 450 451 pgdat = arch_alloc_nodedata(nid); 452 if (!pgdat) 453 return NULL; 454 455 arch_refresh_nodedata(nid, pgdat); 456 457 /* we can use NODE_DATA(nid) from here */ 458 459 /* init node's zones as empty zones, we don't have any present pages.*/ 460 free_area_init_node(nid, zones_size, start_pfn, zholes_size); 461 462 return pgdat; 463} 464 465static void rollback_node_hotadd(int nid, pg_data_t *pgdat) 466{ 467 arch_refresh_nodedata(nid, NULL); 468 arch_free_nodedata(pgdat); 469 return; 470} 471 472 473int add_memory(int nid, u64 start, u64 size) 474{ 475 pg_data_t *pgdat = NULL; 476 int new_pgdat = 0; 477 struct resource *res; 478 int ret; 479 480 res = register_memory_resource(start, size); 481 if (!res) 482 return -EEXIST; 483 484 if (!node_online(nid)) { 485 pgdat = hotadd_new_pgdat(nid, start); 486 if (!pgdat) 487 return -ENOMEM; 488 new_pgdat = 1; 489 } 490 491 /* call arch's memory hotadd */ 492 ret = arch_add_memory(nid, start, size); 493 494 if (ret < 0) 495 goto error; 496 497 /* we online node here. we can't roll back from here. */ 498 node_set_online(nid); 499 500 cpuset_track_online_nodes(); 501 502 if (new_pgdat) { 503 ret = register_one_node(nid); 504 /* 505 * If sysfs file of new node can't create, cpu on the node 506 * can't be hot-added. There is no rollback way now. 507 * So, check by BUG_ON() to catch it reluctantly.. 508 */ 509 BUG_ON(ret); 510 } 511 512 return ret; 513error: 514 /* rollback pgdat allocation and others */ 515 if (new_pgdat) 516 rollback_node_hotadd(nid, pgdat); 517 if (res) 518 release_memory_resource(res); 519 520 return ret; 521} 522EXPORT_SYMBOL_GPL(add_memory); 523 524#ifdef CONFIG_MEMORY_HOTREMOVE 525/* 526 * Confirm all pages in a range [start, end) is belongs to the same zone. 527 */ 528static int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn) 529{ 530 unsigned long pfn; 531 struct zone *zone = NULL; 532 struct page *page; 533 int i; 534 for (pfn = start_pfn; 535 pfn < end_pfn; 536 pfn += MAX_ORDER_NR_PAGES) { 537 i = 0; 538 /* This is just a CONFIG_HOLES_IN_ZONE check.*/ 539 while ((i < MAX_ORDER_NR_PAGES) && !pfn_valid_within(pfn + i)) 540 i++; 541 if (i == MAX_ORDER_NR_PAGES) 542 continue; 543 page = pfn_to_page(pfn + i); 544 if (zone && page_zone(page) != zone) 545 return 0; 546 zone = page_zone(page); 547 } 548 return 1; 549} 550 551/* 552 * Scanning pfn is much easier than scanning lru list. 553 * Scan pfn from start to end and Find LRU page. 554 */ 555int scan_lru_pages(unsigned long start, unsigned long end) 556{ 557 unsigned long pfn; 558 struct page *page; 559 for (pfn = start; pfn < end; pfn++) { 560 if (pfn_valid(pfn)) { 561 page = pfn_to_page(pfn); 562 if (PageLRU(page)) 563 return pfn; 564 } 565 } 566 return 0; 567} 568 569static struct page * 570hotremove_migrate_alloc(struct page *page, 571 unsigned long private, 572 int **x) 573{ 574 /* This should be improoooooved!! */ 575 return alloc_page(GFP_HIGHUSER_PAGECACHE); 576} 577 578 579#define NR_OFFLINE_AT_ONCE_PAGES (256) 580static int 581do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) 582{ 583 unsigned long pfn; 584 struct page *page; 585 int move_pages = NR_OFFLINE_AT_ONCE_PAGES; 586 int not_managed = 0; 587 int ret = 0; 588 LIST_HEAD(source); 589 590 for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) { 591 if (!pfn_valid(pfn)) 592 continue; 593 page = pfn_to_page(pfn); 594 if (!page_count(page)) 595 continue; 596 /* 597 * We can skip free pages. And we can only deal with pages on 598 * LRU. 599 */ 600 ret = isolate_lru_page(page, &source); 601 if (!ret) { /* Success */ 602 move_pages--; 603 } else { 604 /* Becasue we don't have big zone->lock. we should 605 check this again here. */ 606 if (page_count(page)) 607 not_managed++; 608#ifdef CONFIG_DEBUG_VM 609 printk(KERN_INFO "removing from LRU failed" 610 " %lx/%d/%lx\n", 611 pfn, page_count(page), page->flags); 612#endif 613 } 614 } 615 ret = -EBUSY; 616 if (not_managed) { 617 if (!list_empty(&source)) 618 putback_lru_pages(&source); 619 goto out; 620 } 621 ret = 0; 622 if (list_empty(&source)) 623 goto out; 624 /* this function returns # of failed pages */ 625 ret = migrate_pages(&source, hotremove_migrate_alloc, 0); 626 627out: 628 return ret; 629} 630 631/* 632 * remove from free_area[] and mark all as Reserved. 633 */ 634static int 635offline_isolated_pages_cb(unsigned long start, unsigned long nr_pages, 636 void *data) 637{ 638 __offline_isolated_pages(start, start + nr_pages); 639 return 0; 640} 641 642static void 643offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn) 644{ 645 walk_memory_resource(start_pfn, end_pfn - start_pfn, NULL, 646 offline_isolated_pages_cb); 647} 648 649/* 650 * Check all pages in range, recoreded as memory resource, are isolated. 651 */ 652static int 653check_pages_isolated_cb(unsigned long start_pfn, unsigned long nr_pages, 654 void *data) 655{ 656 int ret; 657 long offlined = *(long *)data; 658 ret = test_pages_isolated(start_pfn, start_pfn + nr_pages); 659 offlined = nr_pages; 660 if (!ret) 661 *(long *)data += offlined; 662 return ret; 663} 664 665static long 666check_pages_isolated(unsigned long start_pfn, unsigned long end_pfn) 667{ 668 long offlined = 0; 669 int ret; 670 671 ret = walk_memory_resource(start_pfn, end_pfn - start_pfn, &offlined, 672 check_pages_isolated_cb); 673 if (ret < 0) 674 offlined = (long)ret; 675 return offlined; 676} 677 678int offline_pages(unsigned long start_pfn, 679 unsigned long end_pfn, unsigned long timeout) 680{ 681 unsigned long pfn, nr_pages, expire; 682 long offlined_pages; 683 int ret, drain, retry_max, node; 684 struct zone *zone; 685 struct memory_notify arg; 686 687 BUG_ON(start_pfn >= end_pfn); 688 /* at least, alignment against pageblock is necessary */ 689 if (!IS_ALIGNED(start_pfn, pageblock_nr_pages)) 690 return -EINVAL; 691 if (!IS_ALIGNED(end_pfn, pageblock_nr_pages)) 692 return -EINVAL; 693 /* This makes hotplug much easier...and readable. 694 we assume this for now. .*/ 695 if (!test_pages_in_a_zone(start_pfn, end_pfn)) 696 return -EINVAL; 697 698 zone = page_zone(pfn_to_page(start_pfn)); 699 node = zone_to_nid(zone); 700 nr_pages = end_pfn - start_pfn; 701 702 /* set above range as isolated */ 703 ret = start_isolate_page_range(start_pfn, end_pfn); 704 if (ret) 705 return ret; 706 707 arg.start_pfn = start_pfn; 708 arg.nr_pages = nr_pages; 709 arg.status_change_nid = -1; 710 if (nr_pages >= node_present_pages(node)) 711 arg.status_change_nid = node; 712 713 ret = memory_notify(MEM_GOING_OFFLINE, &arg); 714 ret = notifier_to_errno(ret); 715 if (ret) 716 goto failed_removal; 717 718 pfn = start_pfn; 719 expire = jiffies + timeout; 720 drain = 0; 721 retry_max = 5; 722repeat: 723 /* start memory hot removal */ 724 ret = -EAGAIN; 725 if (time_after(jiffies, expire)) 726 goto failed_removal; 727 ret = -EINTR; 728 if (signal_pending(current)) 729 goto failed_removal; 730 ret = 0; 731 if (drain) { 732 lru_add_drain_all(); 733 flush_scheduled_work(); 734 cond_resched(); 735 drain_all_pages(); 736 } 737 738 pfn = scan_lru_pages(start_pfn, end_pfn); 739 if (pfn) { /* We have page on LRU */ 740 ret = do_migrate_range(pfn, end_pfn); 741 if (!ret) { 742 drain = 1; 743 goto repeat; 744 } else { 745 if (ret < 0) 746 if (--retry_max == 0) 747 goto failed_removal; 748 yield(); 749 drain = 1; 750 goto repeat; 751 } 752 } 753 /* drain all zone's lru pagevec, this is asyncronous... */ 754 lru_add_drain_all(); 755 flush_scheduled_work(); 756 yield(); 757 /* drain pcp pages , this is synchrouns. */ 758 drain_all_pages(); 759 /* check again */ 760 offlined_pages = check_pages_isolated(start_pfn, end_pfn); 761 if (offlined_pages < 0) { 762 ret = -EBUSY; 763 goto failed_removal; 764 } 765 printk(KERN_INFO "Offlined Pages %ld\n", offlined_pages); 766 /* Ok, all of our target is islaoted. 767 We cannot do rollback at this point. */ 768 offline_isolated_pages(start_pfn, end_pfn); 769 /* reset pagetype flags and makes migrate type to be MOVABLE */ 770 undo_isolate_page_range(start_pfn, end_pfn); 771 /* removal success */ 772 zone->present_pages -= offlined_pages; 773 zone->zone_pgdat->node_present_pages -= offlined_pages; 774 totalram_pages -= offlined_pages; 775 num_physpages -= offlined_pages; 776 777 vm_total_pages = nr_free_pagecache_pages(); 778 writeback_set_ratelimit(); 779 780 memory_notify(MEM_OFFLINE, &arg); 781 return 0; 782 783failed_removal: 784 printk(KERN_INFO "memory offlining %lx to %lx failed\n", 785 start_pfn, end_pfn); 786 memory_notify(MEM_CANCEL_OFFLINE, &arg); 787 /* pushback to free area */ 788 undo_isolate_page_range(start_pfn, end_pfn); 789 790 return ret; 791} 792#else 793int remove_memory(u64 start, u64 size) 794{ 795 return -EINVAL; 796} 797EXPORT_SYMBOL_GPL(remove_memory); 798#endif /* CONFIG_MEMORY_HOTREMOVE */ 799