mm/memory_hotplug.c

   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/sched/signal.h>
  10 #include <linux/swap.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/pagemap.h>
  13 #include <linux/compiler.h>
  14 #include <linux/export.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/memremap.h>
  22 #include <linux/memory_hotplug.h>
  23 #include <linux/highmem.h>
  24 #include <linux/vmalloc.h>
  25 #include <linux/ioport.h>
  26 #include <linux/delay.h>
  27 #include <linux/migrate.h>
  28 #include <linux/page-isolation.h>
  29 #include <linux/pfn.h>
  30 #include <linux/suspend.h>
  31 #include <linux/mm_inline.h>
  32 #include <linux/firmware-map.h>
  33 #include <linux/stop_machine.h>
  34 #include <linux/hugetlb.h>
  35 #include <linux/memblock.h>
  36 #include <linux/bootmem.h>
  37 #include <linux/compaction.h>
  38
  39 #include <asm/tlbflush.h>
  40
  41 #include "internal.h"
  42
  43 /*
  44  * online_page_callback contains pointer to current page onlining function.
  45  * Initially it is generic_online_page(). If it is required it could be
  46  * changed by calling set_online_page_callback() for callback registration
  47  * and restore_online_page_callback() for generic callback restore.
  48  */
  49
  50 static void generic_online_page(struct page *page);
  51
  52 static online_page_callback_t online_page_callback = generic_online_page;
  53 static DEFINE_MUTEX(online_page_callback_lock);
  54
  55 /* The same as the cpu_hotplug lock, but for memory hotplug. */
  56 static struct {
  57         struct task_struct *active_writer;
  58         struct mutex lock; /* Synchronizes accesses to refcount, */
  59         /*
  60          * Also blocks the new readers during
  61          * an ongoing mem hotplug operation.
  62          */
  63         int refcount;
  64
  65 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  66         struct lockdep_map dep_map;
  67 #endif
  68 } mem_hotplug = {
  69         .active_writer = NULL,
  70         .lock = __MUTEX_INITIALIZER(mem_hotplug.lock),
  71         .refcount = 0,
  72 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  73         .dep_map = {.name = "mem_hotplug.lock" },
  74 #endif
  75 };
  76
  77 /* Lockdep annotations for get/put_online_mems() and mem_hotplug_begin/end() */
  78 #define memhp_lock_acquire_read() lock_map_acquire_read(&mem_hotplug.dep_map)
  79 #define memhp_lock_acquire()      lock_map_acquire(&mem_hotplug.dep_map)
  80 #define memhp_lock_release()      lock_map_release(&mem_hotplug.dep_map)
  81
  82 bool movable_node_enabled = false;
  83
  84 #ifndef CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE
  85 bool memhp_auto_online;
  86 #else
  87 bool memhp_auto_online = true;
  88 #endif
  89 EXPORT_SYMBOL_GPL(memhp_auto_online);
  90
  91 static int __init setup_memhp_default_state(char *str)
  92 {
  93         if (!strcmp(str, "online"))
  94                 memhp_auto_online = true;
  95         else if (!strcmp(str, "offline"))
  96                 memhp_auto_online = false;
  97
  98         return 1;
  99 }
 100 __setup("memhp_default_state=", setup_memhp_default_state);
 101
 102 void get_online_mems(void)
 103 {
 104         might_sleep();
 105         if (mem_hotplug.active_writer == current)
 106                 return;
 107         memhp_lock_acquire_read();
 108         mutex_lock(&mem_hotplug.lock);
 109         mem_hotplug.refcount++;
 110         mutex_unlock(&mem_hotplug.lock);
 111
 112 }
 113
 114 void put_online_mems(void)
 115 {
 116         if (mem_hotplug.active_writer == current)
 117                 return;
 118         mutex_lock(&mem_hotplug.lock);
 119
 120         if (WARN_ON(!mem_hotplug.refcount))
 121                 mem_hotplug.refcount++; /* try to fix things up */
 122
 123         if (!--mem_hotplug.refcount && unlikely(mem_hotplug.active_writer))
 124                 wake_up_process(mem_hotplug.active_writer);
 125         mutex_unlock(&mem_hotplug.lock);
 126         memhp_lock_release();
 127
 128 }
 129
 130 /* Serializes write accesses to mem_hotplug.active_writer. */
 131 static DEFINE_MUTEX(memory_add_remove_lock);
 132
 133 void mem_hotplug_begin(void)
 134 {
 135         mutex_lock(&memory_add_remove_lock);
 136
 137         mem_hotplug.active_writer = current;
 138
 139         memhp_lock_acquire();
 140         for (;;) {
 141                 mutex_lock(&mem_hotplug.lock);
 142                 if (likely(!mem_hotplug.refcount))
 143                         break;
 144                 __set_current_state(TASK_UNINTERRUPTIBLE);
 145                 mutex_unlock(&mem_hotplug.lock);
 146                 schedule();
 147         }
 148 }
 149
 150 void mem_hotplug_done(void)
 151 {
 152         mem_hotplug.active_writer = NULL;
 153         mutex_unlock(&mem_hotplug.lock);
 154         memhp_lock_release();
 155         mutex_unlock(&memory_add_remove_lock);
 156 }
 157
 158 /* add this memory to iomem resource */
 159 static struct resource *register_memory_resource(u64 start, u64 size)
 160 {
 161         struct resource *res;
 162         res = kzalloc(sizeof(struct resource), GFP_KERNEL);
 163         if (!res)
 164                 return ERR_PTR(-ENOMEM);
 165
 166         res->name = "System RAM";
 167         res->start = start;
 168         res->end = start + size - 1;
 169         res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 170         if (request_resource(&iomem_resource, res) < 0) {
 171                 pr_debug("System RAM resource %pR cannot be added\n", res);
 172                 kfree(res);
 173                 return ERR_PTR(-EEXIST);
 174         }
 175         return res;
 176 }
 177
 178 static void release_memory_resource(struct resource *res)
 179 {
 180         if (!res)
 181                 return;
 182         release_resource(res);
 183         kfree(res);
 184         return;
 185 }
 186
 187 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
 188 void get_page_bootmem(unsigned long info,  struct page *page,
 189                       unsigned long type)
 190 {
 191         page->freelist = (void *)type;
 192         SetPagePrivate(page);
 193         set_page_private(page, info);
 194         page_ref_inc(page);
 195 }
 196
 197 void put_page_bootmem(struct page *page)
 198 {
 199         unsigned long type;
 200
 201         type = (unsigned long) page->freelist;
 202         BUG_ON(type < MEMORY_HOTPLUG_MIN_BOOTMEM_TYPE ||
 203                type > MEMORY_HOTPLUG_MAX_BOOTMEM_TYPE);
 204
 205         if (page_ref_dec_return(page) == 1) {
 206                 page->freelist = NULL;
 207                 ClearPagePrivate(page);
 208                 set_page_private(page, 0);
 209                 INIT_LIST_HEAD(&page->lru);
 210                 free_reserved_page(page);
 211         }
 212 }
 213
 214 #ifdef CONFIG_HAVE_BOOTMEM_INFO_NODE
 215 #ifndef CONFIG_SPARSEMEM_VMEMMAP
 216 static void register_page_bootmem_info_section(unsigned long start_pfn)
 217 {
 218         unsigned long *usemap, mapsize, section_nr, i;
 219         struct mem_section *ms;
 220         struct page *page, *memmap;
 221
 222         section_nr = pfn_to_section_nr(start_pfn);
 223         ms = __nr_to_section(section_nr);
 224
 225         /* Get section's memmap address */
 226         memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);
 227
 228         /*
 229          * Get page for the memmap's phys address
 230          * XXX: need more consideration for sparse_vmemmap...
 231          */
 232         page = virt_to_page(memmap);
 233         mapsize = sizeof(struct page) * PAGES_PER_SECTION;
 234         mapsize = PAGE_ALIGN(mapsize) >> PAGE_SHIFT;
 235
 236         /* remember memmap's page */
 237         for (i = 0; i < mapsize; i++, page++)
 238                 get_page_bootmem(section_nr, page, SECTION_INFO);
 239
 240         usemap = __nr_to_section(section_nr)->pageblock_flags;
 241         page = virt_to_page(usemap);
 242
 243         mapsize = PAGE_ALIGN(usemap_size()) >> PAGE_SHIFT;
 244
 245         for (i = 0; i < mapsize; i++, page++)
 246                 get_page_bootmem(section_nr, page, MIX_SECTION_INFO);
 247
 248 }
 249 #else /* CONFIG_SPARSEMEM_VMEMMAP */
 250 static void register_page_bootmem_info_section(unsigned long start_pfn)
 251 {
 252         unsigned long *usemap, mapsize, section_nr, i;
 253         struct mem_section *ms;
 254         struct page *page, *memmap;
 255
 256         if (!pfn_valid(start_pfn))
 257                 return;
 258
 259         section_nr = pfn_to_section_nr(start_pfn);
 260         ms = __nr_to_section(section_nr);
 261
 262         memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);
 263
 264         register_page_bootmem_memmap(section_nr, memmap, PAGES_PER_SECTION);
 265
 266         usemap = __nr_to_section(section_nr)->pageblock_flags;
 267         page = virt_to_page(usemap);
 268
 269         mapsize = PAGE_ALIGN(usemap_size()) >> PAGE_SHIFT;
 270
 271         for (i = 0; i < mapsize; i++, page++)
 272                 get_page_bootmem(section_nr, page, MIX_SECTION_INFO);
 273 }
 274 #endif /* !CONFIG_SPARSEMEM_VMEMMAP */
 275
 276 void __init register_page_bootmem_info_node(struct pglist_data *pgdat)
 277 {
 278         unsigned long i, pfn, end_pfn, nr_pages;
 279         int node = pgdat->node_id;
 280         struct page *page;
 281
 282         nr_pages = PAGE_ALIGN(sizeof(struct pglist_data)) >> PAGE_SHIFT;
 283         page = virt_to_page(pgdat);
 284
 285         for (i = 0; i < nr_pages; i++, page++)
 286                 get_page_bootmem(node, page, NODE_INFO);
 287
 288         pfn = pgdat->node_start_pfn;
 289         end_pfn = pgdat_end_pfn(pgdat);
 290
 291         /* register section info */
 292         for (; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
 293                 /*
 294                  * Some platforms can assign the same pfn to multiple nodes - on
 295                  * node0 as well as nodeN.  To avoid registering a pfn against
 296                  * multiple nodes we check that this pfn does not already
 297                  * reside in some other nodes.
 298                  */
 299                 if (pfn_valid(pfn) && (early_pfn_to_nid(pfn) == node))
 300                         register_page_bootmem_info_section(pfn);
 301         }
 302 }
 303 #endif /* CONFIG_HAVE_BOOTMEM_INFO_NODE */
 304
 305 static int __meminit __add_section(int nid, unsigned long phys_start_pfn,
 306                 bool want_memblock)
 307 {
 308         int ret;
 309         int i;
 310
 311         if (pfn_valid(phys_start_pfn))
 312                 return -EEXIST;
 313
 314         ret = sparse_add_one_section(NODE_DATA(nid), phys_start_pfn);
 315         if (ret < 0)
 316                 return ret;
 317
 318         /*
 319          * Make all the pages reserved so that nobody will stumble over half
 320          * initialized state.
 321          * FIXME: We also have to associate it with a node because pfn_to_node
 322          * relies on having page with the proper node.
 323          */
 324         for (i = 0; i < PAGES_PER_SECTION; i++) {
 325                 unsigned long pfn = phys_start_pfn + i;
 326                 struct page *page;
 327                 if (!pfn_valid(pfn))
 328                         continue;
 329
 330                 page = pfn_to_page(pfn);
 331                 set_page_node(page, nid);
 332                 SetPageReserved(page);
 333         }
 334
 335         if (!want_memblock)
 336                 return 0;
 337
 338         return register_new_memory(nid, __pfn_to_section(phys_start_pfn));
 339 }
 340
 341 /*
 342  * Reasonably generic function for adding memory.  It is
 343  * expected that archs that support memory hotplug will
 344  * call this function after deciding the zone to which to
 345  * add the new pages.
 346  */
 347 int __ref __add_pages(int nid, unsigned long phys_start_pfn,
 348                         unsigned long nr_pages, bool want_memblock)
 349 {
 350         unsigned long i;
 351         int err = 0;
 352         int start_sec, end_sec;
 353         struct vmem_altmap *altmap;
 354
 355         /* during initialize mem_map, align hot-added range to section */
 356         start_sec = pfn_to_section_nr(phys_start_pfn);
 357         end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
 358
 359         altmap = to_vmem_altmap((unsigned long) pfn_to_page(phys_start_pfn));
 360         if (altmap) {
 361                 /*
 362                  * Validate altmap is within bounds of the total request
 363                  */
 364                 if (altmap->base_pfn != phys_start_pfn
 365                                 || vmem_altmap_offset(altmap) > nr_pages) {
 366                         pr_warn_once("memory add fail, invalid altmap\n");
 367                         err = -EINVAL;
 368                         goto out;
 369                 }
 370                 altmap->alloc = 0;
 371         }
 372
 373         for (i = start_sec; i <= end_sec; i++) {
 374                 err = __add_section(nid, section_nr_to_pfn(i), want_memblock);
 375
 376                 /*
 377                  * EEXIST is finally dealt with by ioresource collision
 378                  * check. see add_memory() => register_memory_resource()
 379                  * Warning will be printed if there is collision.
 380                  */
 381                 if (err && (err != -EEXIST))
 382                         break;
 383                 err = 0;
 384         }
 385         vmemmap_populate_print_last();
 386 out:
 387         return err;
 388 }
 389 EXPORT_SYMBOL_GPL(__add_pages);
 390
 391 #ifdef CONFIG_MEMORY_HOTREMOVE
 392 /* find the smallest valid pfn in the range [start_pfn, end_pfn) */
 393 static int find_smallest_section_pfn(int nid, struct zone *zone,
 394                                      unsigned long start_pfn,
 395                                      unsigned long end_pfn)
 396 {
 397         struct mem_section *ms;
 398
 399         for (; start_pfn < end_pfn; start_pfn += PAGES_PER_SECTION) {
 400                 ms = __pfn_to_section(start_pfn);
 401
 402                 if (unlikely(!valid_section(ms)))
 403                         continue;
 404
 405                 if (unlikely(pfn_to_nid(start_pfn) != nid))
 406                         continue;
 407
 408                 if (zone && zone != page_zone(pfn_to_page(start_pfn)))
 409                         continue;
 410
 411                 return start_pfn;
 412         }
 413
 414         return 0;
 415 }
 416
 417 /* find the biggest valid pfn in the range [start_pfn, end_pfn). */
 418 static int find_biggest_section_pfn(int nid, struct zone *zone,
 419                                     unsigned long start_pfn,
 420                                     unsigned long end_pfn)
 421 {
 422         struct mem_section *ms;
 423         unsigned long pfn;
 424
 425         /* pfn is the end pfn of a memory section. */
 426         pfn = end_pfn - 1;
 427         for (; pfn >= start_pfn; pfn -= PAGES_PER_SECTION) {
 428                 ms = __pfn_to_section(pfn);
 429
 430                 if (unlikely(!valid_section(ms)))
 431                         continue;
 432
 433                 if (unlikely(pfn_to_nid(pfn) != nid))
 434                         continue;
 435
 436                 if (zone && zone != page_zone(pfn_to_page(pfn)))
 437                         continue;
 438
 439                 return pfn;
 440         }
 441
 442         return 0;
 443 }
 444
 445 static void shrink_zone_span(struct zone *zone, unsigned long start_pfn,
 446                              unsigned long end_pfn)
 447 {
 448         unsigned long zone_start_pfn = zone->zone_start_pfn;
 449         unsigned long z = zone_end_pfn(zone); /* zone_end_pfn namespace clash */
 450         unsigned long zone_end_pfn = z;
 451         unsigned long pfn;
 452         struct mem_section *ms;
 453         int nid = zone_to_nid(zone);
 454
 455         zone_span_writelock(zone);
 456         if (zone_start_pfn == start_pfn) {
 457                 /*
 458                  * If the section is smallest section in the zone, it need
 459                  * shrink zone->zone_start_pfn and zone->zone_spanned_pages.
 460                  * In this case, we find second smallest valid mem_section
 461                  * for shrinking zone.
 462                  */
 463                 pfn = find_smallest_section_pfn(nid, zone, end_pfn,
 464                                                 zone_end_pfn);
 465                 if (pfn) {
 466                         zone->zone_start_pfn = pfn;
 467                         zone->spanned_pages = zone_end_pfn - pfn;
 468                 }
 469         } else if (zone_end_pfn == end_pfn) {
 470                 /*
 471                  * If the section is biggest section in the zone, it need
 472                  * shrink zone->spanned_pages.
 473                  * In this case, we find second biggest valid mem_section for
 474                  * shrinking zone.
 475                  */
 476                 pfn = find_biggest_section_pfn(nid, zone, zone_start_pfn,
 477                                                start_pfn);
 478                 if (pfn)
 479                         zone->spanned_pages = pfn - zone_start_pfn + 1;
 480         }
 481
 482         /*
 483          * The section is not biggest or smallest mem_section in the zone, it
 484          * only creates a hole in the zone. So in this case, we need not
 485          * change the zone. But perhaps, the zone has only hole data. Thus
 486          * it check the zone has only hole or not.
 487          */
 488         pfn = zone_start_pfn;
 489         for (; pfn < zone_end_pfn; pfn += PAGES_PER_SECTION) {
 490                 ms = __pfn_to_section(pfn);
 491
 492                 if (unlikely(!valid_section(ms)))
 493                         continue;
 494
 495                 if (page_zone(pfn_to_page(pfn)) != zone)
 496                         continue;
 497
 498                  /* If the section is current section, it continues the loop */
 499                 if (start_pfn == pfn)
 500                         continue;
 501
 502                 /* If we find valid section, we have nothing to do */
 503                 zone_span_writeunlock(zone);
 504                 return;
 505         }
 506
 507         /* The zone has no valid section */
 508         zone->zone_start_pfn = 0;
 509         zone->spanned_pages = 0;
 510         zone_span_writeunlock(zone);
 511 }
 512
 513 static void shrink_pgdat_span(struct pglist_data *pgdat,
 514                               unsigned long start_pfn, unsigned long end_pfn)
 515 {
 516         unsigned long pgdat_start_pfn = pgdat->node_start_pfn;
 517         unsigned long p = pgdat_end_pfn(pgdat); /* pgdat_end_pfn namespace clash */
 518         unsigned long pgdat_end_pfn = p;
 519         unsigned long pfn;
 520         struct mem_section *ms;
 521         int nid = pgdat->node_id;
 522
 523         if (pgdat_start_pfn == start_pfn) {
 524                 /*
 525                  * If the section is smallest section in the pgdat, it need
 526                  * shrink pgdat->node_start_pfn and pgdat->node_spanned_pages.
 527                  * In this case, we find second smallest valid mem_section
 528                  * for shrinking zone.
 529                  */
 530                 pfn = find_smallest_section_pfn(nid, NULL, end_pfn,
 531                                                 pgdat_end_pfn);
 532                 if (pfn) {
 533                         pgdat->node_start_pfn = pfn;
 534                         pgdat->node_spanned_pages = pgdat_end_pfn - pfn;
 535                 }
 536         } else if (pgdat_end_pfn == end_pfn) {
 537                 /*
 538                  * If the section is biggest section in the pgdat, it need
 539                  * shrink pgdat->node_spanned_pages.
 540                  * In this case, we find second biggest valid mem_section for
 541                  * shrinking zone.
 542                  */
 543                 pfn = find_biggest_section_pfn(nid, NULL, pgdat_start_pfn,
 544                                                start_pfn);
 545                 if (pfn)
 546                         pgdat->node_spanned_pages = pfn - pgdat_start_pfn + 1;
 547         }
 548
 549         /*
 550          * If the section is not biggest or smallest mem_section in the pgdat,
 551          * it only creates a hole in the pgdat. So in this case, we need not
 552          * change the pgdat.
 553          * But perhaps, the pgdat has only hole data. Thus it check the pgdat
 554          * has only hole or not.
 555          */
 556         pfn = pgdat_start_pfn;
 557         for (; pfn < pgdat_end_pfn; pfn += PAGES_PER_SECTION) {
 558                 ms = __pfn_to_section(pfn);
 559
 560                 if (unlikely(!valid_section(ms)))
 561                         continue;
 562
 563                 if (pfn_to_nid(pfn) != nid)
 564                         continue;
 565
 566                  /* If the section is current section, it continues the loop */
 567                 if (start_pfn == pfn)
 568                         continue;
 569
 570                 /* If we find valid section, we have nothing to do */
 571                 return;
 572         }
 573
 574         /* The pgdat has no valid section */
 575         pgdat->node_start_pfn = 0;
 576         pgdat->node_spanned_pages = 0;
 577 }
 578
 579 static void __remove_zone(struct zone *zone, unsigned long start_pfn)
 580 {
 581         struct pglist_data *pgdat = zone->zone_pgdat;
 582         int nr_pages = PAGES_PER_SECTION;
 583         unsigned long flags;
 584
 585         pgdat_resize_lock(zone->zone_pgdat, &flags);
 586         shrink_zone_span(zone, start_pfn, start_pfn + nr_pages);
 587         shrink_pgdat_span(pgdat, start_pfn, start_pfn + nr_pages);
 588         pgdat_resize_unlock(zone->zone_pgdat, &flags);
 589 }
 590
 591 static int __remove_section(struct zone *zone, struct mem_section *ms,
 592                 unsigned long map_offset)
 593 {
 594         unsigned long start_pfn;
 595         int scn_nr;
 596         int ret = -EINVAL;
 597
 598         if (!valid_section(ms))
 599                 return ret;
 600
 601         ret = unregister_memory_section(ms);
 602         if (ret)
 603                 return ret;
 604
 605         scn_nr = __section_nr(ms);
 606         start_pfn = section_nr_to_pfn(scn_nr);
 607         __remove_zone(zone, start_pfn);
 608
 609         sparse_remove_one_section(zone, ms, map_offset);
 610         return 0;
 611 }
 612
 613 /**
 614  * __remove_pages() - remove sections of pages from a zone
 615  * @zone: zone from which pages need to be removed
 616  * @phys_start_pfn: starting pageframe (must be aligned to start of a section)
 617  * @nr_pages: number of pages to remove (must be multiple of section size)
 618  *
 619  * Generic helper function to remove section mappings and sysfs entries
 620  * for the section of the memory we are removing. Caller needs to make
 621  * sure that pages are marked reserved and zones are adjust properly by
 622  * calling offline_pages().
 623  */
 624 int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
 625                  unsigned long nr_pages)
 626 {
 627         unsigned long i;
 628         unsigned long map_offset = 0;
 629         int sections_to_remove, ret = 0;
 630
 631         /* In the ZONE_DEVICE case device driver owns the memory region */
 632         if (is_dev_zone(zone)) {
 633                 struct page *page = pfn_to_page(phys_start_pfn);
 634                 struct vmem_altmap *altmap;
 635
 636                 altmap = to_vmem_altmap((unsigned long) page);
 637                 if (altmap)
 638                         map_offset = vmem_altmap_offset(altmap);
 639         } else {
 640                 resource_size_t start, size;
 641
 642                 start = phys_start_pfn << PAGE_SHIFT;
 643                 size = nr_pages * PAGE_SIZE;
 644
 645                 ret = release_mem_region_adjustable(&iomem_resource, start,
 646                                         size);
 647                 if (ret) {
 648                         resource_size_t endres = start + size - 1;
 649
 650                         pr_warn("Unable to release resource <%pa-%pa> (%d)\n",
 651                                         &start, &endres, ret);
 652                 }
 653         }
 654
 655         clear_zone_contiguous(zone);
 656
 657         /*
 658          * We can only remove entire sections
 659          */
 660         BUG_ON(phys_start_pfn & ~PAGE_SECTION_MASK);
 661         BUG_ON(nr_pages % PAGES_PER_SECTION);
 662
 663         sections_to_remove = nr_pages / PAGES_PER_SECTION;
 664         for (i = 0; i < sections_to_remove; i++) {
 665                 unsigned long pfn = phys_start_pfn + i*PAGES_PER_SECTION;
 666
 667                 ret = __remove_section(zone, __pfn_to_section(pfn), map_offset);
 668                 map_offset = 0;
 669                 if (ret)
 670                         break;
 671         }
 672
 673         set_zone_contiguous(zone);
 674
 675         return ret;
 676 }
 677 #endif /* CONFIG_MEMORY_HOTREMOVE */
 678
 679 int set_online_page_callback(online_page_callback_t callback)
 680 {
 681         int rc = -EINVAL;
 682
 683         get_online_mems();
 684         mutex_lock(&online_page_callback_lock);
 685
 686         if (online_page_callback == generic_online_page) {
 687                 online_page_callback = callback;
 688                 rc = 0;
 689         }
 690
 691         mutex_unlock(&online_page_callback_lock);
 692         put_online_mems();
 693
 694         return rc;
 695 }
 696 EXPORT_SYMBOL_GPL(set_online_page_callback);
 697
 698 int restore_online_page_callback(online_page_callback_t callback)
 699 {
 700         int rc = -EINVAL;
 701
 702         get_online_mems();
 703         mutex_lock(&online_page_callback_lock);
 704
 705         if (online_page_callback == callback) {
 706                 online_page_callback = generic_online_page;
 707                 rc = 0;
 708         }
 709
 710         mutex_unlock(&online_page_callback_lock);
 711         put_online_mems();
 712
 713         return rc;
 714 }
 715 EXPORT_SYMBOL_GPL(restore_online_page_callback);
 716
 717 void __online_page_set_limits(struct page *page)
 718 {
 719 }
 720 EXPORT_SYMBOL_GPL(__online_page_set_limits);
 721
 722 void __online_page_increment_counters(struct page *page)
 723 {
 724         adjust_managed_page_count(page, 1);
 725 }
 726 EXPORT_SYMBOL_GPL(__online_page_increment_counters);
 727
 728 void __online_page_free(struct page *page)
 729 {
 730         __free_reserved_page(page);
 731 }
 732 EXPORT_SYMBOL_GPL(__online_page_free);
 733
 734 static void generic_online_page(struct page *page)
 735 {
 736         __online_page_set_limits(page);
 737         __online_page_increment_counters(page);
 738         __online_page_free(page);
 739 }
 740
 741 static int online_pages_range(unsigned long start_pfn, unsigned long nr_pages,
 742                         void *arg)
 743 {
 744         unsigned long i;
 745         unsigned long onlined_pages = *(unsigned long *)arg;
 746         struct page *page;
 747
 748         if (PageReserved(pfn_to_page(start_pfn)))
 749                 for (i = 0; i < nr_pages; i++) {
 750                         page = pfn_to_page(start_pfn + i);
 751                         (*online_page_callback)(page);
 752                         onlined_pages++;
 753                 }
 754
 755         online_mem_sections(start_pfn, start_pfn + nr_pages);
 756
 757         *(unsigned long *)arg = onlined_pages;
 758         return 0;
 759 }
 760
 761 /* check which state of node_states will be changed when online memory */
 762 static void node_states_check_changes_online(unsigned long nr_pages,
 763         struct zone *zone, struct memory_notify *arg)
 764 {
 765         int nid = zone_to_nid(zone);
 766         enum zone_type zone_last = ZONE_NORMAL;
 767
 768         /*
 769          * If we have HIGHMEM or movable node, node_states[N_NORMAL_MEMORY]
 770          * contains nodes which have zones of 0...ZONE_NORMAL,
 771          * set zone_last to ZONE_NORMAL.
 772          *
 773          * If we don't have HIGHMEM nor movable node,
 774          * node_states[N_NORMAL_MEMORY] contains nodes which have zones of
 775          * 0...ZONE_MOVABLE, set zone_last to ZONE_MOVABLE.
 776          */
 777         if (N_MEMORY == N_NORMAL_MEMORY)
 778                 zone_last = ZONE_MOVABLE;
 779
 780         /*
 781          * if the memory to be online is in a zone of 0...zone_last, and
 782          * the zones of 0...zone_last don't have memory before online, we will
 783          * need to set the node to node_states[N_NORMAL_MEMORY] after
 784          * the memory is online.
 785          */
 786         if (zone_idx(zone) <= zone_last && !node_state(nid, N_NORMAL_MEMORY))
 787                 arg->status_change_nid_normal = nid;
 788         else
 789                 arg->status_change_nid_normal = -1;
 790
 791 #ifdef CONFIG_HIGHMEM
 792         /*
 793          * If we have movable node, node_states[N_HIGH_MEMORY]
 794          * contains nodes which have zones of 0...ZONE_HIGHMEM,
 795          * set zone_last to ZONE_HIGHMEM.
 796          *
 797          * If we don't have movable node, node_states[N_NORMAL_MEMORY]
 798          * contains nodes which have zones of 0...ZONE_MOVABLE,
 799          * set zone_last to ZONE_MOVABLE.
 800          */
 801         zone_last = ZONE_HIGHMEM;
 802         if (N_MEMORY == N_HIGH_MEMORY)
 803                 zone_last = ZONE_MOVABLE;
 804
 805         if (zone_idx(zone) <= zone_last && !node_state(nid, N_HIGH_MEMORY))
 806                 arg->status_change_nid_high = nid;
 807         else
 808                 arg->status_change_nid_high = -1;
 809 #else
 810         arg->status_change_nid_high = arg->status_change_nid_normal;
 811 #endif
 812
 813         /*
 814          * if the node don't have memory befor online, we will need to
 815          * set the node to node_states[N_MEMORY] after the memory
 816          * is online.
 817          */
 818         if (!node_state(nid, N_MEMORY))
 819                 arg->status_change_nid = nid;
 820         else
 821                 arg->status_change_nid = -1;
 822 }
 823
 824 static void node_states_set_node(int node, struct memory_notify *arg)
 825 {
 826         if (arg->status_change_nid_normal >= 0)
 827                 node_set_state(node, N_NORMAL_MEMORY);
 828
 829         if (arg->status_change_nid_high >= 0)
 830                 node_set_state(node, N_HIGH_MEMORY);
 831
 832         node_set_state(node, N_MEMORY);
 833 }
 834
 835 bool allow_online_pfn_range(int nid, unsigned long pfn, unsigned long nr_pages, int online_type)
 836 {
 837         struct pglist_data *pgdat = NODE_DATA(nid);
 838         struct zone *movable_zone = &pgdat->node_zones[ZONE_MOVABLE];
 839         struct zone *default_zone = default_zone_for_pfn(nid, pfn, nr_pages);
 840
 841         /*
 842          * TODO there shouldn't be any inherent reason to have ZONE_NORMAL
 843          * physically before ZONE_MOVABLE. All we need is they do not
 844          * overlap. Historically we didn't allow ZONE_NORMAL after ZONE_MOVABLE
 845          * though so let's stick with it for simplicity for now.
 846          * TODO make sure we do not overlap with ZONE_DEVICE
 847          */
 848         if (online_type == MMOP_ONLINE_KERNEL) {
 849                 if (zone_is_empty(movable_zone))
 850                         return true;
 851                 return movable_zone->zone_start_pfn >= pfn + nr_pages;
 852         } else if (online_type == MMOP_ONLINE_MOVABLE) {
 853                 return zone_end_pfn(default_zone) <= pfn;
 854         }
 855
 856         /* MMOP_ONLINE_KEEP will always succeed and inherits the current zone */
 857         return online_type == MMOP_ONLINE_KEEP;
 858 }
 859
 860 static void __meminit resize_zone_range(struct zone *zone, unsigned long start_pfn,
 861                 unsigned long nr_pages)
 862 {
 863         unsigned long old_end_pfn = zone_end_pfn(zone);
 864
 865         if (zone_is_empty(zone) || start_pfn < zone->zone_start_pfn)
 866                 zone->zone_start_pfn = start_pfn;
 867
 868         zone->spanned_pages = max(start_pfn + nr_pages, old_end_pfn) - zone->zone_start_pfn;
 869 }
 870
 871 static void __meminit resize_pgdat_range(struct pglist_data *pgdat, unsigned long start_pfn,
 872                                      unsigned long nr_pages)
 873 {
 874         unsigned long old_end_pfn = pgdat_end_pfn(pgdat);
 875
 876         if (!pgdat->node_spanned_pages || start_pfn < pgdat->node_start_pfn)
 877                 pgdat->node_start_pfn = start_pfn;
 878
 879         pgdat->node_spanned_pages = max(start_pfn + nr_pages, old_end_pfn) - pgdat->node_start_pfn;
 880 }
 881
 882 void __ref move_pfn_range_to_zone(struct zone *zone,
 883                 unsigned long start_pfn, unsigned long nr_pages)
 884 {
 885         struct pglist_data *pgdat = zone->zone_pgdat;
 886         int nid = pgdat->node_id;
 887         unsigned long flags;
 888
 889         if (zone_is_empty(zone))
 890                 init_currently_empty_zone(zone, start_pfn, nr_pages);
 891
 892         clear_zone_contiguous(zone);
 893
 894         /* TODO Huh pgdat is irqsave while zone is not. It used to be like that before */
 895         pgdat_resize_lock(pgdat, &flags);
 896         zone_span_writelock(zone);
 897         resize_zone_range(zone, start_pfn, nr_pages);
 898         zone_span_writeunlock(zone);
 899         resize_pgdat_range(pgdat, start_pfn, nr_pages);
 900         pgdat_resize_unlock(pgdat, &flags);
 901
 902         /*
 903          * TODO now we have a visible range of pages which are not associated
 904          * with their zone properly. Not nice but set_pfnblock_flags_mask
 905          * expects the zone spans the pfn range. All the pages in the range
 906          * are reserved so nobody should be touching them so we should be safe
 907          */
 908         memmap_init_zone(nr_pages, nid, zone_idx(zone), start_pfn, MEMMAP_HOTPLUG);
 909
 910         set_zone_contiguous(zone);
 911 }
 912
 913 /*
 914  * Returns a default kernel memory zone for the given pfn range.
 915  * If no kernel zone covers this pfn range it will automatically go
 916  * to the ZONE_NORMAL.
 917  */
 918 struct zone *default_zone_for_pfn(int nid, unsigned long start_pfn,
 919                 unsigned long nr_pages)
 920 {
 921         struct pglist_data *pgdat = NODE_DATA(nid);
 922         int zid;
 923
 924         for (zid = 0; zid <= ZONE_NORMAL; zid++) {
 925                 struct zone *zone = &pgdat->node_zones[zid];
 926
 927                 if (zone_intersects(zone, start_pfn, nr_pages))
 928                         return zone;
 929         }
 930
 931         return &pgdat->node_zones[ZONE_NORMAL];
 932 }
 933
 934 static inline bool movable_pfn_range(int nid, struct zone *default_zone,
 935                 unsigned long start_pfn, unsigned long nr_pages)
 936 {
 937         if (!allow_online_pfn_range(nid, start_pfn, nr_pages,
 938                                 MMOP_ONLINE_KERNEL))
 939                 return true;
 940
 941         if (!movable_node_is_enabled())
 942                 return false;
 943
 944         return !zone_intersects(default_zone, start_pfn, nr_pages);
 945 }
 946
 947 /*
 948  * Associates the given pfn range with the given node and the zone appropriate
 949  * for the given online type.
 950  */
 951 static struct zone * __meminit move_pfn_range(int online_type, int nid,
 952                 unsigned long start_pfn, unsigned long nr_pages)
 953 {
 954         struct pglist_data *pgdat = NODE_DATA(nid);
 955         struct zone *zone = default_zone_for_pfn(nid, start_pfn, nr_pages);
 956
 957         if (online_type == MMOP_ONLINE_KEEP) {
 958                 struct zone *movable_zone = &pgdat->node_zones[ZONE_MOVABLE];
 959                 /*
 960                  * MMOP_ONLINE_KEEP defaults to MMOP_ONLINE_KERNEL but use
 961                  * movable zone if that is not possible (e.g. we are within
 962                  * or past the existing movable zone). movable_node overrides
 963                  * this default and defaults to movable zone
 964                  */
 965                 if (movable_pfn_range(nid, zone, start_pfn, nr_pages))
 966                         zone = movable_zone;
 967         } else if (online_type == MMOP_ONLINE_MOVABLE) {
 968                 zone = &pgdat->node_zones[ZONE_MOVABLE];
 969         }
 970
 971         move_pfn_range_to_zone(zone, start_pfn, nr_pages);
 972         return zone;
 973 }
 974
 975 /* Must be protected by mem_hotplug_begin() */
 976 int __ref online_pages(unsigned long pfn, unsigned long nr_pages, int online_type)
 977 {
 978         unsigned long flags;
 979         unsigned long onlined_pages = 0;
 980         struct zone *zone;
 981         int need_zonelists_rebuild = 0;
 982         int nid;
 983         int ret;
 984         struct memory_notify arg;
 985
 986         nid = pfn_to_nid(pfn);
 987         if (!allow_online_pfn_range(nid, pfn, nr_pages, online_type))
 988                 return -EINVAL;
 989
 990         /* associate pfn range with the zone */
 991         zone = move_pfn_range(online_type, nid, pfn, nr_pages);
 992
 993         arg.start_pfn = pfn;
 994         arg.nr_pages = nr_pages;
 995         node_states_check_changes_online(nr_pages, zone, &arg);
 996
 997         ret = memory_notify(MEM_GOING_ONLINE, &arg);
 998         ret = notifier_to_errno(ret);
 999         if (ret)
1000                 goto failed_addition;
1001
1002         /*
1003          * If this zone is not populated, then it is not in zonelist.
1004          * This means the page allocator ignores this zone.
1005          * So, zonelist must be updated after online.
1006          */
1007         mutex_lock(&zonelists_mutex);
1008         if (!populated_zone(zone)) {
1009                 need_zonelists_rebuild = 1;
1010                 build_all_zonelists(NULL, zone);
1011         }
1012
1013         ret = walk_system_ram_range(pfn, nr_pages, &onlined_pages,
1014                 online_pages_range);
1015         if (ret) {
1016                 if (need_zonelists_rebuild)
1017                         zone_pcp_reset(zone);
1018                 mutex_unlock(&zonelists_mutex);
1019                 goto failed_addition;
1020         }
1021
1022         zone->present_pages += onlined_pages;
1023
1024         pgdat_resize_lock(zone->zone_pgdat, &flags);
1025         zone->zone_pgdat->node_present_pages += onlined_pages;
1026         pgdat_resize_unlock(zone->zone_pgdat, &flags);
1027
1028         if (onlined_pages) {
1029                 node_states_set_node(nid, &arg);
1030                 if (need_zonelists_rebuild)
1031                         build_all_zonelists(NULL, NULL);
1032                 else
1033                         zone_pcp_update(zone);
1034         }
1035
1036         mutex_unlock(&zonelists_mutex);
1037
1038         init_per_zone_wmark_min();
1039
1040         if (onlined_pages) {
1041                 kswapd_run(nid);
1042                 kcompactd_run(nid);
1043         }
1044
1045         vm_total_pages = nr_free_pagecache_pages();
1046
1047         writeback_set_ratelimit();
1048
1049         if (onlined_pages)
1050                 memory_notify(MEM_ONLINE, &arg);
1051         return 0;
1052
1053 failed_addition:
1054         pr_debug("online_pages [mem %#010llx-%#010llx] failed\n",
1055                  (unsigned long long) pfn << PAGE_SHIFT,
1056                  (((unsigned long long) pfn + nr_pages) << PAGE_SHIFT) - 1);
1057         memory_notify(MEM_CANCEL_ONLINE, &arg);
1058         return ret;
1059 }
1060 #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
1061
1062 static void reset_node_present_pages(pg_data_t *pgdat)
1063 {
1064         struct zone *z;
1065
1066         for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
1067                 z->present_pages = 0;
1068
1069         pgdat->node_present_pages = 0;
1070 }
1071
1072 /* we are OK calling __meminit stuff here - we have CONFIG_MEMORY_HOTPLUG */
1073 static pg_data_t __ref *hotadd_new_pgdat(int nid, u64 start)
1074 {
1075         struct pglist_data *pgdat;
1076         unsigned long zones_size[MAX_NR_ZONES] = {0};
1077         unsigned long zholes_size[MAX_NR_ZONES] = {0};
1078         unsigned long start_pfn = PFN_DOWN(start);
1079
1080         pgdat = NODE_DATA(nid);
1081         if (!pgdat) {
1082                 pgdat = arch_alloc_nodedata(nid);
1083                 if (!pgdat)
1084                         return NULL;
1085
1086                 arch_refresh_nodedata(nid, pgdat);
1087         } else {
1088                 /*
1089                  * Reset the nr_zones, order and classzone_idx before reuse.
1090                  * Note that kswapd will init kswapd_classzone_idx properly
1091                  * when it starts in the near future.
1092                  */
1093                 pgdat->nr_zones = 0;
1094                 pgdat->kswapd_order = 0;
1095                 pgdat->kswapd_classzone_idx = 0;
1096         }
1097
1098         /* we can use NODE_DATA(nid) from here */
1099
1100         /* init node's zones as empty zones, we don't have any present pages.*/
1101         free_area_init_node(nid, zones_size, start_pfn, zholes_size);
1102         pgdat->per_cpu_nodestats = alloc_percpu(struct per_cpu_nodestat);
1103
1104         /*
1105          * The node we allocated has no zone fallback lists. For avoiding
1106          * to access not-initialized zonelist, build here.
1107          */
1108         mutex_lock(&zonelists_mutex);
1109         build_all_zonelists(pgdat, NULL);
1110         mutex_unlock(&zonelists_mutex);
1111
1112         /*
1113          * zone->managed_pages is set to an approximate value in
1114          * free_area_init_core(), which will cause
1115          * /sys/device/system/node/nodeX/meminfo has wrong data.
1116          * So reset it to 0 before any memory is onlined.
1117          */
1118         reset_node_managed_pages(pgdat);
1119
1120         /*
1121          * When memory is hot-added, all the memory is in offline state. So
1122          * clear all zones' present_pages because they will be updated in
1123          * online_pages() and offline_pages().
1124          */
1125         reset_node_present_pages(pgdat);
1126
1127         return pgdat;
1128 }
1129
1130 static void rollback_node_hotadd(int nid, pg_data_t *pgdat)
1131 {
1132         arch_refresh_nodedata(nid, NULL);
1133         free_percpu(pgdat->per_cpu_nodestats);
1134         arch_free_nodedata(pgdat);
1135         return;
1136 }
1137
1138
1139 /**
1140  * try_online_node - online a node if offlined
1141  *
1142  * called by cpu_up() to online a node without onlined memory.
1143  */
1144 int try_online_node(int nid)
1145 {
1146         pg_data_t       *pgdat;
1147         int     ret;
1148
1149         if (node_online(nid))
1150                 return 0;
1151
1152         mem_hotplug_begin();
1153         pgdat = hotadd_new_pgdat(nid, 0);
1154         if (!pgdat) {
1155                 pr_err("Cannot online node %d due to NULL pgdat\n", nid);
1156                 ret = -ENOMEM;
1157                 goto out;
1158         }
1159         node_set_online(nid);
1160         ret = register_one_node(nid);
1161         BUG_ON(ret);
1162
1163         if (pgdat->node_zonelists->_zonerefs->zone == NULL) {
1164                 mutex_lock(&zonelists_mutex);
1165                 build_all_zonelists(NULL, NULL);
1166                 mutex_unlock(&zonelists_mutex);
1167         }
1168
1169 out:
1170         mem_hotplug_done();
1171         return ret;
1172 }
1173
1174 static int check_hotplug_memory_range(u64 start, u64 size)
1175 {
1176         u64 start_pfn = PFN_DOWN(start);
1177         u64 nr_pages = size >> PAGE_SHIFT;
1178
1179         /* Memory range must be aligned with section */
1180         if ((start_pfn & ~PAGE_SECTION_MASK) ||
1181             (nr_pages % PAGES_PER_SECTION) || (!nr_pages)) {
1182                 pr_err("Section-unaligned hotplug range: start 0x%llx, size 0x%llx\n",
1183                                 (unsigned long long)start,
1184                                 (unsigned long long)size);
1185                 return -EINVAL;
1186         }
1187
1188         return 0;
1189 }
1190
1191 static int online_memory_block(struct memory_block *mem, void *arg)
1192 {
1193         return device_online(&mem->dev);
1194 }
1195
1196 /* we are OK calling __meminit stuff here - we have CONFIG_MEMORY_HOTPLUG */
1197 int __ref add_memory_resource(int nid, struct resource *res, bool online)
1198 {
1199         u64 start, size;
1200         pg_data_t *pgdat = NULL;
1201         bool new_pgdat;
1202         bool new_node;
1203         int ret;
1204
1205         start = res->start;
1206         size = resource_size(res);
1207
1208         ret = check_hotplug_memory_range(start, size);
1209         if (ret)
1210                 return ret;
1211
1212         {       /* Stupid hack to suppress address-never-null warning */
1213                 void *p = NODE_DATA(nid);
1214                 new_pgdat = !p;
1215         }
1216
1217         mem_hotplug_begin();
1218
1219         /*
1220          * Add new range to memblock so that when hotadd_new_pgdat() is called
1221          * to allocate new pgdat, get_pfn_range_for_nid() will be able to find
1222          * this new range and calculate total pages correctly.  The range will
1223          * be removed at hot-remove time.
1224          */
1225         memblock_add_node(start, size, nid);
1226
1227         new_node = !node_online(nid);
1228         if (new_node) {
1229                 pgdat = hotadd_new_pgdat(nid, start);
1230                 ret = -ENOMEM;
1231                 if (!pgdat)
1232                         goto error;
1233         }
1234
1235         /* call arch's memory hotadd */
1236         ret = arch_add_memory(nid, start, size, true);
1237
1238         if (ret < 0)
1239                 goto error;
1240
1241         /* we online node here. we can't roll back from here. */
1242         node_set_online(nid);
1243
1244         if (new_node) {
1245                 unsigned long start_pfn = start >> PAGE_SHIFT;
1246                 unsigned long nr_pages = size >> PAGE_SHIFT;
1247
1248                 ret = __register_one_node(nid);
1249                 if (ret)
1250                         goto register_fail;
1251
1252                 /*
1253                  * link memory sections under this node. This is already
1254                  * done when creatig memory section in register_new_memory
1255                  * but that depends to have the node registered so offline
1256                  * nodes have to go through register_node.
1257                  * TODO clean up this mess.
1258                  */
1259                 ret = link_mem_sections(nid, start_pfn, nr_pages);
1260 register_fail:
1261                 /*
1262                  * If sysfs file of new node can't create, cpu on the node
1263                  * can't be hot-added. There is no rollback way now.
1264                  * So, check by BUG_ON() to catch it reluctantly..
1265                  */
1266                 BUG_ON(ret);
1267         }
1268
1269         /* create new memmap entry */
1270         firmware_map_add_hotplug(start, start + size, "System RAM");
1271
1272         /* online pages if requested */
1273         if (online)
1274                 walk_memory_range(PFN_DOWN(start), PFN_UP(start + size - 1),
1275                                   NULL, online_memory_block);
1276
1277         goto out;
1278
1279 error:
1280         /* rollback pgdat allocation and others */
1281         if (new_pgdat && pgdat)
1282                 rollback_node_hotadd(nid, pgdat);
1283         memblock_remove(start, size);
1284
1285 out:
1286         mem_hotplug_done();
1287         return ret;
1288 }
1289 EXPORT_SYMBOL_GPL(add_memory_resource);
1290
1291 int __ref add_memory(int nid, u64 start, u64 size)
1292 {
1293         struct resource *res;
1294         int ret;
1295
1296         res = register_memory_resource(start, size);
1297         if (IS_ERR(res))
1298                 return PTR_ERR(res);
1299
1300         ret = add_memory_resource(nid, res, memhp_auto_online);
1301         if (ret < 0)
1302                 release_memory_resource(res);
1303         return ret;
1304 }
1305 EXPORT_SYMBOL_GPL(add_memory);
1306
1307 #ifdef CONFIG_MEMORY_HOTREMOVE
1308 /*
1309  * A free page on the buddy free lists (not the per-cpu lists) has PageBuddy
1310  * set and the size of the free page is given by page_order(). Using this,
1311  * the function determines if the pageblock contains only free pages.
1312  * Due to buddy contraints, a free page at least the size of a pageblock will
1313  * be located at the start of the pageblock
1314  */
1315 static inline int pageblock_free(struct page *page)
1316 {
1317         return PageBuddy(page) && page_order(page) >= pageblock_order;
1318 }
1319
1320 /* Return the start of the next active pageblock after a given page */
1321 static struct page *next_active_pageblock(struct page *page)
1322 {
1323         /* Ensure the starting page is pageblock-aligned */
1324         BUG_ON(page_to_pfn(page) & (pageblock_nr_pages - 1));
1325
1326         /* If the entire pageblock is free, move to the end of free page */
1327         if (pageblock_free(page)) {
1328                 int order;
1329                 /* be careful. we don't have locks, page_order can be changed.*/
1330                 order = page_order(page);
1331                 if ((order < MAX_ORDER) && (order >= pageblock_order))
1332                         return page + (1 << order);
1333         }
1334
1335         return page + pageblock_nr_pages;
1336 }
1337
1338 /* Checks if this range of memory is likely to be hot-removable. */
1339 bool is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages)
1340 {
1341         struct page *page = pfn_to_page(start_pfn);
1342         struct page *end_page = page + nr_pages;
1343
1344         /* Check the starting page of each pageblock within the range */
1345         for (; page < end_page; page = next_active_pageblock(page)) {
1346                 if (!is_pageblock_removable_nolock(page))
1347                         return false;
1348                 cond_resched();
1349         }
1350
1351         /* All pageblocks in the memory block are likely to be hot-removable */
1352         return true;
1353 }
1354
1355 /*
1356  * Confirm all pages in a range [start, end) belong to the same zone.
1357  * When true, return its valid [start, end).
1358  */
1359 int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
1360                          unsigned long *valid_start, unsigned long *valid_end)
1361 {
1362         unsigned long pfn, sec_end_pfn;
1363         unsigned long start, end;
1364         struct zone *zone = NULL;
1365         struct page *page;
1366         int i;
1367         for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn + 1);
1368              pfn < end_pfn;
1369              pfn = sec_end_pfn, sec_end_pfn += PAGES_PER_SECTION) {
1370                 /* Make sure the memory section is present first */
1371                 if (!present_section_nr(pfn_to_section_nr(pfn)))
1372                         continue;
1373                 for (; pfn < sec_end_pfn && pfn < end_pfn;
1374                      pfn += MAX_ORDER_NR_PAGES) {
1375                         i = 0;
1376                         /* This is just a CONFIG_HOLES_IN_ZONE check.*/
1377                         while ((i < MAX_ORDER_NR_PAGES) &&
1378                                 !pfn_valid_within(pfn + i))
1379                                 i++;
1380                         if (i == MAX_ORDER_NR_PAGES || pfn + i >= end_pfn)
1381                                 continue;
1382                         page = pfn_to_page(pfn + i);
1383                         if (zone && page_zone(page) != zone)
1384                                 return 0;
1385                         if (!zone)
1386                                 start = pfn + i;
1387                         zone = page_zone(page);
1388                         end = pfn + MAX_ORDER_NR_PAGES;
1389                 }
1390         }
1391
1392         if (zone) {
1393                 *valid_start = start;
1394                 *valid_end = min(end, end_pfn);
1395                 return 1;
1396         } else {
1397                 return 0;
1398         }
1399 }
1400
1401 /*
1402  * Scan pfn range [start,end) to find movable/migratable pages (LRU pages,
1403  * non-lru movable pages and hugepages). We scan pfn because it's much
1404  * easier than scanning over linked list. This function returns the pfn
1405  * of the first found movable page if it's found, otherwise 0.
1406  */
1407 static unsigned long scan_movable_pages(unsigned long start, unsigned long end)
1408 {
1409         unsigned long pfn;
1410         struct page *page;
1411         for (pfn = start; pfn < end; pfn++) {
1412                 if (pfn_valid(pfn)) {
1413                         page = pfn_to_page(pfn);
1414                         if (PageLRU(page))
1415                                 return pfn;
1416                         if (__PageMovable(page))
1417                                 return pfn;
1418                         if (PageHuge(page)) {
1419                                 if (page_huge_active(page))
1420                                         return pfn;
1421                                 else
1422                                         pfn = round_up(pfn + 1,
1423                                                 1 << compound_order(page)) - 1;
1424                         }
1425                 }
1426         }
1427         return 0;
1428 }
1429
1430 static struct page *new_node_page(struct page *page, unsigned long private,
1431                 int **result)
1432 {
1433         int nid = page_to_nid(page);
1434         nodemask_t nmask = node_states[N_MEMORY];
1435
1436         /*
1437          * try to allocate from a different node but reuse this node if there
1438          * are no other online nodes to be used (e.g. we are offlining a part
1439          * of the only existing node)
1440          */
1441         node_clear(nid, nmask);
1442         if (nodes_empty(nmask))
1443                 node_set(nid, nmask);
1444
1445         return new_page_nodemask(page, nid, &nmask);
1446 }
1447
1448 #define NR_OFFLINE_AT_ONCE_PAGES        (256)
1449 static int
1450 do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
1451 {
1452         unsigned long pfn;
1453         struct page *page;
1454         int move_pages = NR_OFFLINE_AT_ONCE_PAGES;
1455         int not_managed = 0;
1456         int ret = 0;
1457         LIST_HEAD(source);
1458
1459         for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) {
1460                 if (!pfn_valid(pfn))
1461                         continue;
1462                 page = pfn_to_page(pfn);
1463
1464                 if (PageHuge(page)) {
1465                         struct page *head = compound_head(page);
1466                         pfn = page_to_pfn(head) + (1<<compound_order(head)) - 1;
1467                         if (compound_order(head) > PFN_SECTION_SHIFT) {
1468                                 ret = -EBUSY;
1469                                 break;
1470                         }
1471                         if (isolate_huge_page(page, &source))
1472                                 move_pages -= 1 << compound_order(head);
1473                         continue;
1474                 }
1475
1476                 if (!get_page_unless_zero(page))
1477                         continue;
1478                 /*
1479                  * We can skip free pages. And we can deal with pages on
1480                  * LRU and non-lru movable pages.
1481                  */
1482                 if (PageLRU(page))
1483                         ret = isolate_lru_page(page);
1484                 else
1485                         ret = isolate_movable_page(page, ISOLATE_UNEVICTABLE);
1486                 if (!ret) { /* Success */
1487                         put_page(page);
1488                         list_add_tail(&page->lru, &source);
1489                         move_pages--;
1490                         if (!__PageMovable(page))
1491                                 inc_node_page_state(page, NR_ISOLATED_ANON +
1492                                                     page_is_file_cache(page));
1493
1494                 } else {
1495 #ifdef CONFIG_DEBUG_VM
1496                         pr_alert("failed to isolate pfn %lx\n", pfn);
1497                         dump_page(page, "isolation failed");
1498 #endif
1499                         put_page(page);
1500                         /* Because we don't have big zone->lock. we should
1501                            check this again here. */
1502                         if (page_count(page)) {
1503                                 not_managed++;
1504                                 ret = -EBUSY;
1505                                 break;
1506                         }
1507                 }
1508         }
1509         if (!list_empty(&source)) {
1510                 if (not_managed) {
1511                         putback_movable_pages(&source);
1512                         goto out;
1513                 }
1514
1515                 /* Allocate a new page from the nearest neighbor node */
1516                 ret = migrate_pages(&source, new_node_page, NULL, 0,
1517                                         MIGRATE_SYNC, MR_MEMORY_HOTPLUG);
1518                 if (ret)
1519                         putback_movable_pages(&source);
1520         }
1521 out:
1522         return ret;
1523 }
1524
1525 /*
1526  * remove from free_area[] and mark all as Reserved.
1527  */
1528 static int
1529 offline_isolated_pages_cb(unsigned long start, unsigned long nr_pages,
1530                         void *data)
1531 {
1532         __offline_isolated_pages(start, start + nr_pages);
1533         return 0;
1534 }
1535
1536 static void
1537 offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
1538 {
1539         walk_system_ram_range(start_pfn, end_pfn - start_pfn, NULL,
1540                                 offline_isolated_pages_cb);
1541 }
1542
1543 /*
1544  * Check all pages in range, recoreded as memory resource, are isolated.
1545  */
1546 static int
1547 check_pages_isolated_cb(unsigned long start_pfn, unsigned long nr_pages,
1548                         void *data)
1549 {
1550         int ret;
1551         long offlined = *(long *)data;
1552         ret = test_pages_isolated(start_pfn, start_pfn + nr_pages, true);
1553         offlined = nr_pages;
1554         if (!ret)
1555                 *(long *)data += offlined;
1556         return ret;
1557 }
1558
1559 static long
1560 check_pages_isolated(unsigned long start_pfn, unsigned long end_pfn)
1561 {
1562         long offlined = 0;
1563         int ret;
1564
1565         ret = walk_system_ram_range(start_pfn, end_pfn - start_pfn, &offlined,
1566                         check_pages_isolated_cb);
1567         if (ret < 0)
1568                 offlined = (long)ret;
1569         return offlined;
1570 }
1571
1572 static int __init cmdline_parse_movable_node(char *p)
1573 {
1574 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
1575         movable_node_enabled = true;
1576 #else
1577         pr_warn("movable_node parameter depends on CONFIG_HAVE_MEMBLOCK_NODE_MAP to work properly\n");
1578 #endif
1579         return 0;
1580 }
1581 early_param("movable_node", cmdline_parse_movable_node);
1582
1583 /* check which state of node_states will be changed when offline memory */
1584 static void node_states_check_changes_offline(unsigned long nr_pages,
1585                 struct zone *zone, struct memory_notify *arg)
1586 {
1587         struct pglist_data *pgdat = zone->zone_pgdat;
1588         unsigned long present_pages = 0;
1589         enum zone_type zt, zone_last = ZONE_NORMAL;
1590
1591         /*
1592          * If we have HIGHMEM or movable node, node_states[N_NORMAL_MEMORY]
1593          * contains nodes which have zones of 0...ZONE_NORMAL,
1594          * set zone_last to ZONE_NORMAL.
1595          *
1596          * If we don't have HIGHMEM nor movable node,
1597          * node_states[N_NORMAL_MEMORY] contains nodes which have zones of
1598          * 0...ZONE_MOVABLE, set zone_last to ZONE_MOVABLE.
1599          */
1600         if (N_MEMORY == N_NORMAL_MEMORY)
1601                 zone_last = ZONE_MOVABLE;
1602
1603         /*
1604          * check whether node_states[N_NORMAL_MEMORY] will be changed.
1605          * If the memory to be offline is in a zone of 0...zone_last,
1606          * and it is the last present memory, 0...zone_last will
1607          * become empty after offline , thus we can determind we will
1608          * need to clear the node from node_states[N_NORMAL_MEMORY].
1609          */
1610         for (zt = 0; zt <= zone_last; zt++)
1611                 present_pages += pgdat->node_zones[zt].present_pages;
1612         if (zone_idx(zone) <= zone_last && nr_pages >= present_pages)
1613                 arg->status_change_nid_normal = zone_to_nid(zone);
1614         else
1615                 arg->status_change_nid_normal = -1;
1616
1617 #ifdef CONFIG_HIGHMEM
1618         /*
1619          * If we have movable node, node_states[N_HIGH_MEMORY]
1620          * contains nodes which have zones of 0...ZONE_HIGHMEM,
1621          * set zone_last to ZONE_HIGHMEM.
1622          *
1623          * If we don't have movable node, node_states[N_NORMAL_MEMORY]
1624          * contains nodes which have zones of 0...ZONE_MOVABLE,
1625          * set zone_last to ZONE_MOVABLE.
1626          */
1627         zone_last = ZONE_HIGHMEM;
1628         if (N_MEMORY == N_HIGH_MEMORY)
1629                 zone_last = ZONE_MOVABLE;
1630
1631         for (; zt <= zone_last; zt++)
1632                 present_pages += pgdat->node_zones[zt].present_pages;
1633         if (zone_idx(zone) <= zone_last && nr_pages >= present_pages)
1634                 arg->status_change_nid_high = zone_to_nid(zone);
1635         else
1636                 arg->status_change_nid_high = -1;
1637 #else
1638         arg->status_change_nid_high = arg->status_change_nid_normal;
1639 #endif
1640
1641         /*
1642          * node_states[N_HIGH_MEMORY] contains nodes which have 0...ZONE_MOVABLE
1643          */
1644         zone_last = ZONE_MOVABLE;
1645
1646         /*
1647          * check whether node_states[N_HIGH_MEMORY] will be changed
1648          * If we try to offline the last present @nr_pages from the node,
1649          * we can determind we will need to clear the node from
1650          * node_states[N_HIGH_MEMORY].
1651          */
1652         for (; zt <= zone_last; zt++)
1653                 present_pages += pgdat->node_zones[zt].present_pages;
1654         if (nr_pages >= present_pages)
1655                 arg->status_change_nid = zone_to_nid(zone);
1656         else
1657                 arg->status_change_nid = -1;
1658 }
1659
1660 static void node_states_clear_node(int node, struct memory_notify *arg)
1661 {
1662         if (arg->status_change_nid_normal >= 0)
1663                 node_clear_state(node, N_NORMAL_MEMORY);
1664
1665         if ((N_MEMORY != N_NORMAL_MEMORY) &&
1666             (arg->status_change_nid_high >= 0))
1667                 node_clear_state(node, N_HIGH_MEMORY);
1668
1669         if ((N_MEMORY != N_HIGH_MEMORY) &&
1670             (arg->status_change_nid >= 0))
1671                 node_clear_state(node, N_MEMORY);
1672 }
1673
1674 static int __ref __offline_pages(unsigned long start_pfn,
1675                   unsigned long end_pfn, unsigned long timeout)
1676 {
1677         unsigned long pfn, nr_pages, expire;
1678         long offlined_pages;
1679         int ret, drain, retry_max, node;
1680         unsigned long flags;
1681         unsigned long valid_start, valid_end;
1682         struct zone *zone;
1683         struct memory_notify arg;
1684
1685         /* at least, alignment against pageblock is necessary */
1686         if (!IS_ALIGNED(start_pfn, pageblock_nr_pages))
1687                 return -EINVAL;
1688         if (!IS_ALIGNED(end_pfn, pageblock_nr_pages))
1689                 return -EINVAL;
1690         /* This makes hotplug much easier...and readable.
1691            we assume this for now. .*/
1692         if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end))
1693                 return -EINVAL;
1694
1695         zone = page_zone(pfn_to_page(valid_start));
1696         node = zone_to_nid(zone);
1697         nr_pages = end_pfn - start_pfn;
1698
1699         /* set above range as isolated */
1700         ret = start_isolate_page_range(start_pfn, end_pfn,
1701                                        MIGRATE_MOVABLE, true);
1702         if (ret)
1703                 return ret;
1704
1705         arg.start_pfn = start_pfn;
1706         arg.nr_pages = nr_pages;
1707         node_states_check_changes_offline(nr_pages, zone, &arg);
1708
1709         ret = memory_notify(MEM_GOING_OFFLINE, &arg);
1710         ret = notifier_to_errno(ret);
1711         if (ret)
1712                 goto failed_removal;
1713
1714         pfn = start_pfn;
1715         expire = jiffies + timeout;
1716         drain = 0;
1717         retry_max = 5;
1718 repeat:
1719         /* start memory hot removal */
1720         ret = -EAGAIN;
1721         if (time_after(jiffies, expire))
1722                 goto failed_removal;
1723         ret = -EINTR;
1724         if (signal_pending(current))
1725                 goto failed_removal;
1726         ret = 0;
1727         if (drain) {
1728                 lru_add_drain_all();
1729                 cond_resched();
1730                 drain_all_pages(zone);
1731         }
1732
1733         pfn = scan_movable_pages(start_pfn, end_pfn);
1734         if (pfn) { /* We have movable pages */
1735                 ret = do_migrate_range(pfn, end_pfn);
1736                 if (!ret) {
1737                         drain = 1;
1738                         goto repeat;
1739                 } else {
1740                         if (ret < 0)
1741                                 if (--retry_max == 0)
1742                                         goto failed_removal;
1743                         yield();
1744                         drain = 1;
1745                         goto repeat;
1746                 }
1747         }
1748         /* drain all zone's lru pagevec, this is asynchronous... */
1749         lru_add_drain_all();
1750         yield();
1751         /* drain pcp pages, this is synchronous. */
1752         drain_all_pages(zone);
1753         /*
1754          * dissolve free hugepages in the memory block before doing offlining
1755          * actually in order to make hugetlbfs's object counting consistent.
1756          */
1757         ret = dissolve_free_huge_pages(start_pfn, end_pfn);
1758         if (ret)
1759                 goto failed_removal;
1760         /* check again */
1761         offlined_pages = check_pages_isolated(start_pfn, end_pfn);
1762         if (offlined_pages < 0) {
1763                 ret = -EBUSY;
1764                 goto failed_removal;
1765         }
1766         pr_info("Offlined Pages %ld\n", offlined_pages);
1767         /* Ok, all of our target is isolated.
1768            We cannot do rollback at this point. */
1769         offline_isolated_pages(start_pfn, end_pfn);
1770         /* reset pagetype flags and makes migrate type to be MOVABLE */
1771         undo_isolate_page_range(start_pfn, end_pfn, MIGRATE_MOVABLE);
1772         /* removal success */
1773         adjust_managed_page_count(pfn_to_page(start_pfn), -offlined_pages);
1774         zone->present_pages -= offlined_pages;
1775
1776         pgdat_resize_lock(zone->zone_pgdat, &flags);
1777         zone->zone_pgdat->node_present_pages -= offlined_pages;
1778         pgdat_resize_unlock(zone->zone_pgdat, &flags);
1779
1780         init_per_zone_wmark_min();
1781
1782         if (!populated_zone(zone)) {
1783                 zone_pcp_reset(zone);
1784                 mutex_lock(&zonelists_mutex);
1785                 build_all_zonelists(NULL, NULL);
1786                 mutex_unlock(&zonelists_mutex);
1787         } else
1788                 zone_pcp_update(zone);
1789
1790         node_states_clear_node(node, &arg);
1791         if (arg.status_change_nid >= 0) {
1792                 kswapd_stop(node);
1793                 kcompactd_stop(node);
1794         }
1795
1796         vm_total_pages = nr_free_pagecache_pages();
1797         writeback_set_ratelimit();
1798
1799         memory_notify(MEM_OFFLINE, &arg);
1800         return 0;
1801
1802 failed_removal:
1803         pr_debug("memory offlining [mem %#010llx-%#010llx] failed\n",
1804                  (unsigned long long) start_pfn << PAGE_SHIFT,
1805                  ((unsigned long long) end_pfn << PAGE_SHIFT) - 1);
1806         memory_notify(MEM_CANCEL_OFFLINE, &arg);
1807         /* pushback to free area */
1808         undo_isolate_page_range(start_pfn, end_pfn, MIGRATE_MOVABLE);
1809         return ret;
1810 }
1811
1812 /* Must be protected by mem_hotplug_begin() */
1813 int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
1814 {
1815         return __offline_pages(start_pfn, start_pfn + nr_pages, 120 * HZ);
1816 }
1817 #endif /* CONFIG_MEMORY_HOTREMOVE */
1818
1819 /**
1820  * walk_memory_range - walks through all mem sections in [start_pfn, end_pfn)
1821  * @start_pfn: start pfn of the memory range
1822  * @end_pfn: end pfn of the memory range
1823  * @arg: argument passed to func
1824  * @func: callback for each memory section walked
1825  *
1826  * This function walks through all present mem sections in range
1827  * [start_pfn, end_pfn) and call func on each mem section.
1828  *
1829  * Returns the return value of func.
1830  */
1831 int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
1832                 void *arg, int (*func)(struct memory_block *, void *))
1833 {
1834         struct memory_block *mem = NULL;
1835         struct mem_section *section;
1836         unsigned long pfn, section_nr;
1837         int ret;
1838
1839         for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
1840                 section_nr = pfn_to_section_nr(pfn);
1841                 if (!present_section_nr(section_nr))
1842                         continue;
1843
1844                 section = __nr_to_section(section_nr);
1845                 /* same memblock? */
1846                 if (mem)
1847                         if ((section_nr >= mem->start_section_nr) &&
1848                             (section_nr <= mem->end_section_nr))
1849                                 continue;
1850
1851                 mem = find_memory_block_hinted(section, mem);
1852                 if (!mem)
1853                         continue;
1854
1855                 ret = func(mem, arg);
1856                 if (ret) {
1857                         kobject_put(&mem->dev.kobj);
1858                         return ret;
1859                 }
1860         }
1861
1862         if (mem)
1863                 kobject_put(&mem->dev.kobj);
1864
1865         return 0;
1866 }
1867
1868 #ifdef CONFIG_MEMORY_HOTREMOVE
1869 static int check_memblock_offlined_cb(struct memory_block *mem, void *arg)
1870 {
1871         int ret = !is_memblock_offlined(mem);
1872
1873         if (unlikely(ret)) {
1874                 phys_addr_t beginpa, endpa;
1875
1876                 beginpa = PFN_PHYS(section_nr_to_pfn(mem->start_section_nr));
1877                 endpa = PFN_PHYS(section_nr_to_pfn(mem->end_section_nr + 1))-1;
1878                 pr_warn("removing memory fails, because memory [%pa-%pa] is onlined\n",
1879                         &beginpa, &endpa);
1880         }
1881
1882         return ret;
1883 }
1884
1885 static int check_cpu_on_node(pg_data_t *pgdat)
1886 {
1887         int cpu;
1888
1889         for_each_present_cpu(cpu) {
1890                 if (cpu_to_node(cpu) == pgdat->node_id)
1891                         /*
1892                          * the cpu on this node isn't removed, and we can't
1893                          * offline this node.
1894                          */
1895                         return -EBUSY;
1896         }
1897
1898         return 0;
1899 }
1900
1901 static void unmap_cpu_on_node(pg_data_t *pgdat)
1902 {
1903 #ifdef CONFIG_ACPI_NUMA
1904         int cpu;
1905
1906         for_each_possible_cpu(cpu)
1907                 if (cpu_to_node(cpu) == pgdat->node_id)
1908                         numa_clear_node(cpu);
1909 #endif
1910 }
1911
1912 static int check_and_unmap_cpu_on_node(pg_data_t *pgdat)
1913 {
1914         int ret;
1915
1916         ret = check_cpu_on_node(pgdat);
1917         if (ret)
1918                 return ret;
1919
1920         /*
1921          * the node will be offlined when we come here, so we can clear
1922          * the cpu_to_node() now.
1923          */
1924
1925         unmap_cpu_on_node(pgdat);
1926         return 0;
1927 }
1928
1929 /**
1930  * try_offline_node
1931  *
1932  * Offline a node if all memory sections and cpus of the node are removed.
1933  *
1934  * NOTE: The caller must call lock_device_hotplug() to serialize hotplug
1935  * and online/offline operations before this call.
1936  */
1937 void try_offline_node(int nid)
1938 {
1939         pg_data_t *pgdat = NODE_DATA(nid);
1940         unsigned long start_pfn = pgdat->node_start_pfn;
1941         unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
1942         unsigned long pfn;
1943
1944         for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
1945                 unsigned long section_nr = pfn_to_section_nr(pfn);
1946
1947                 if (!present_section_nr(section_nr))
1948                         continue;
1949
1950                 if (pfn_to_nid(pfn) != nid)
1951                         continue;
1952
1953                 /*
1954                  * some memory sections of this node are not removed, and we
1955                  * can't offline node now.
1956                  */
1957                 return;
1958         }
1959
1960         if (check_and_unmap_cpu_on_node(pgdat))
1961                 return;
1962
1963         /*
1964          * all memory/cpu of this node are removed, we can offline this
1965          * node now.
1966          */
1967         node_set_offline(nid);
1968         unregister_one_node(nid);
1969 }
1970 EXPORT_SYMBOL(try_offline_node);
1971
1972 /**
1973  * remove_memory
1974  *
1975  * NOTE: The caller must call lock_device_hotplug() to serialize hotplug
1976  * and online/offline operations before this call, as required by
1977  * try_offline_node().
1978  */
1979 void __ref remove_memory(int nid, u64 start, u64 size)
1980 {
1981         int ret;
1982
1983         BUG_ON(check_hotplug_memory_range(start, size));
1984
1985         mem_hotplug_begin();
1986
1987         /*
1988          * All memory blocks must be offlined before removing memory.  Check
1989          * whether all memory blocks in question are offline and trigger a BUG()
1990          * if this is not the case.
1991          */
1992         ret = walk_memory_range(PFN_DOWN(start), PFN_UP(start + size - 1), NULL,
1993                                 check_memblock_offlined_cb);
1994         if (ret)
1995                 BUG();
1996
1997         /* remove memmap entry */
1998         firmware_map_remove(start, start + size, "System RAM");
1999         memblock_free(start, size);
2000         memblock_remove(start, size);
2001
2002         arch_remove_memory(start, size);
2003
2004         try_offline_node(nid);
2005
2006         mem_hotplug_done();
2007 }
2008 EXPORT_SYMBOL_GPL(remove_memory);
2009 #endif /* CONFIG_MEMORY_HOTREMOVE */