bootmem: revisit bootmem descriptor list handling
[linux-2.6.git] / 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 }