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         int aligned;
 148         struct page *page;
 149         unsigned long start, end, pages, count = 0;
 150
 151         if (!bdata->node_bootmem_map)
 152                 return 0;
 153
 154         start = PFN_DOWN(bdata->node_boot_start);
 155         end = bdata->node_low_pfn;
 156
 157         /*
 158          * If the start is aligned to the machines wordsize, we might
 159          * be able to free pages in bulks of that order.
 160          */
 161         aligned = !(start & (BITS_PER_LONG - 1));
 162
 163         bdebug("nid=%td start=%lx end=%lx aligned=%d\n",
 164                 bdata - bootmem_node_data, start, end, aligned);
 165
 166         while (start < end) {
 167                 unsigned long *map, idx, vec;
 168
 169                 map = bdata->node_bootmem_map;
 170                 idx = start - PFN_DOWN(bdata->node_boot_start);
 171                 vec = ~map[idx / BITS_PER_LONG];
 172
 173                 if (aligned && vec == ~0UL && start + BITS_PER_LONG < end) {
 174                         int order = ilog2(BITS_PER_LONG);
 175
 176                         __free_pages_bootmem(pfn_to_page(start), order);
 177                         count += BITS_PER_LONG;
 178                 } else {
 179                         unsigned long off = 0;
 180
 181                         while (vec && off < BITS_PER_LONG) {
 182                                 if (vec & 1) {
 183                                         page = pfn_to_page(start + off);
 184                                         __free_pages_bootmem(page, 0);
 185                                         count++;
 186                                 }
 187                                 vec >>= 1;
 188                                 off++;
 189                         }
 190                 }
 191                 start += BITS_PER_LONG;
 192         }
 193
 194         page = virt_to_page(bdata->node_bootmem_map);
 195         pages = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 196         pages = bootmem_bootmap_pages(pages);
 197         count += pages;
 198         while (pages--)
 199                 __free_pages_bootmem(page++, 0);
 200
 201         bdebug("nid=%td released=%lx\n", bdata - bootmem_node_data, count);
 202
 203         return count;
 204 }
 205
 206 /**
 207  * free_all_bootmem_node - release a node's free pages to the buddy allocator
 208  * @pgdat: node to be released
 209  *
 210  * Returns the number of pages actually released.
 211  */
 212 unsigned long __init free_all_bootmem_node(pg_data_t *pgdat)
 213 {
 214         register_page_bootmem_info_node(pgdat);
 215         return free_all_bootmem_core(pgdat->bdata);
 216 }
 217
 218 /**
 219  * free_all_bootmem - release free pages to the buddy allocator
 220  *
 221  * Returns the number of pages actually released.
 222  */
 223 unsigned long __init free_all_bootmem(void)
 224 {
 225         return free_all_bootmem_core(NODE_DATA(0)->bdata);
 226 }
 227
 228 static void __init free_bootmem_core(bootmem_data_t *bdata, unsigned long addr,
 229                                      unsigned long size)
 230 {
 231         unsigned long sidx, eidx;
 232         unsigned long i;
 233
 234         BUG_ON(!size);
 235
 236         /* out range */
 237         if (addr + size < bdata->node_boot_start ||
 238                 PFN_DOWN(addr) > bdata->node_low_pfn)
 239                 return;
 240         /*
 241          * round down end of usable mem, partially free pages are
 242          * considered reserved.
 243          */
 244
 245         if (addr >= bdata->node_boot_start &&
 246                         PFN_DOWN(addr - bdata->node_boot_start) < bdata->hint_idx)
 247                 bdata->hint_idx = PFN_DOWN(addr - bdata->node_boot_start);
 248
 249         /*
 250          * Round up to index to the range.
 251          */
 252         if (PFN_UP(addr) > PFN_DOWN(bdata->node_boot_start))
 253                 sidx = PFN_UP(addr) - PFN_DOWN(bdata->node_boot_start);
 254         else
 255                 sidx = 0;
 256
 257         eidx = PFN_DOWN(addr + size - bdata->node_boot_start);
 258         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 259                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 260
 261         bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,
 262                 sidx + PFN_DOWN(bdata->node_boot_start),
 263                 eidx + PFN_DOWN(bdata->node_boot_start));
 264
 265         for (i = sidx; i < eidx; i++) {
 266                 if (unlikely(!test_and_clear_bit(i, bdata->node_bootmem_map)))
 267                         BUG();
 268         }
 269 }
 270
 271 /**
 272  * free_bootmem_node - mark a page range as usable
 273  * @pgdat: node the range resides on
 274  * @physaddr: starting address of the range
 275  * @size: size of the range in bytes
 276  *
 277  * Partial pages will be considered reserved and left as they are.
 278  *
 279  * Only physical pages that actually reside on @pgdat are marked.
 280  */
 281 void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
 282                               unsigned long size)
 283 {
 284         free_bootmem_core(pgdat->bdata, physaddr, size);
 285 }
 286
 287 /**
 288  * free_bootmem - mark a page range as usable
 289  * @addr: starting address of the range
 290  * @size: size of the range in bytes
 291  *
 292  * Partial pages will be considered reserved and left as they are.
 293  *
 294  * All physical pages within the range are marked, no matter what
 295  * node they reside on.
 296  */
 297 void __init free_bootmem(unsigned long addr, unsigned long size)
 298 {
 299         bootmem_data_t *bdata;
 300         list_for_each_entry(bdata, &bdata_list, list)
 301                 free_bootmem_core(bdata, addr, size);
 302 }
 303
 304 /*
 305  * Marks a particular physical memory range as unallocatable. Usable RAM
 306  * might be used for boot-time allocations - or it might get added
 307  * to the free page pool later on.
 308  */
 309 static int __init can_reserve_bootmem_core(bootmem_data_t *bdata,
 310                         unsigned long addr, unsigned long size, int flags)
 311 {
 312         unsigned long sidx, eidx;
 313         unsigned long i;
 314
 315         BUG_ON(!size);
 316
 317         /* out of range, don't hold other */
 318         if (addr + size < bdata->node_boot_start ||
 319                 PFN_DOWN(addr) > bdata->node_low_pfn)
 320                 return 0;
 321
 322         /*
 323          * Round up to index to the range.
 324          */
 325         if (addr > bdata->node_boot_start)
 326                 sidx= PFN_DOWN(addr - bdata->node_boot_start);
 327         else
 328                 sidx = 0;
 329
 330         eidx = PFN_UP(addr + size - bdata->node_boot_start);
 331         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 332                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 333
 334         for (i = sidx; i < eidx; i++) {
 335                 if (test_bit(i, bdata->node_bootmem_map)) {
 336                         if (flags & BOOTMEM_EXCLUSIVE)
 337                                 return -EBUSY;
 338                 }
 339         }
 340
 341         return 0;
 342
 343 }
 344
 345 static void __init reserve_bootmem_core(bootmem_data_t *bdata,
 346                         unsigned long addr, unsigned long size, int flags)
 347 {
 348         unsigned long sidx, eidx;
 349         unsigned long i;
 350
 351         BUG_ON(!size);
 352
 353         /* out of range */
 354         if (addr + size < bdata->node_boot_start ||
 355                 PFN_DOWN(addr) > bdata->node_low_pfn)
 356                 return;
 357
 358         /*
 359          * Round up to index to the range.
 360          */
 361         if (addr > bdata->node_boot_start)
 362                 sidx= PFN_DOWN(addr - bdata->node_boot_start);
 363         else
 364                 sidx = 0;
 365
 366         eidx = PFN_UP(addr + size - bdata->node_boot_start);
 367         if (eidx > bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start))
 368                 eidx = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
 369
 370         bdebug("nid=%td start=%lx end=%lx flags=%x\n",
 371                 bdata - bootmem_node_data,
 372                 sidx + PFN_DOWN(bdata->node_boot_start),
 373                 eidx + PFN_DOWN(bdata->node_boot_start),
 374                 flags);
 375
 376         for (i = sidx; i < eidx; i++)
 377                 if (test_and_set_bit(i, bdata->node_bootmem_map))
 378                         bdebug("hm, page %lx reserved twice.\n",
 379                                 PFN_DOWN(bdata->node_boot_start) + i);
 380 }
 381
 382 /**
 383  * reserve_bootmem_node - mark a page range as reserved
 384  * @pgdat: node the range resides on
 385  * @physaddr: starting address of the range
 386  * @size: size of the range in bytes
 387  * @flags: reservation flags (see linux/bootmem.h)
 388  *
 389  * Partial pages will be reserved.
 390  *
 391  * Only physical pages that actually reside on @pgdat are marked.
 392  */
 393 int __init reserve_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
 394                                  unsigned long size, int flags)
 395 {
 396         int ret;
 397
 398         ret = can_reserve_bootmem_core(pgdat->bdata, physaddr, size, flags);
 399         if (ret < 0)
 400                 return -ENOMEM;
 401         reserve_bootmem_core(pgdat->bdata, physaddr, size, flags);
 402         return 0;
 403 }
 404
 405 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 406 /**
 407  * reserve_bootmem - mark a page range as usable
 408  * @addr: starting address of the range
 409  * @size: size of the range in bytes
 410  * @flags: reservation flags (see linux/bootmem.h)
 411  *
 412  * Partial pages will be reserved.
 413  *
 414  * All physical pages within the range are marked, no matter what
 415  * node they reside on.
 416  */
 417 int __init reserve_bootmem(unsigned long addr, unsigned long size,
 418                             int flags)
 419 {
 420         bootmem_data_t *bdata;
 421         int ret;
 422
 423         list_for_each_entry(bdata, &bdata_list, list) {
 424                 ret = can_reserve_bootmem_core(bdata, addr, size, flags);
 425                 if (ret < 0)
 426                         return ret;
 427         }
 428         list_for_each_entry(bdata, &bdata_list, list)
 429                 reserve_bootmem_core(bdata, addr, size, flags);
 430
 431         return 0;
 432 }
 433 #endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
 434
 435 static void * __init alloc_bootmem_core(struct bootmem_data *bdata,
 436                                 unsigned long size, unsigned long align,
 437                                 unsigned long goal, unsigned long limit)
 438 {
 439         unsigned long min, max, start, sidx, midx, step;
 440
 441         BUG_ON(!size);
 442         BUG_ON(align & (align - 1));
 443         BUG_ON(limit && goal + size > limit);
 444
 445         if (!bdata->node_bootmem_map)
 446                 return NULL;
 447
 448         bdebug("nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n",
 449                 bdata - bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,
 450                 align, goal, limit);
 451
 452         min = PFN_DOWN(bdata->node_boot_start);
 453         max = bdata->node_low_pfn;
 454
 455         goal >>= PAGE_SHIFT;
 456         limit >>= PAGE_SHIFT;
 457
 458         if (limit && max > limit)
 459                 max = limit;
 460         if (max <= min)
 461                 return NULL;
 462
 463         step = max(align >> PAGE_SHIFT, 1UL);
 464
 465         if (goal && min < goal && goal < max)
 466                 start = ALIGN(goal, step);
 467         else
 468                 start = ALIGN(min, step);
 469
 470         sidx = start - PFN_DOWN(bdata->node_boot_start);
 471         midx = max - PFN_DOWN(bdata->node_boot_start);
 472
 473         if (bdata->hint_idx > sidx) {
 474                 /* Make sure we retry on failure */
 475                 goal = 1;
 476                 sidx = ALIGN(bdata->hint_idx, step);
 477         }
 478
 479         while (1) {
 480                 int merge;
 481                 void *region;
 482                 unsigned long eidx, i, start_off, end_off;
 483 find_block:
 484                 sidx = find_next_zero_bit(bdata->node_bootmem_map, midx, sidx);
 485                 sidx = ALIGN(sidx, step);
 486                 eidx = sidx + PFN_UP(size);
 487
 488                 if (sidx >= midx || eidx > midx)
 489                         break;
 490
 491                 for (i = sidx; i < eidx; i++)
 492                         if (test_bit(i, bdata->node_bootmem_map)) {
 493                                 sidx = ALIGN(i, step);
 494                                 if (sidx == i)
 495                                         sidx += step;
 496                                 goto find_block;
 497                         }
 498
 499                 if (bdata->last_end_off &&
 500                                 PFN_DOWN(bdata->last_end_off) + 1 == sidx)
 501                         start_off = ALIGN(bdata->last_end_off, align);
 502                 else
 503                         start_off = PFN_PHYS(sidx);
 504
 505                 merge = PFN_DOWN(start_off) < sidx;
 506                 end_off = start_off + size;
 507
 508                 bdata->last_end_off = end_off;
 509                 bdata->hint_idx = PFN_UP(end_off);
 510
 511                 /*
 512                  * Reserve the area now:
 513                  */
 514                 for (i = PFN_DOWN(start_off) + merge;
 515                                 i < PFN_UP(end_off); i++)
 516                         if (test_and_set_bit(i, bdata->node_bootmem_map))
 517                                 BUG();
 518
 519                 region = phys_to_virt(bdata->node_boot_start + start_off);
 520                 memset(region, 0, size);
 521                 return region;
 522         }
 523
 524         if (goal) {
 525                 goal = 0;
 526                 sidx = 0;
 527                 goto find_block;
 528         }
 529
 530         return NULL;
 531 }
 532
 533 /**
 534  * __alloc_bootmem_nopanic - allocate boot memory without panicking
 535  * @size: size of the request in bytes
 536  * @align: alignment of the region
 537  * @goal: preferred starting address of the region
 538  *
 539  * The goal is dropped if it can not be satisfied and the allocation will
 540  * fall back to memory below @goal.
 541  *
 542  * Allocation may happen on any node in the system.
 543  *
 544  * Returns NULL on failure.
 545  */
 546 void * __init __alloc_bootmem_nopanic(unsigned long size, unsigned long align,
 547                                       unsigned long goal)
 548 {
 549         bootmem_data_t *bdata;
 550         void *ptr;
 551
 552         list_for_each_entry(bdata, &bdata_list, list) {
 553                 ptr = alloc_bootmem_core(bdata, size, align, goal, 0);
 554                 if (ptr)
 555                         return ptr;
 556         }
 557         return NULL;
 558 }
 559
 560 /**
 561  * __alloc_bootmem - allocate boot memory
 562  * @size: size of the request in bytes
 563  * @align: alignment of the region
 564  * @goal: preferred starting address of the region
 565  *
 566  * The goal is dropped if it can not be satisfied and the allocation will
 567  * fall back to memory below @goal.
 568  *
 569  * Allocation may happen on any node in the system.
 570  *
 571  * The function panics if the request can not be satisfied.
 572  */
 573 void * __init __alloc_bootmem(unsigned long size, unsigned long align,
 574                               unsigned long goal)
 575 {
 576         void *mem = __alloc_bootmem_nopanic(size,align,goal);
 577
 578         if (mem)
 579                 return mem;
 580         /*
 581          * Whoops, we cannot satisfy the allocation request.
 582          */
 583         printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size);
 584         panic("Out of memory");
 585         return NULL;
 586 }
 587
 588 /**
 589  * __alloc_bootmem_node - allocate boot memory from a specific node
 590  * @pgdat: node to allocate from
 591  * @size: size of the request in bytes
 592  * @align: alignment of the region
 593  * @goal: preferred starting address of the region
 594  *
 595  * The goal is dropped if it can not be satisfied and the allocation will
 596  * fall back to memory below @goal.
 597  *
 598  * Allocation may fall back to any node in the system if the specified node
 599  * can not hold the requested memory.
 600  *
 601  * The function panics if the request can not be satisfied.
 602  */
 603 void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
 604                                    unsigned long align, unsigned long goal)
 605 {
 606         void *ptr;
 607
 608         ptr = alloc_bootmem_core(pgdat->bdata, size, align, goal, 0);
 609         if (ptr)
 610                 return ptr;
 611
 612         return __alloc_bootmem(size, align, goal);
 613 }
 614
 615 #ifdef CONFIG_SPARSEMEM
 616 /**
 617  * alloc_bootmem_section - allocate boot memory from a specific section
 618  * @size: size of the request in bytes
 619  * @section_nr: sparse map section to allocate from
 620  *
 621  * Return NULL on failure.
 622  */
 623 void * __init alloc_bootmem_section(unsigned long size,
 624                                     unsigned long section_nr)
 625 {
 626         void *ptr;
 627         unsigned long limit, goal, start_nr, end_nr, pfn;
 628         struct pglist_data *pgdat;
 629
 630         pfn = section_nr_to_pfn(section_nr);
 631         goal = PFN_PHYS(pfn);
 632         limit = PFN_PHYS(section_nr_to_pfn(section_nr + 1)) - 1;
 633         pgdat = NODE_DATA(early_pfn_to_nid(pfn));
 634         ptr = alloc_bootmem_core(pgdat->bdata, size, SMP_CACHE_BYTES, goal,
 635                                 limit);
 636
 637         if (!ptr)
 638                 return NULL;
 639
 640         start_nr = pfn_to_section_nr(PFN_DOWN(__pa(ptr)));
 641         end_nr = pfn_to_section_nr(PFN_DOWN(__pa(ptr) + size));
 642         if (start_nr != section_nr || end_nr != section_nr) {
 643                 printk(KERN_WARNING "alloc_bootmem failed on section %ld.\n",
 644                        section_nr);
 645                 free_bootmem_core(pgdat->bdata, __pa(ptr), size);
 646                 ptr = NULL;
 647         }
 648
 649         return ptr;
 650 }
 651 #endif
 652
 653 void * __init __alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size,
 654                                    unsigned long align, unsigned long goal)
 655 {
 656         void *ptr;
 657
 658         ptr = alloc_bootmem_core(pgdat->bdata, size, align, goal, 0);
 659         if (ptr)
 660                 return ptr;
 661
 662         return __alloc_bootmem_nopanic(size, align, goal);
 663 }
 664
 665 #ifndef ARCH_LOW_ADDRESS_LIMIT
 666 #define ARCH_LOW_ADDRESS_LIMIT  0xffffffffUL
 667 #endif
 668
 669 /**
 670  * __alloc_bootmem_low - allocate low boot memory
 671  * @size: size of the request in bytes
 672  * @align: alignment of the region
 673  * @goal: preferred starting address of the region
 674  *
 675  * The goal is dropped if it can not be satisfied and the allocation will
 676  * fall back to memory below @goal.
 677  *
 678  * Allocation may happen on any node in the system.
 679  *
 680  * The function panics if the request can not be satisfied.
 681  */
 682 void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
 683                                   unsigned long goal)
 684 {
 685         bootmem_data_t *bdata;
 686         void *ptr;
 687
 688         list_for_each_entry(bdata, &bdata_list, list) {
 689                 ptr = alloc_bootmem_core(bdata, size, align, goal,
 690                                         ARCH_LOW_ADDRESS_LIMIT);
 691                 if (ptr)
 692                         return ptr;
 693         }
 694
 695         /*
 696          * Whoops, we cannot satisfy the allocation request.
 697          */
 698         printk(KERN_ALERT "low bootmem alloc of %lu bytes failed!\n", size);
 699         panic("Out of low memory");
 700         return NULL;
 701 }
 702
 703 /**
 704  * __alloc_bootmem_low_node - allocate low boot memory from a specific node
 705  * @pgdat: node to allocate from
 706  * @size: size of the request in bytes
 707  * @align: alignment of the region
 708  * @goal: preferred starting address of the region
 709  *
 710  * The goal is dropped if it can not be satisfied and the allocation will
 711  * fall back to memory below @goal.
 712  *
 713  * Allocation may fall back to any node in the system if the specified node
 714  * can not hold the requested memory.
 715  *
 716  * The function panics if the request can not be satisfied.
 717  */
 718 void * __init __alloc_bootmem_low_node(pg_data_t *pgdat, unsigned long size,
 719                                        unsigned long align, unsigned long goal)
 720 {
 721         return alloc_bootmem_core(pgdat->bdata, size, align, goal,
 722                                 ARCH_LOW_ADDRESS_LIMIT);
 723 }