SAFE public projects git trees. - safe/jmp/linux-2.6/blob - mm/bootmem.c

   1 /*
   2  *  bootmem - A boot-time physical memory allocator and configurator
   3  *
   4  *  Copyright (C) 1999 Ingo Molnar
   5  *                1999 Kanoj Sarcar, SGI
   6  *                2008 Johannes Weiner
   7  *
   8  * Access to this subsystem has to be serialized externally (which is true
   9  * for the boot process anyway).
  10  */
  11 #include <linux/init.h>
  12 #include <linux/pfn.h>
  13 #include <linux/bootmem.h>
  14 #include <linux/module.h>
  15
  16 #include <asm/bug.h>
  17 #include <asm/io.h>
  18 #include <asm/processor.h>
  19
  20 #include "internal.h"
  21
  22 unsigned long max_low_pfn;
  23 unsigned long min_low_pfn;
  24 unsigned long max_pfn;
  25
  26 #ifdef CONFIG_CRASH_DUMP
  27 /*
  28  * If we have booted due to a crash, max_pfn will be a very low value. We need
  29  * to know the amount of memory that the previous kernel used.
  30  */
  31 unsigned long saved_max_pfn;
  32 #endif
  33
  34 bootmem_data_t bootmem_node_data[MAX_NUMNODES] __initdata;
  35
  36 static struct list_head bdata_list __initdata = LIST_HEAD_INIT(bdata_list);
  37
  38 static int bootmem_debug;
  39
  40 static int __init bootmem_debug_setup(char *buf)
  41 {
  42         bootmem_debug = 1;
  43         return 0;
  44 }
  45 early_param("bootmem_debug", bootmem_debug_setup);
  46
  47 #define bdebug(fmt, args...) ({                         \
  48         if (unlikely(bootmem_debug))                    \
  49                 printk(KERN_INFO                        \
  50                         "bootmem::%s " fmt,             \
  51                         __FUNCTION__, ## args);         \
  52 })
  53
  54 static unsigned long __init bootmap_bytes(unsigned long pages)
  55 {
  56         unsigned long bytes = (pages + 7) / 8;
  57
  58         return ALIGN(bytes, sizeof(long));
  59 }
  60
  61 /**
  62  * bootmem_bootmap_pages - calculate bitmap size in pages
  63  * @pages: number of pages the bitmap has to represent
  64  */
  65 unsigned long __init bootmem_bootmap_pages(unsigned long pages)
  66 {
  67         unsigned long bytes = bootmap_bytes(pages);
  68
  69         return PAGE_ALIGN(bytes) >> PAGE_SHIFT;
  70 }
  71
  72 /*
  73  * link bdata in order
  74  */
  75 static void __init link_bootmem(bootmem_data_t *bdata)
  76 {
  77         struct list_head *iter;
  78
  79         list_for_each(iter, &bdata_list) {
  80                 bootmem_data_t *ent;
  81
  82                 ent = list_entry(iter, bootmem_data_t, list);
  83                 if (bdata->node_boot_start < ent->node_boot_start)
  84                         break;
  85         }
  86         list_add_tail(&bdata->list, iter);
  87 }
  88
  89 /*
  90  * Called once to set up the allocator itself.
  91  */
  92 static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
  93         unsigned long mapstart, unsigned long start, unsigned long end)
  94 {
  95         unsigned long mapsize;
  96
  97         mminit_validate_memmodel_limits(&start, &end);
  98         bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
  99         bdata->node_boot_start = PFN_PHYS(start);
 100         bdata->node_low_pfn = end;
 101         link_bootmem(bdata);
 102
 103         /*
 104          * Initially all pages are reserved - setup_arch() has to
 105          * register free RAM areas explicitly.
 106          */
 107         mapsize = bootmap_bytes(end - start);
 108         memset(bdata->node_bootmem_map, 0xff, mapsize);
 109
 110         bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",
 111                 bdata - bootmem_node_data, start, mapstart, end, mapsize);
 112
 113         return mapsize;
 114 }
 115
 116 /**
 117  * init_bootmem_node - register a node as boot memory
 118  * @pgdat: node to register
 119  * @freepfn: pfn where the bitmap for this node is to be placed
 120  * @startpfn: first pfn on the node
 121  * @endpfn: first pfn after the node
 122  *
 123  * Returns the number of bytes needed to hold the bitmap for this node.
 124  */
 125 unsigned long __init init_bootmem_node(pg_data_t *pgdat, unsigned long freepfn,
 126                                 unsigned long startpfn, unsigned long endpfn)
 127 {
 128         return init_bootmem_core(pgdat->bdata, freepfn, startpfn, endpfn);
 129 }
 130
 131 /**
 132  * init_bootmem - register boot memory
 133  * @start: pfn where the bitmap is to be placed
 134  * @pages: number of available physical pages
 135  *
 136  * Returns the number of bytes needed to hold the bitmap.
 137  */
 138 unsigned long __init init_bootmem(unsigned long start, unsigned long pages)
 139 {
 140         max_low_pfn = pages;
 141         min_low_pfn = start;
 142         return init_bootmem_core(NODE_DATA(0)->bdata, start, 0, pages);
 143 }
 144
 145 static unsigned long __init free_all_bootmem_core(bootmem_data_t *bdata)
 146 {
 147         struct page *page;
 148         unsigned long pfn;
 149         unsigned long i, count;
 150         unsigned long idx, pages;
 151         unsigned long *map;
 152         int gofast = 0;
 153
 154         BUG_ON(!bdata->node_bootmem_map);
 155
 156         count = 0;
 157         /* first extant page of the node */
 158         pfn = PFN_DOWN(bdata->node_boot_start);
 159         idx = bdata->node_low_pfn - pfn;
 160         map = bdata->node_bootmem_map;
 161         /*
 162          * Check if we are aligned to BITS_PER_LONG pages.  If so, we might
 163          * be able to free page orders of that size at once.
 164          */
 165         if (!(pfn & (BITS_PER_LONG-1)))
 166                 gofast = 1;
 167
 168         for (i = 0; i < idx; ) {
 169                 unsigned long v = ~map[i / BITS_PER_LONG];
 170
 171                 if (gofast && v == ~0UL) {
 172                         int order;
 173
 174                         page = pfn_to_page(pfn);
 175                         count += BITS_PER_LONG;
 176                         order = ffs(BITS_PER_LONG) - 1;
 177                         __free_pages_bootmem(page, order);
 178                         i += BITS_PER_LONG;
 179                         page += BITS_PER_LONG;
 180                 } else if (v) {
 181                         unsigned long m;
 182
 183                         page = pfn_to_page(pfn);
 184                         for (m = 1; m && i < idx; m<<=1, page++, i++) {
 185                                 if (v & m) {
 186                                         count++;
 187                                         __free_pages_bootmem(page, 0);
 188                                 }
 189                         }
 190                 } else {
 191                         i += BITS_PER_LONG;
 192                 }
 193                 pfn += BITS_PER_LONG;
 194         }
 195
 196         /*
 197          * Now free the allocator bitmap itself, it's not
 198          * needed anymore:
 199          */
 200         page = virt_to_page(bdata->node_bootmem_map);
 201         pages = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 202         idx = bootmem_bootmap_pages(pages);
 203         for (i = 0; i < idx; i++, page++)
 204                 __free_pages_bootmem(page, 0);
 205         count += i;
 206         bdata->node_bootmem_map = NULL;
 207
 208         bdebug("nid=%td released=%lx\n", bdata - bootmem_node_data, count);
 209
 210         return count;
 211 }
 212
 213 /**
 214  * free_all_bootmem_node - release a node's free pages to the buddy allocator
 215  * @pgdat: node to be released
 216  *
 217  * Returns the number of pages actually released.
 218  */
 219 unsigned long __init free_all_bootmem_node(pg_data_t *pgdat)
 220 {
 221         register_page_bootmem_info_node(pgdat);
 222         return free_all_bootmem_core(pgdat->bdata);
 223 }
 224
 225 /**
 226  * free_all_bootmem - release free pages to the buddy allocator
 227  *
 228  * Returns the number of pages actually released.
 229  */
 230 unsigned long __init free_all_bootmem(void)
 231 {
 232         return free_all_bootmem_core(NODE_DATA(0)->bdata);
 233 }
 234
 235 static void __init free_bootmem_core(bootmem_data_t *bdata, unsigned long addr,
 236                                      unsigned long size)
 237 {
 238         unsigned long sidx, eidx;
 239         unsigned long i;
 240
 241         BUG_ON(!size);
 242
 243         /* out range */
 244         if (addr + size < bdata->node_boot_start ||
 245                 PFN_DOWN(addr) > bdata->node_low_pfn)
 246                 return;
 247         /*
 248          * round down end of usable mem, partially free pages are
 249          * considered reserved.
 250          */
 251
 252         if (addr >= bdata->node_boot_start && addr < bdata->last_success)
 253                 bdata->last_success = addr;
 254
 255         /*
 256          * Round up to index to the range.
 257          */
 258         if (PFN_UP(addr) > PFN_DOWN(bdata->node_boot_start))
 259                 sidx = PFN_UP(addr) - PFN_DOWN(bdata->node_boot_start);
 260         else
 261                 sidx = 0;
 262
 263         eidx = PFN_DOWN(addr + size - bdata->node_boot_start);
 264         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 265                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 266
 267         bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,
 268                 sidx + PFN_DOWN(bdata->node_boot_start),
 269                 eidx + PFN_DOWN(bdata->node_boot_start));
 270
 271         for (i = sidx; i < eidx; i++) {
 272                 if (unlikely(!test_and_clear_bit(i, bdata->node_bootmem_map)))
 273                         BUG();
 274         }
 275 }
 276
 277 /**
 278  * free_bootmem_node - mark a page range as usable
 279  * @pgdat: node the range resides on
 280  * @physaddr: starting address of the range
 281  * @size: size of the range in bytes
 282  *
 283  * Partial pages will be considered reserved and left as they are.
 284  *
 285  * Only physical pages that actually reside on @pgdat are marked.
 286  */
 287 void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
 288                               unsigned long size)
 289 {
 290         free_bootmem_core(pgdat->bdata, physaddr, size);
 291 }
 292
 293 /**
 294  * free_bootmem - mark a page range as usable
 295  * @addr: starting address of the range
 296  * @size: size of the range in bytes
 297  *
 298  * Partial pages will be considered reserved and left as they are.
 299  *
 300  * All physical pages within the range are marked, no matter what
 301  * node they reside on.
 302  */
 303 void __init free_bootmem(unsigned long addr, unsigned long size)
 304 {
 305         bootmem_data_t *bdata;
 306         list_for_each_entry(bdata, &bdata_list, list)
 307                 free_bootmem_core(bdata, addr, size);
 308 }
 309
 310 /*
 311  * Marks a particular physical memory range as unallocatable. Usable RAM
 312  * might be used for boot-time allocations - or it might get added
 313  * to the free page pool later on.
 314  */
 315 static int __init can_reserve_bootmem_core(bootmem_data_t *bdata,
 316                         unsigned long addr, unsigned long size, int flags)
 317 {
 318         unsigned long sidx, eidx;
 319         unsigned long i;
 320
 321         BUG_ON(!size);
 322
 323         /* out of range, don't hold other */
 324         if (addr + size < bdata->node_boot_start ||
 325                 PFN_DOWN(addr) > bdata->node_low_pfn)
 326                 return 0;
 327
 328         /*
 329          * Round up to index to the range.
 330          */
 331         if (addr > bdata->node_boot_start)
 332                 sidx= PFN_DOWN(addr - bdata->node_boot_start);
 333         else
 334                 sidx = 0;
 335
 336         eidx = PFN_UP(addr + size - bdata->node_boot_start);
 337         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 338                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 339
 340         for (i = sidx; i < eidx; i++) {
 341                 if (test_bit(i, bdata->node_bootmem_map)) {
 342                         if (flags & BOOTMEM_EXCLUSIVE)
 343                                 return -EBUSY;
 344                 }
 345         }
 346
 347         return 0;
 348
 349 }
 350
 351 static void __init reserve_bootmem_core(bootmem_data_t *bdata,
 352                         unsigned long addr, unsigned long size, int flags)
 353 {
 354         unsigned long sidx, eidx;
 355         unsigned long i;
 356
 357         BUG_ON(!size);
 358
 359         /* out of range */
 360         if (addr + size < bdata->node_boot_start ||
 361                 PFN_DOWN(addr) > bdata->node_low_pfn)
 362                 return;
 363
 364         /*
 365          * Round up to index to the range.
 366          */
 367         if (addr > bdata->node_boot_start)
 368                 sidx= PFN_DOWN(addr - bdata->node_boot_start);
 369         else
 370                 sidx = 0;
 371
 372         eidx = PFN_UP(addr + size - bdata->node_boot_start);
 373         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 374                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 375
 376         bdebug("nid=%td start=%lx end=%lx flags=%x\n",
 377                 bdata - bootmem_node_data,
 378                 sidx + PFN_DOWN(bdata->node_boot_start),
 379                 eidx + PFN_DOWN(bdata->node_boot_start),
 380                 flags);
 381
 382         for (i = sidx; i < eidx; i++)
 383                 if (test_and_set_bit(i, bdata->node_bootmem_map))
 384                         bdebug("hm, page %lx reserved twice.\n",
 385                                 PFN_DOWN(bdata->node_boot_start) + i);
 386 }
 387
 388 /**
 389  * reserve_bootmem_node - mark a page range as reserved
 390  * @pgdat: node the range resides on
 391  * @physaddr: starting address of the range
 392  * @size: size of the range in bytes
 393  * @flags: reservation flags (see linux/bootmem.h)
 394  *
 395  * Partial pages will be reserved.
 396  *
 397  * Only physical pages that actually reside on @pgdat are marked.
 398  */
 399 int __init reserve_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
 400                                  unsigned long size, int flags)
 401 {
 402         int ret;
 403
 404         ret = can_reserve_bootmem_core(pgdat->bdata, physaddr, size, flags);
 405         if (ret < 0)
 406                 return -ENOMEM;
 407         reserve_bootmem_core(pgdat->bdata, physaddr, size, flags);
 408         return 0;
 409 }
 410
 411 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 412 /**
 413  * reserve_bootmem - mark a page range as usable
 414  * @addr: starting address of the range
 415  * @size: size of the range in bytes
 416  * @flags: reservation flags (see linux/bootmem.h)
 417  *
 418  * Partial pages will be reserved.
 419  *
 420  * All physical pages within the range are marked, no matter what
 421  * node they reside on.
 422  */
 423 int __init reserve_bootmem(unsigned long addr, unsigned long size,
 424                             int flags)
 425 {
 426         bootmem_data_t *bdata;
 427         int ret;
 428
 429         list_for_each_entry(bdata, &bdata_list, list) {
 430                 ret = can_reserve_bootmem_core(bdata, addr, size, flags);
 431                 if (ret < 0)
 432                         return ret;
 433         }
 434         list_for_each_entry(bdata, &bdata_list, list)
 435                 reserve_bootmem_core(bdata, addr, size, flags);
 436
 437         return 0;
 438 }
 439 #endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
 440
 441 /*
 442  * We 'merge' subsequent allocations to save space. We might 'lose'
 443  * some fraction of a page if allocations cannot be satisfied due to
 444  * size constraints on boxes where there is physical RAM space
 445  * fragmentation - in these cases (mostly large memory boxes) this
 446  * is not a problem.
 447  *
 448  * On low memory boxes we get it right in 100% of the cases.
 449  *
 450  * alignment has to be a power of 2 value.
 451  *
 452  * NOTE:  This function is _not_ reentrant.
 453  */
 454 static void * __init
 455 alloc_bootmem_core(struct bootmem_data *bdata, unsigned long size,
 456                 unsigned long align, unsigned long goal, unsigned long limit)
 457 {
 458         unsigned long areasize, preferred;
 459         unsigned long i, start = 0, incr, eidx, end_pfn;
 460         void *ret;
 461         unsigned long node_boot_start;
 462         void *node_bootmem_map;
 463
 464         if (!size) {
 465                 printk("alloc_bootmem_core(): zero-sized request\n");
 466                 BUG();
 467         }
 468         BUG_ON(align & (align-1));
 469
 470         /* on nodes without memory - bootmem_map is NULL */
 471         if (!bdata->node_bootmem_map)
 472                 return NULL;
 473
 474         bdebug("nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n",
 475                 bdata - bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,
 476                 align, goal, limit);
 477
 478         /* bdata->node_boot_start is supposed to be (12+6)bits alignment on x86_64 ? */
 479         node_boot_start = bdata->node_boot_start;
 480         node_bootmem_map = bdata->node_bootmem_map;
 481         if (align) {
 482                 node_boot_start = ALIGN(bdata->node_boot_start, align);
 483                 if (node_boot_start > bdata->node_boot_start)
 484                         node_bootmem_map = (unsigned long *)bdata->node_bootmem_map +
 485                             PFN_DOWN(node_boot_start - bdata->node_boot_start)/BITS_PER_LONG;
 486         }
 487
 488         if (limit && node_boot_start >= limit)
 489                 return NULL;
 490
 491         end_pfn = bdata->node_low_pfn;
 492         limit = PFN_DOWN(limit);
 493         if (limit && end_pfn > limit)
 494                 end_pfn = limit;
 495
 496         eidx = end_pfn - PFN_DOWN(node_boot_start);
 497
 498         /*
 499          * We try to allocate bootmem pages above 'goal'
 500          * first, then we try to allocate lower pages.
 501          */
 502         preferred = 0;
 503         if (goal && PFN_DOWN(goal) < end_pfn) {
 504                 if (goal > node_boot_start)
 505                         preferred = goal - node_boot_start;
 506
 507                 if (bdata->last_success > node_boot_start &&
 508                         bdata->last_success - node_boot_start >= preferred)
 509                         if (!limit || (limit && limit > bdata->last_success))
 510                                 preferred = bdata->last_success - node_boot_start;
 511         }
 512
 513         preferred = PFN_DOWN(ALIGN(preferred, align));
 514         areasize = (size + PAGE_SIZE-1) / PAGE_SIZE;
 515         incr = align >> PAGE_SHIFT ? : 1;
 516
 517 restart_scan:
 518         for (i = preferred; i < eidx;) {
 519                 unsigned long j;
 520
 521                 i = find_next_zero_bit(node_bootmem_map, eidx, i);
 522                 i = ALIGN(i, incr);
 523                 if (i >= eidx)
 524                         break;
 525                 if (test_bit(i, node_bootmem_map)) {
 526                         i += incr;
 527                         continue;
 528                 }
 529                 for (j = i + 1; j < i + areasize; ++j) {
 530                         if (j >= eidx)
 531                                 goto fail_block;
 532                         if (test_bit(j, node_bootmem_map))
 533                                 goto fail_block;
 534                 }
 535                 start = i;
 536                 goto found;
 537         fail_block:
 538                 i = ALIGN(j, incr);
 539                 if (i == j)
 540                         i += incr;
 541         }
 542
 543         if (preferred > 0) {
 544                 preferred = 0;
 545                 goto restart_scan;
 546         }
 547         return NULL;
 548
 549 found:
 550         bdata->last_success = PFN_PHYS(start) + node_boot_start;
 551         BUG_ON(start >= eidx);
 552
 553         /*
 554          * Is the next page of the previous allocation-end the start
 555          * of this allocation's buffer? If yes then we can 'merge'
 556          * the previous partial page with this allocation.
 557          */
 558         if (align < PAGE_SIZE &&
 559             bdata->last_offset && bdata->last_pos+1 == start) {
 560                 unsigned long offset, remaining_size;
 561                 offset = ALIGN(bdata->last_offset, align);
 562                 BUG_ON(offset > PAGE_SIZE);
 563                 remaining_size = PAGE_SIZE - offset;
 564                 if (size < remaining_size) {
 565                         areasize = 0;
 566                         /* last_pos unchanged */
 567                         bdata->last_offset = offset + size;
 568                         ret = phys_to_virt(bdata->last_pos * PAGE_SIZE +
 569                                            offset + node_boot_start);
 570                 } else {
 571                         remaining_size = size - remaining_size;
 572                         areasize = (remaining_size + PAGE_SIZE-1) / PAGE_SIZE;
 573                         ret = phys_to_virt(bdata->last_pos * PAGE_SIZE +
 574                                            offset + node_boot_start);
 575                         bdata->last_pos = start + areasize - 1;
 576                         bdata->last_offset = remaining_size;
 577                 }
 578                 bdata->last_offset &= ~PAGE_MASK;
 579         } else {
 580                 bdata->last_pos = start + areasize - 1;
 581                 bdata->last_offset = size & ~PAGE_MASK;
 582                 ret = phys_to_virt(start * PAGE_SIZE + node_boot_start);
 583         }
 584
 585         bdebug("nid=%td start=%lx end=%lx\n",
 586                 bdata - bootmem_node_data,
 587                 start + PFN_DOWN(bdata->node_boot_start),
 588                 start + areasize + PFN_DOWN(bdata->node_boot_start));
 589
 590         /*
 591          * Reserve the area now:
 592          */
 593         for (i = start; i < start + areasize; i++)
 594                 if (unlikely(test_and_set_bit(i, node_bootmem_map)))
 595                         BUG();
 596         memset(ret, 0, size);
 597         return ret;
 598 }
 599
 600 /**
 601  * __alloc_bootmem_nopanic - allocate boot memory without panicking
 602  * @size: size of the request in bytes
 603  * @align: alignment of the region
 604  * @goal: preferred starting address of the region
 605  *
 606  * The goal is dropped if it can not be satisfied and the allocation will
 607  * fall back to memory below @goal.
 608  *
 609  * Allocation may happen on any node in the system.
 610  *
 611  * Returns NULL on failure.
 612  */
 613 void * __init __alloc_bootmem_nopanic(unsigned long size, unsigned long align,
 614                                       unsigned long goal)
 615 {
 616         bootmem_data_t *bdata;
 617         void *ptr;
 618
 619         list_for_each_entry(bdata, &bdata_list, list) {
 620                 ptr = alloc_bootmem_core(bdata, size, align, goal, 0);
 621                 if (ptr)
 622                         return ptr;
 623         }
 624         return NULL;
 625 }
 626
 627 /**
 628  * __alloc_bootmem - allocate boot memory
 629  * @size: size of the request in bytes
 630  * @align: alignment of the region
 631  * @goal: preferred starting address of the region
 632  *
 633  * The goal is dropped if it can not be satisfied and the allocation will
 634  * fall back to memory below @goal.
 635  *
 636  * Allocation may happen on any node in the system.
 637  *
 638  * The function panics if the request can not be satisfied.
 639  */
 640 void * __init __alloc_bootmem(unsigned long size, unsigned long align,
 641                               unsigned long goal)
 642 {
 643         void *mem = __alloc_bootmem_nopanic(size,align,goal);
 644
 645         if (mem)
 646                 return mem;
 647         /*
 648          * Whoops, we cannot satisfy the allocation request.
 649          */
 650         printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size);
 651         panic("Out of memory");
 652         return NULL;
 653 }
 654
 655 /**
 656  * __alloc_bootmem_node - allocate boot memory from a specific node
 657  * @pgdat: node to allocate from
 658  * @size: size of the request in bytes
 659  * @align: alignment of the region
 660  * @goal: preferred starting address of the region
 661  *
 662  * The goal is dropped if it can not be satisfied and the allocation will
 663  * fall back to memory below @goal.
 664  *
 665  * Allocation may fall back to any node in the system if the specified node
 666  * can not hold the requested memory.
 667  *
 668  * The function panics if the request can not be satisfied.
 669  */
 670 void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
 671                                    unsigned long align, unsigned long goal)
 672 {
 673         void *ptr;
 674
 675         ptr = alloc_bootmem_core(pgdat->bdata, size, align, goal, 0);
 676         if (ptr)
 677                 return ptr;
 678
 679         return __alloc_bootmem(size, align, goal);
 680 }
 681
 682 #ifdef CONFIG_SPARSEMEM
 683 /**
 684  * alloc_bootmem_section - allocate boot memory from a specific section
 685  * @size: size of the request in bytes
 686  * @section_nr: sparse map section to allocate from
 687  *
 688  * Return NULL on failure.
 689  */
 690 void * __init alloc_bootmem_section(unsigned long size,
 691                                     unsigned long section_nr)
 692 {
 693         void *ptr;
 694         unsigned long limit, goal, start_nr, end_nr, pfn;
 695         struct pglist_data *pgdat;
 696
 697         pfn = section_nr_to_pfn(section_nr);
 698         goal = PFN_PHYS(pfn);
 699         limit = PFN_PHYS(section_nr_to_pfn(section_nr + 1)) - 1;
 700         pgdat = NODE_DATA(early_pfn_to_nid(pfn));
 701         ptr = alloc_bootmem_core(pgdat->bdata, size, SMP_CACHE_BYTES, goal,
 702                                 limit);
 703
 704         if (!ptr)
 705                 return NULL;
 706
 707         start_nr = pfn_to_section_nr(PFN_DOWN(__pa(ptr)));
 708         end_nr = pfn_to_section_nr(PFN_DOWN(__pa(ptr) + size));
 709         if (start_nr != section_nr || end_nr != section_nr) {
 710                 printk(KERN_WARNING "alloc_bootmem failed on section %ld.\n",
 711                        section_nr);
 712                 free_bootmem_core(pgdat->bdata, __pa(ptr), size);
 713                 ptr = NULL;
 714         }
 715
 716         return ptr;
 717 }
 718 #endif
 719
 720 void * __init __alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size,
 721                                    unsigned long align, unsigned long goal)
 722 {
 723         void *ptr;
 724
 725         ptr = alloc_bootmem_core(pgdat->bdata, size, align, goal, 0);
 726         if (ptr)
 727                 return ptr;
 728
 729         return __alloc_bootmem_nopanic(size, align, goal);
 730 }
 731
 732 #ifndef ARCH_LOW_ADDRESS_LIMIT
 733 #define ARCH_LOW_ADDRESS_LIMIT  0xffffffffUL
 734 #endif
 735
 736 /**
 737  * __alloc_bootmem_low - allocate low boot memory
 738  * @size: size of the request in bytes
 739  * @align: alignment of the region
 740  * @goal: preferred starting address of the region
 741  *
 742  * The goal is dropped if it can not be satisfied and the allocation will
 743  * fall back to memory below @goal.
 744  *
 745  * Allocation may happen on any node in the system.
 746  *
 747  * The function panics if the request can not be satisfied.
 748  */
 749 void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
 750                                   unsigned long goal)
 751 {
 752         bootmem_data_t *bdata;
 753         void *ptr;
 754
 755         list_for_each_entry(bdata, &bdata_list, list) {
 756                 ptr = alloc_bootmem_core(bdata, size, align, goal,
 757                                         ARCH_LOW_ADDRESS_LIMIT);
 758                 if (ptr)
 759                         return ptr;
 760         }
 761
 762         /*
 763          * Whoops, we cannot satisfy the allocation request.
 764          */
 765         printk(KERN_ALERT "low bootmem alloc of %lu bytes failed!\n", size);
 766         panic("Out of low memory");
 767         return NULL;
 768 }
 769
 770 /**
 771  * __alloc_bootmem_low_node - allocate low boot memory from a specific node
 772  * @pgdat: node to allocate from
 773  * @size: size of the request in bytes
 774  * @align: alignment of the region
 775  * @goal: preferred starting address of the region
 776  *
 777  * The goal is dropped if it can not be satisfied and the allocation will
 778  * fall back to memory below @goal.
 779  *
 780  * Allocation may fall back to any node in the system if the specified node
 781  * can not hold the requested memory.
 782  *
 783  * The function panics if the request can not be satisfied.
 784  */
 785 void * __init __alloc_bootmem_low_node(pg_data_t *pgdat, unsigned long size,
 786                                        unsigned long align, unsigned long goal)
 787 {
 788         return alloc_bootmem_core(pgdat->bdata, size, align, goal,
 789                                 ARCH_LOW_ADDRESS_LIMIT);
 790 }