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