2005-04-17 02:20:36 +04:00
/*
2008-07-24 08:28:00 +04:00
* bootmem - A boot - time physical memory allocator and configurator
2005-04-17 02:20:36 +04:00
*
* Copyright ( C ) 1999 Ingo Molnar
2008-07-24 08:28:00 +04:00
* 1999 Kanoj Sarcar , SGI
* 2008 Johannes Weiner
2005-04-17 02:20:36 +04:00
*
2008-07-24 08:28:00 +04:00
* Access to this subsystem has to be serialized externally ( which is true
* for the boot process anyway ) .
2005-04-17 02:20:36 +04:00
*/
# include <linux/init.h>
2006-09-26 10:31:07 +04:00
# include <linux/pfn.h>
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
# include <linux/slab.h>
2005-04-17 02:20:36 +04:00
# include <linux/bootmem.h>
# include <linux/module.h>
2009-07-07 13:33:01 +04:00
# include <linux/kmemleak.h>
2010-02-10 12:20:20 +03:00
# include <linux/range.h>
2006-09-26 10:31:06 +04:00
# include <asm/bug.h>
2005-04-17 02:20:36 +04:00
# include <asm/io.h>
2006-09-26 10:31:33 +04:00
# include <asm/processor.h>
2006-09-26 10:31:06 +04:00
2005-04-17 02:20:36 +04:00
# include "internal.h"
unsigned long max_low_pfn ;
unsigned long min_low_pfn ;
unsigned long max_pfn ;
2005-06-26 01:58:18 +04:00
# ifdef CONFIG_CRASH_DUMP
/*
* If we have booted due to a crash , max_pfn will be a very low value . We need
* to know the amount of memory that the previous kernel used .
*/
unsigned long saved_max_pfn ;
# endif
2010-02-10 12:20:20 +03:00
# ifndef CONFIG_NO_BOOTMEM
2008-07-24 08:26:55 +04:00
bootmem_data_t bootmem_node_data [ MAX_NUMNODES ] __initdata ;
2008-07-24 08:28:03 +04:00
static struct list_head bdata_list __initdata = LIST_HEAD_INIT ( bdata_list ) ;
2008-07-24 08:28:02 +04:00
static int bootmem_debug ;
static int __init bootmem_debug_setup ( char * buf )
{
bootmem_debug = 1 ;
return 0 ;
}
early_param ( " bootmem_debug " , bootmem_debug_setup ) ;
# define bdebug(fmt, args...) ({ \
if ( unlikely ( bootmem_debug ) ) \
printk ( KERN_INFO \
" bootmem::%s " fmt , \
2008-10-16 09:01:25 +04:00
__func__ , # # args ) ; \
2008-07-24 08:28:02 +04:00
} )
2008-07-24 08:28:02 +04:00
static unsigned long __init bootmap_bytes ( unsigned long pages )
2008-07-24 08:28:00 +04:00
{
2008-07-24 08:28:02 +04:00
unsigned long bytes = ( pages + 7 ) / 8 ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:02 +04:00
return ALIGN ( bytes , sizeof ( long ) ) ;
2008-07-24 08:28:00 +04:00
}
2008-07-24 08:28:01 +04:00
/**
* bootmem_bootmap_pages - calculate bitmap size in pages
* @ pages : number of pages the bitmap has to represent
*/
2006-09-26 10:31:08 +04:00
unsigned long __init bootmem_bootmap_pages ( unsigned long pages )
2005-04-17 02:20:36 +04:00
{
2008-07-24 08:28:02 +04:00
unsigned long bytes = bootmap_bytes ( pages ) ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:02 +04:00
return PAGE_ALIGN ( bytes ) > > PAGE_SHIFT ;
2005-04-17 02:20:36 +04:00
}
2006-09-26 10:31:08 +04:00
2006-03-27 13:15:58 +04:00
/*
* link bdata in order
*/
2006-09-26 10:31:04 +04:00
static void __init link_bootmem ( bootmem_data_t * bdata )
2006-03-27 13:15:58 +04:00
{
2008-07-24 08:28:03 +04:00
struct list_head * iter ;
2006-09-26 10:31:08 +04:00
2008-07-24 08:28:03 +04:00
list_for_each ( iter , & bdata_list ) {
bootmem_data_t * ent ;
ent = list_entry ( iter , bootmem_data_t , list ) ;
2008-07-24 08:28:09 +04:00
if ( bdata - > node_min_pfn < ent - > node_min_pfn )
2008-07-24 08:28:03 +04:00
break ;
2006-03-27 13:15:58 +04:00
}
2008-07-24 08:28:03 +04:00
list_add_tail ( & bdata - > list , iter ) ;
2006-03-27 13:15:58 +04:00
}
2005-04-17 02:20:36 +04:00
/*
* Called once to set up the allocator itself .
*/
2008-07-24 08:26:59 +04:00
static unsigned long __init init_bootmem_core ( bootmem_data_t * bdata ,
2005-04-17 02:20:36 +04:00
unsigned long mapstart , unsigned long start , unsigned long end )
{
2006-09-26 10:31:07 +04:00
unsigned long mapsize ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:26:52 +04:00
mminit_validate_memmodel_limits ( & start , & end ) ;
2006-09-26 10:31:07 +04:00
bdata - > node_bootmem_map = phys_to_virt ( PFN_PHYS ( mapstart ) ) ;
2008-07-24 08:28:09 +04:00
bdata - > node_min_pfn = start ;
2005-04-17 02:20:36 +04:00
bdata - > node_low_pfn = end ;
2006-03-27 13:15:58 +04:00
link_bootmem ( bdata ) ;
2005-04-17 02:20:36 +04:00
/*
* Initially all pages are reserved - setup_arch ( ) has to
* register free RAM areas explicitly .
*/
2008-07-24 08:28:02 +04:00
mapsize = bootmap_bytes ( end - start ) ;
2005-04-17 02:20:36 +04:00
memset ( bdata - > node_bootmem_map , 0xff , mapsize ) ;
2008-07-24 08:28:02 +04:00
bdebug ( " nid=%td start=%lx map=%lx end=%lx mapsize=%lx \n " ,
bdata - bootmem_node_data , start , mapstart , end , mapsize ) ;
2005-04-17 02:20:36 +04:00
return mapsize ;
}
2008-07-24 08:28:01 +04:00
/**
* init_bootmem_node - register a node as boot memory
* @ pgdat : node to register
* @ freepfn : pfn where the bitmap for this node is to be placed
* @ startpfn : first pfn on the node
* @ endpfn : first pfn after the node
*
* Returns the number of bytes needed to hold the bitmap for this node .
*/
2008-07-24 08:28:00 +04:00
unsigned long __init init_bootmem_node ( pg_data_t * pgdat , unsigned long freepfn ,
unsigned long startpfn , unsigned long endpfn )
{
return init_bootmem_core ( pgdat - > bdata , freepfn , startpfn , endpfn ) ;
}
2008-07-24 08:28:01 +04:00
/**
* init_bootmem - register boot memory
* @ start : pfn where the bitmap is to be placed
* @ pages : number of available physical pages
*
* Returns the number of bytes needed to hold the bitmap .
*/
2008-07-24 08:28:00 +04:00
unsigned long __init init_bootmem ( unsigned long start , unsigned long pages )
{
max_low_pfn = pages ;
min_low_pfn = start ;
return init_bootmem_core ( NODE_DATA ( 0 ) - > bdata , start , 0 , pages ) ;
}
2010-02-10 12:20:20 +03:00
# endif
2009-11-10 13:46:17 +03:00
/*
* free_bootmem_late - free bootmem pages directly to page allocator
* @ addr : starting address of the range
* @ size : size of the range in bytes
*
* This is only useful when the bootmem allocator has already been torn
* down , but we are still initializing the system . Pages are given directly
* to the page allocator , no bootmem metadata is updated because it is gone .
*/
void __init free_bootmem_late ( unsigned long addr , unsigned long size )
{
unsigned long cursor , end ;
kmemleak_free_part ( __va ( addr ) , size ) ;
cursor = PFN_UP ( addr ) ;
end = PFN_DOWN ( addr + size ) ;
for ( ; cursor < end ; cursor + + ) {
__free_pages_bootmem ( pfn_to_page ( cursor ) , 0 ) ;
totalram_pages + + ;
}
}
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
static void __init __free_pages_memory ( unsigned long start , unsigned long end )
{
int i ;
unsigned long start_aligned , end_aligned ;
int order = ilog2 ( BITS_PER_LONG ) ;
start_aligned = ( start + ( BITS_PER_LONG - 1 ) ) & ~ ( BITS_PER_LONG - 1 ) ;
end_aligned = end & ~ ( BITS_PER_LONG - 1 ) ;
if ( end_aligned < = start_aligned ) {
for ( i = start ; i < end ; i + + )
__free_pages_bootmem ( pfn_to_page ( i ) , 0 ) ;
return ;
}
for ( i = start ; i < start_aligned ; i + + )
__free_pages_bootmem ( pfn_to_page ( i ) , 0 ) ;
for ( i = start_aligned ; i < end_aligned ; i + = BITS_PER_LONG )
__free_pages_bootmem ( pfn_to_page ( i ) , order ) ;
for ( i = end_aligned ; i < end ; i + + )
__free_pages_bootmem ( pfn_to_page ( i ) , 0 ) ;
}
unsigned long __init free_all_memory_core_early ( int nodeid )
{
int i ;
u64 start , end ;
unsigned long count = 0 ;
struct range * range = NULL ;
int nr_range ;
nr_range = get_free_all_memory_range ( & range , nodeid ) ;
for ( i = 0 ; i < nr_range ; i + + ) {
start = range [ i ] . start ;
end = range [ i ] . end ;
count + = end - start ;
__free_pages_memory ( start , end ) ;
}
return count ;
}
# else
2008-07-24 08:28:00 +04:00
static unsigned long __init free_all_bootmem_core ( bootmem_data_t * bdata )
{
2008-07-24 08:28:03 +04:00
int aligned ;
2008-07-24 08:28:00 +04:00
struct page * page ;
2008-07-24 08:28:03 +04:00
unsigned long start , end , pages , count = 0 ;
if ( ! bdata - > node_bootmem_map )
return 0 ;
2008-07-24 08:28:09 +04:00
start = bdata - > node_min_pfn ;
2008-07-24 08:28:03 +04:00
end = bdata - > node_low_pfn ;
2008-07-24 08:28:00 +04:00
/*
2008-07-24 08:28:03 +04:00
* If the start is aligned to the machines wordsize , we might
* be able to free pages in bulks of that order .
2008-07-24 08:28:00 +04:00
*/
2008-07-24 08:28:03 +04:00
aligned = ! ( start & ( BITS_PER_LONG - 1 ) ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:03 +04:00
bdebug ( " nid=%td start=%lx end=%lx aligned=%d \n " ,
bdata - bootmem_node_data , start , end , aligned ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:03 +04:00
while ( start < end ) {
unsigned long * map , idx , vec ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:03 +04:00
map = bdata - > node_bootmem_map ;
2008-07-24 08:28:09 +04:00
idx = start - bdata - > node_min_pfn ;
2008-07-24 08:28:03 +04:00
vec = ~ map [ idx / BITS_PER_LONG ] ;
if ( aligned & & vec = = ~ 0UL & & start + BITS_PER_LONG < end ) {
int order = ilog2 ( BITS_PER_LONG ) ;
__free_pages_bootmem ( pfn_to_page ( start ) , order ) ;
2008-07-24 08:28:00 +04:00
count + = BITS_PER_LONG ;
2008-07-24 08:28:03 +04:00
} else {
unsigned long off = 0 ;
while ( vec & & off < BITS_PER_LONG ) {
if ( vec & 1 ) {
page = pfn_to_page ( start + off ) ;
2008-07-24 08:28:00 +04:00
__free_pages_bootmem ( page , 0 ) ;
2008-07-24 08:28:03 +04:00
count + + ;
2008-07-24 08:28:00 +04:00
}
2008-07-24 08:28:03 +04:00
vec > > = 1 ;
off + + ;
2008-07-24 08:28:00 +04:00
}
}
2008-07-24 08:28:03 +04:00
start + = BITS_PER_LONG ;
2008-07-24 08:28:00 +04:00
}
page = virt_to_page ( bdata - > node_bootmem_map ) ;
2008-07-24 08:28:09 +04:00
pages = bdata - > node_low_pfn - bdata - > node_min_pfn ;
2008-07-24 08:28:03 +04:00
pages = bootmem_bootmap_pages ( pages ) ;
count + = pages ;
while ( pages - - )
__free_pages_bootmem ( page + + , 0 ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:02 +04:00
bdebug ( " nid=%td released=%lx \n " , bdata - bootmem_node_data , count ) ;
2008-07-24 08:28:00 +04:00
return count ;
}
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:01 +04:00
/**
* free_all_bootmem_node - release a node ' s free pages to the buddy allocator
* @ pgdat : node to be released
*
* Returns the number of pages actually released .
*/
2008-07-24 08:28:00 +04:00
unsigned long __init free_all_bootmem_node ( pg_data_t * pgdat )
{
register_page_bootmem_info_node ( pgdat ) ;
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
/* free_all_memory_core_early(MAX_NUMNODES) will be called later */
return 0 ;
# else
2008-07-24 08:28:00 +04:00
return free_all_bootmem_core ( pgdat - > bdata ) ;
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
}
2008-07-24 08:28:01 +04:00
/**
* free_all_bootmem - release free pages to the buddy allocator
*
* Returns the number of pages actually released .
*/
2008-07-24 08:28:00 +04:00
unsigned long __init free_all_bootmem ( void )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
nobootmem, x86: Fix 32bit numa system without RAM on node 0
On one system without RAM on node0, got following boot dump with a 32
bit NUMA kernel:
early_node_map[4] active PFN ranges
1: 0x00000010 -> 0x00000099
1: 0x00000100 -> 0x0007da00
1: 0x0007e800 -> 0x0007ffa0
1: 0x0007ffae -> 0x0007ffb0
...
Subtract (29 early reservations)
#000 [0000001000 - 0000002000]
#001 [0000089000 - 000008f000]
#002 [0000091000 - 0000093500]
...
#027 [007cbfef40 - 007e800000]
#028 [007e9ca000 - 007ff95000]
(0 free memory ranges)
Initializing HighMem for node 0 (00000000:00000000)
Initializing HighMem for node 1 (00000000:00000000)
Memory: 0k/2096832k available (6662k kernel code, 2096300k reserved, 4829k data, 484k init, 0k highmem)
...
Checking if this processor honours the WP bit even in supervisor mode...Ok.
swapper: page allocation failure. order:0, mode:0x0
Pid: 0, comm: swapper Not tainted 2.6.34-rc3-tip-03818-g4b1ea6c-dirty #35
Call Trace:
[<4087a5dc>] ? printk+0xf/0x11
[<40286728>] __alloc_pages_nodemask+0x417/0x487
[<402a9ce1>] new_slab+0xe2/0x1fe
[<402aa5b2>] kmem_cache_open+0x185/0x358
[<402abbc0>] T.954+0x1c/0x60
[<40d52a29>] kmem_cache_init+0x24/0x113
[<40d39738>] start_kernel+0x166/0x2e4
[<40d3940e>] ? unknown_bootoption+0x0/0x18e
[<40d390ce>] i386_start_kernel+0xce/0xd5
Mem-Info:
Node 1 DMA per-cpu:
CPU 0: hi: 0, btch: 1 usd: 0
Node 1 Normal per-cpu:
CPU 0: hi: 0, btch: 1 usd: 0
active_anon:0 inactive_anon:0 isolated_anon:0
active_file:0 inactive_file:0 isolated_file:0
unevictable:0 dirty:0 writeback:0 unstable:0
free:0 slab_reclaimable:0 slab_unreclaimable:0
mapped:0 shmem:0 pagetables:0 bounce:0
When 32bit NUMA is used, free_all_bootmem() will still only go over with
node id 0.
If node 0 doesn't have RAM installed, We need to go with node1
because early_node_map still use 1 for all ranges, and ram from node1
become low ram.
Use MAX_NUMNODES like 64-bit NUMA does.
Note: BOOTMEM path has the same problem.
this bug exist before We have NO_BOOTMEM support.
-v3: add more comments, and fix bootmem path too.
-v4: seperate bootmem path fix
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
LKML-Reference: <4BB41689.9090502@kernel.org>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2010-04-01 07:44:09 +04:00
/*
* We need to use MAX_NUMNODES instead of NODE_DATA ( 0 ) - > node_id
* because in some case like Node0 doesnt have RAM installed
* low ram will be on Node1
* Use MAX_NUMNODES will make sure all ranges in early_node_map [ ]
* will be used instead of only Node0 related
*/
return free_all_memory_core_early ( MAX_NUMNODES ) ;
2010-02-10 12:20:20 +03:00
# else
2010-04-01 07:45:27 +04:00
unsigned long total_pages = 0 ;
bootmem_data_t * bdata ;
list_for_each_entry ( bdata , & bdata_list , list )
total_pages + = free_all_bootmem_core ( bdata ) ;
return total_pages ;
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
}
2010-02-10 12:20:20 +03:00
# ifndef CONFIG_NO_BOOTMEM
2008-07-24 08:28:05 +04:00
static void __init __free ( bootmem_data_t * bdata ,
unsigned long sidx , unsigned long eidx )
{
unsigned long idx ;
bdebug ( " nid=%td start=%lx end=%lx \n " , bdata - bootmem_node_data ,
2008-07-24 08:28:09 +04:00
sidx + bdata - > node_min_pfn ,
eidx + bdata - > node_min_pfn ) ;
2008-07-24 08:28:05 +04:00
2008-07-24 08:28:06 +04:00
if ( bdata - > hint_idx > sidx )
bdata - > hint_idx = sidx ;
2008-07-24 08:28:05 +04:00
for ( idx = sidx ; idx < eidx ; idx + + )
if ( ! test_and_clear_bit ( idx , bdata - > node_bootmem_map ) )
BUG ( ) ;
}
static int __init __reserve ( bootmem_data_t * bdata , unsigned long sidx ,
unsigned long eidx , int flags )
{
unsigned long idx ;
int exclusive = flags & BOOTMEM_EXCLUSIVE ;
bdebug ( " nid=%td start=%lx end=%lx flags=%x \n " ,
bdata - bootmem_node_data ,
2008-07-24 08:28:09 +04:00
sidx + bdata - > node_min_pfn ,
eidx + bdata - > node_min_pfn ,
2008-07-24 08:28:05 +04:00
flags ) ;
for ( idx = sidx ; idx < eidx ; idx + + )
if ( test_and_set_bit ( idx , bdata - > node_bootmem_map ) ) {
if ( exclusive ) {
__free ( bdata , sidx , idx ) ;
return - EBUSY ;
}
bdebug ( " silent double reserve of PFN %lx \n " ,
2008-07-24 08:28:09 +04:00
idx + bdata - > node_min_pfn ) ;
2008-07-24 08:28:05 +04:00
}
return 0 ;
}
2008-07-24 08:28:06 +04:00
static int __init mark_bootmem_node ( bootmem_data_t * bdata ,
unsigned long start , unsigned long end ,
int reserve , int flags )
2008-07-24 08:28:00 +04:00
{
unsigned long sidx , eidx ;
2008-07-24 08:28:06 +04:00
bdebug ( " nid=%td start=%lx end=%lx reserve=%d flags=%x \n " ,
bdata - bootmem_node_data , start , end , reserve , flags ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:09 +04:00
BUG_ON ( start < bdata - > node_min_pfn ) ;
2008-07-24 08:28:06 +04:00
BUG_ON ( end > bdata - > node_low_pfn ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:09 +04:00
sidx = start - bdata - > node_min_pfn ;
eidx = end - bdata - > node_min_pfn ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:06 +04:00
if ( reserve )
return __reserve ( bdata , sidx , eidx , flags ) ;
2008-07-24 08:28:00 +04:00
else
2008-07-24 08:28:06 +04:00
__free ( bdata , sidx , eidx ) ;
return 0 ;
}
static int __init mark_bootmem ( unsigned long start , unsigned long end ,
int reserve , int flags )
{
unsigned long pos ;
bootmem_data_t * bdata ;
pos = start ;
list_for_each_entry ( bdata , & bdata_list , list ) {
int err ;
unsigned long max ;
2008-07-24 08:28:09 +04:00
if ( pos < bdata - > node_min_pfn | |
pos > = bdata - > node_low_pfn ) {
2008-07-24 08:28:06 +04:00
BUG_ON ( pos ! = start ) ;
continue ;
}
max = min ( bdata - > node_low_pfn , end ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:06 +04:00
err = mark_bootmem_node ( bdata , pos , max , reserve , flags ) ;
if ( reserve & & err ) {
mark_bootmem ( start , pos , 0 , 0 ) ;
return err ;
}
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:06 +04:00
if ( max = = end )
return 0 ;
pos = bdata - > node_low_pfn ;
}
BUG ( ) ;
2008-07-24 08:28:00 +04:00
}
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:01 +04:00
/**
* free_bootmem_node - mark a page range as usable
* @ pgdat : node the range resides on
* @ physaddr : starting address of the range
* @ size : size of the range in bytes
*
* Partial pages will be considered reserved and left as they are .
*
2008-07-24 08:28:06 +04:00
* The range must reside completely on the specified node .
2008-07-24 08:28:01 +04:00
*/
2008-07-24 08:28:00 +04:00
void __init free_bootmem_node ( pg_data_t * pgdat , unsigned long physaddr ,
unsigned long size )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
free_early ( physaddr , physaddr + size ) ;
# else
2008-07-24 08:28:06 +04:00
unsigned long start , end ;
2009-07-07 13:33:01 +04:00
kmemleak_free_part ( __va ( physaddr ) , size ) ;
2008-07-24 08:28:06 +04:00
start = PFN_UP ( physaddr ) ;
end = PFN_DOWN ( physaddr + size ) ;
mark_bootmem_node ( pgdat - > bdata , start , end , 0 , 0 ) ;
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
}
2008-07-24 08:28:01 +04:00
/**
* free_bootmem - mark a page range as usable
* @ addr : starting address of the range
* @ size : size of the range in bytes
*
* Partial pages will be considered reserved and left as they are .
*
2008-07-24 08:28:06 +04:00
* The range must be contiguous but may span node boundaries .
2008-07-24 08:28:01 +04:00
*/
2008-07-24 08:28:00 +04:00
void __init free_bootmem ( unsigned long addr , unsigned long size )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
free_early ( addr , addr + size ) ;
# else
2008-07-24 08:28:06 +04:00
unsigned long start , end ;
2008-03-18 22:49:12 +03:00
2009-07-07 13:33:01 +04:00
kmemleak_free_part ( __va ( addr ) , size ) ;
2008-07-24 08:28:06 +04:00
start = PFN_UP ( addr ) ;
end = PFN_DOWN ( addr + size ) ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:06 +04:00
mark_bootmem ( start , end , 0 , 0 ) ;
2010-02-10 12:20:20 +03:00
# endif
2005-04-17 02:20:36 +04:00
}
2008-07-24 08:28:01 +04:00
/**
* reserve_bootmem_node - mark a page range as reserved
* @ pgdat : node the range resides on
* @ physaddr : starting address of the range
* @ size : size of the range in bytes
* @ flags : reservation flags ( see linux / bootmem . h )
*
* Partial pages will be reserved .
*
2008-07-24 08:28:06 +04:00
* The range must reside completely on the specified node .
2008-07-24 08:28:01 +04:00
*/
2008-07-24 08:28:00 +04:00
int __init reserve_bootmem_node ( pg_data_t * pgdat , unsigned long physaddr ,
unsigned long size , int flags )
2005-04-17 02:20:36 +04:00
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
panic ( " no bootmem " ) ;
return 0 ;
# else
2008-07-24 08:28:06 +04:00
unsigned long start , end ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:06 +04:00
start = PFN_DOWN ( physaddr ) ;
end = PFN_UP ( physaddr + size ) ;
return mark_bootmem_node ( pgdat - > bdata , start , end , 1 , flags ) ;
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:00 +04:00
}
2008-03-24 22:29:45 +03:00
2008-07-24 08:28:01 +04:00
/**
* reserve_bootmem - mark a page range as usable
* @ addr : starting address of the range
* @ size : size of the range in bytes
* @ flags : reservation flags ( see linux / bootmem . h )
*
* Partial pages will be reserved .
*
2008-07-24 08:28:06 +04:00
* The range must be contiguous but may span node boundaries .
2008-07-24 08:28:01 +04:00
*/
2008-07-24 08:28:00 +04:00
int __init reserve_bootmem ( unsigned long addr , unsigned long size ,
int flags )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
panic ( " no bootmem " ) ;
return 0 ;
# else
2008-07-24 08:28:06 +04:00
unsigned long start , end ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:06 +04:00
start = PFN_DOWN ( addr ) ;
end = PFN_UP ( addr + size ) ;
2008-07-24 08:28:00 +04:00
2008-07-24 08:28:06 +04:00
return mark_bootmem ( start , end , 1 , flags ) ;
2010-02-10 12:20:20 +03:00
# endif
2005-04-17 02:20:36 +04:00
}
2010-02-10 12:20:20 +03:00
# ifndef CONFIG_NO_BOOTMEM
2009-12-15 04:59:46 +03:00
static unsigned long __init align_idx ( struct bootmem_data * bdata ,
unsigned long idx , unsigned long step )
2008-08-21 01:09:15 +04:00
{
unsigned long base = bdata - > node_min_pfn ;
/*
* Align the index with respect to the node start so that the
* combination of both satisfies the requested alignment .
*/
return ALIGN ( base + idx , step ) - base ;
}
2009-12-15 04:59:46 +03:00
static unsigned long __init align_off ( struct bootmem_data * bdata ,
unsigned long off , unsigned long align )
2008-08-21 01:09:15 +04:00
{
unsigned long base = PFN_PHYS ( bdata - > node_min_pfn ) ;
/* Same as align_idx for byte offsets */
return ALIGN ( base + off , align ) - base ;
}
2009-03-01 10:06:56 +03:00
static void * __init alloc_bootmem_core ( struct bootmem_data * bdata ,
unsigned long size , unsigned long align ,
unsigned long goal , unsigned long limit )
2005-04-17 02:20:36 +04:00
{
2008-07-24 08:28:07 +04:00
unsigned long fallback = 0 ;
2008-07-24 08:28:05 +04:00
unsigned long min , max , start , sidx , midx , step ;
2009-01-07 01:40:32 +03:00
bdebug ( " nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx \n " ,
bdata - bootmem_node_data , size , PAGE_ALIGN ( size ) > > PAGE_SHIFT ,
align , goal , limit ) ;
2008-07-24 08:28:05 +04:00
BUG_ON ( ! size ) ;
BUG_ON ( align & ( align - 1 ) ) ;
BUG_ON ( limit & & goal + size > limit ) ;
2005-04-17 02:20:36 +04:00
2006-12-07 07:32:41 +03:00
if ( ! bdata - > node_bootmem_map )
return NULL ;
2008-07-24 08:28:09 +04:00
min = bdata - > node_min_pfn ;
2008-07-24 08:28:05 +04:00
max = bdata - > node_low_pfn ;
2008-03-18 22:44:48 +03:00
2008-07-24 08:28:05 +04:00
goal > > = PAGE_SHIFT ;
limit > > = PAGE_SHIFT ;
if ( limit & & max > limit )
max = limit ;
if ( max < = min )
2008-03-18 22:44:48 +03:00
return NULL ;
2008-07-24 08:28:05 +04:00
step = max ( align > > PAGE_SHIFT , 1UL ) ;
2005-10-20 02:52:18 +04:00
2008-07-24 08:28:05 +04:00
if ( goal & & min < goal & & goal < max )
start = ALIGN ( goal , step ) ;
else
start = ALIGN ( min , step ) ;
2005-04-17 02:20:36 +04:00
2008-08-21 01:09:15 +04:00
sidx = start - bdata - > node_min_pfn ;
2008-07-24 08:28:09 +04:00
midx = max - bdata - > node_min_pfn ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:05 +04:00
if ( bdata - > hint_idx > sidx ) {
2008-07-24 08:28:07 +04:00
/*
* Handle the valid case of sidx being zero and still
* catch the fallback below .
*/
fallback = sidx + 1 ;
2008-08-21 01:09:15 +04:00
sidx = align_idx ( bdata , bdata - > hint_idx , step ) ;
2008-07-24 08:28:05 +04:00
}
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:05 +04:00
while ( 1 ) {
int merge ;
void * region ;
unsigned long eidx , i , start_off , end_off ;
find_block :
sidx = find_next_zero_bit ( bdata - > node_bootmem_map , midx , sidx ) ;
2008-08-21 01:09:15 +04:00
sidx = align_idx ( bdata , sidx , step ) ;
2008-07-24 08:28:05 +04:00
eidx = sidx + PFN_UP ( size ) ;
2008-03-11 09:23:42 +03:00
2008-07-24 08:28:05 +04:00
if ( sidx > = midx | | eidx > midx )
2005-12-12 11:37:39 +03:00
break ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:05 +04:00
for ( i = sidx ; i < eidx ; i + + )
if ( test_bit ( i , bdata - > node_bootmem_map ) ) {
2008-08-21 01:09:15 +04:00
sidx = align_idx ( bdata , i , step ) ;
2008-07-24 08:28:05 +04:00
if ( sidx = = i )
sidx + = step ;
goto find_block ;
}
2005-04-17 02:20:36 +04:00
bootmem allocator: alloc_bootmem_core(): page-align the end offset
This is the minimal sequence that jams the allocator:
void *p, *q, *r;
p = alloc_bootmem(PAGE_SIZE);
q = alloc_bootmem(64);
free_bootmem(p, PAGE_SIZE);
p = alloc_bootmem(PAGE_SIZE);
r = alloc_bootmem(64);
after this sequence (assuming that the allocator was empty or page-aligned
before), pointer "q" will be equal to pointer "r".
What's hapenning inside the allocator:
p = alloc_bootmem(PAGE_SIZE);
in allocator: last_end_off == PAGE_SIZE, bitmap contains bits 10000...
q = alloc_bootmem(64);
in allocator: last_end_off == PAGE_SIZE + 64, bitmap contains 11000...
free_bootmem(p, PAGE_SIZE);
in allocator: last_end_off == PAGE_SIZE + 64, bitmap contains 01000...
p = alloc_bootmem(PAGE_SIZE);
in allocator: last_end_off == PAGE_SIZE, bitmap contains 11000...
r = alloc_bootmem(64);
and now:
it finds bit "2", as a place where to allocate (sidx)
it hits the condition
if (bdata->last_end_off && PFN_DOWN(bdata->last_end_off) + 1 == sidx))
start_off = ALIGN(bdata->last_end_off, align);
-you can see that the condition is true, so it assigns start_off =
ALIGN(bdata->last_end_off, align); (that is PAGE_SIZE) and allocates
over already allocated block.
With the patch it tries to continue at the end of previous allocation only
if the previous allocation ended in the middle of the page.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Johannes Weiner <hannes@saeurebad.de>
Cc: David Miller <davem@davemloft.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-08-15 11:40:17 +04:00
if ( bdata - > last_end_off & ( PAGE_SIZE - 1 ) & &
2008-07-24 08:28:05 +04:00
PFN_DOWN ( bdata - > last_end_off ) + 1 = = sidx )
2008-08-21 01:09:15 +04:00
start_off = align_off ( bdata , bdata - > last_end_off , align ) ;
2008-07-24 08:28:05 +04:00
else
start_off = PFN_PHYS ( sidx ) ;
merge = PFN_DOWN ( start_off ) < sidx ;
end_off = start_off + size ;
bdata - > last_end_off = end_off ;
bdata - > hint_idx = PFN_UP ( end_off ) ;
/*
* Reserve the area now :
*/
2008-07-24 08:28:05 +04:00
if ( __reserve ( bdata , PFN_DOWN ( start_off ) + merge ,
PFN_UP ( end_off ) , BOOTMEM_EXCLUSIVE ) )
BUG ( ) ;
2008-07-24 08:28:05 +04:00
2008-07-24 08:28:09 +04:00
region = phys_to_virt ( PFN_PHYS ( bdata - > node_min_pfn ) +
start_off ) ;
2008-07-24 08:28:05 +04:00
memset ( region , 0 , size ) ;
2009-08-27 17:29:17 +04:00
/*
* The min_count is set to 0 so that bootmem allocated blocks
* are never reported as leaks .
*/
kmemleak_alloc ( region , size , 0 , 0 ) ;
2008-07-24 08:28:05 +04:00
return region ;
2005-04-17 02:20:36 +04:00
}
2008-07-24 08:28:07 +04:00
if ( fallback ) {
2008-08-21 01:09:15 +04:00
sidx = align_idx ( bdata , fallback - 1 , step ) ;
2008-07-24 08:28:07 +04:00
fallback = 0 ;
goto find_block ;
}
return NULL ;
}
2009-03-01 10:06:56 +03:00
static void * __init alloc_arch_preferred_bootmem ( bootmem_data_t * bdata ,
unsigned long size , unsigned long align ,
unsigned long goal , unsigned long limit )
{
2009-06-10 21:05:53 +04:00
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc ( size , GFP_NOWAIT ) ;
2009-03-01 10:06:56 +03:00
# ifdef CONFIG_HAVE_ARCH_BOOTMEM
2009-06-19 03:48:58 +04:00
{
bootmem_data_t * p_bdata ;
p_bdata = bootmem_arch_preferred_node ( bdata , size , align ,
goal , limit ) ;
if ( p_bdata )
return alloc_bootmem_core ( p_bdata , size , align ,
goal , limit ) ;
}
2009-03-01 10:06:56 +03:00
# endif
return NULL ;
}
2010-02-10 12:20:20 +03:00
# endif
2009-03-01 10:06:56 +03:00
2008-07-24 08:28:07 +04:00
static void * __init ___alloc_bootmem_nopanic ( unsigned long size ,
unsigned long align ,
unsigned long goal ,
unsigned long limit )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
void * ptr ;
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc ( size , GFP_NOWAIT ) ;
restart :
ptr = __alloc_memory_core_early ( MAX_NUMNODES , size , align , goal , limit ) ;
if ( ptr )
return ptr ;
if ( goal ! = 0 ) {
goal = 0 ;
goto restart ;
}
return NULL ;
# else
2008-07-24 08:28:07 +04:00
bootmem_data_t * bdata ;
2009-03-01 10:06:56 +03:00
void * region ;
2008-07-24 08:28:07 +04:00
restart :
2009-03-01 10:06:56 +03:00
region = alloc_arch_preferred_bootmem ( NULL , size , align , goal , limit ) ;
if ( region )
return region ;
2008-07-24 08:28:07 +04:00
2009-03-01 10:06:56 +03:00
list_for_each_entry ( bdata , & bdata_list , list ) {
2008-07-24 08:28:07 +04:00
if ( goal & & bdata - > node_low_pfn < = PFN_DOWN ( goal ) )
continue ;
2008-07-24 08:28:09 +04:00
if ( limit & & bdata - > node_min_pfn > = PFN_DOWN ( limit ) )
2008-07-24 08:28:07 +04:00
break ;
region = alloc_bootmem_core ( bdata , size , align , goal , limit ) ;
if ( region )
return region ;
}
2008-07-24 08:28:05 +04:00
if ( goal ) {
goal = 0 ;
2008-07-24 08:28:07 +04:00
goto restart ;
2008-07-24 08:28:05 +04:00
}
2008-07-24 08:28:02 +04:00
2008-07-24 08:28:05 +04:00
return NULL ;
2010-02-10 12:20:20 +03:00
# endif
2005-04-17 02:20:36 +04:00
}
2008-07-24 08:28:01 +04:00
/**
* __alloc_bootmem_nopanic - allocate boot memory without panicking
* @ size : size of the request in bytes
* @ align : alignment of the region
* @ goal : preferred starting address of the region
*
* The goal is dropped if it can not be satisfied and the allocation will
* fall back to memory below @ goal .
*
* Allocation may happen on any node in the system .
*
* Returns NULL on failure .
*/
2006-09-26 10:31:05 +04:00
void * __init __alloc_bootmem_nopanic ( unsigned long size , unsigned long align ,
2008-07-24 08:28:07 +04:00
unsigned long goal )
2005-04-17 02:20:36 +04:00
{
2010-02-10 12:20:20 +03:00
unsigned long limit = 0 ;
# ifdef CONFIG_NO_BOOTMEM
limit = - 1UL ;
# endif
return ___alloc_bootmem_nopanic ( size , align , goal , limit ) ;
2008-07-24 08:28:07 +04:00
}
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:07 +04:00
static void * __init ___alloc_bootmem ( unsigned long size , unsigned long align ,
unsigned long goal , unsigned long limit )
{
void * mem = ___alloc_bootmem_nopanic ( size , align , goal , limit ) ;
if ( mem )
return mem ;
/*
* Whoops , we cannot satisfy the allocation request .
*/
printk ( KERN_ALERT " bootmem alloc of %lu bytes failed! \n " , size ) ;
panic ( " Out of memory " ) ;
2006-04-07 21:49:21 +04:00
return NULL ;
}
2005-04-17 02:20:36 +04:00
2008-07-24 08:28:01 +04:00
/**
* __alloc_bootmem - allocate boot memory
* @ size : size of the request in bytes
* @ align : alignment of the region
* @ goal : preferred starting address of the region
*
* The goal is dropped if it can not be satisfied and the allocation will
* fall back to memory below @ goal .
*
* Allocation may happen on any node in the system .
*
* The function panics if the request can not be satisfied .
*/
2006-09-26 10:31:05 +04:00
void * __init __alloc_bootmem ( unsigned long size , unsigned long align ,
unsigned long goal )
2006-04-07 21:49:21 +04:00
{
2010-02-10 12:20:20 +03:00
unsigned long limit = 0 ;
# ifdef CONFIG_NO_BOOTMEM
limit = - 1UL ;
# endif
return ___alloc_bootmem ( size , align , goal , limit ) ;
2005-04-17 02:20:36 +04:00
}
2010-02-10 12:20:20 +03:00
# ifndef CONFIG_NO_BOOTMEM
2008-07-24 08:28:08 +04:00
static void * __init ___alloc_bootmem_node ( bootmem_data_t * bdata ,
unsigned long size , unsigned long align ,
unsigned long goal , unsigned long limit )
{
void * ptr ;
2009-03-01 10:06:56 +03:00
ptr = alloc_arch_preferred_bootmem ( bdata , size , align , goal , limit ) ;
if ( ptr )
return ptr ;
2008-07-24 08:28:08 +04:00
ptr = alloc_bootmem_core ( bdata , size , align , goal , limit ) ;
if ( ptr )
return ptr ;
return ___alloc_bootmem ( size , align , goal , limit ) ;
}
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:28:08 +04:00
2008-07-24 08:28:01 +04:00
/**
* __alloc_bootmem_node - allocate boot memory from a specific node
* @ pgdat : node to allocate from
* @ size : size of the request in bytes
* @ align : alignment of the region
* @ goal : preferred starting address of the region
*
* The goal is dropped if it can not be satisfied and the allocation will
* fall back to memory below @ goal .
*
* Allocation may fall back to any node in the system if the specified node
* can not hold the requested memory .
*
* The function panics if the request can not be satisfied .
*/
2006-09-26 10:31:05 +04:00
void * __init __alloc_bootmem_node ( pg_data_t * pgdat , unsigned long size ,
unsigned long align , unsigned long goal )
2005-04-17 02:20:36 +04:00
{
2009-06-11 09:10:28 +04:00
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc_node ( size , GFP_NOWAIT , pgdat - > node_id ) ;
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
return __alloc_memory_core_early ( pgdat - > node_id , size , align ,
goal , - 1ULL ) ;
# else
2008-07-24 08:28:08 +04:00
return ___alloc_bootmem_node ( pgdat - > bdata , size , align , goal , 0 ) ;
2010-02-10 12:20:20 +03:00
# endif
}
void * __init __alloc_bootmem_node_high ( pg_data_t * pgdat , unsigned long size ,
unsigned long align , unsigned long goal )
{
# ifdef MAX_DMA32_PFN
unsigned long end_pfn ;
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc_node ( size , GFP_NOWAIT , pgdat - > node_id ) ;
/* update goal according ...MAX_DMA32_PFN */
end_pfn = pgdat - > node_start_pfn + pgdat - > node_spanned_pages ;
if ( end_pfn > MAX_DMA32_PFN + ( 128 > > ( 20 - PAGE_SHIFT ) ) & &
( goal > > PAGE_SHIFT ) < MAX_DMA32_PFN ) {
void * ptr ;
unsigned long new_goal ;
new_goal = MAX_DMA32_PFN < < PAGE_SHIFT ;
# ifdef CONFIG_NO_BOOTMEM
ptr = __alloc_memory_core_early ( pgdat - > node_id , size , align ,
new_goal , - 1ULL ) ;
# else
ptr = alloc_bootmem_core ( pgdat - > bdata , size , align ,
new_goal , 0 ) ;
# endif
if ( ptr )
return ptr ;
}
# endif
return __alloc_bootmem_node ( pgdat , size , align , goal ) ;
2005-04-17 02:20:36 +04:00
}
2008-04-28 13:13:32 +04:00
# ifdef CONFIG_SPARSEMEM
2008-07-24 08:28:01 +04:00
/**
* alloc_bootmem_section - allocate boot memory from a specific section
* @ size : size of the request in bytes
* @ section_nr : sparse map section to allocate from
*
* Return NULL on failure .
*/
2008-04-28 13:13:32 +04:00
void * __init alloc_bootmem_section ( unsigned long size ,
unsigned long section_nr )
{
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
unsigned long pfn , goal , limit ;
pfn = section_nr_to_pfn ( section_nr ) ;
goal = pfn < < PAGE_SHIFT ;
limit = section_nr_to_pfn ( section_nr + 1 ) < < PAGE_SHIFT ;
return __alloc_memory_core_early ( early_pfn_to_nid ( pfn ) , size ,
SMP_CACHE_BYTES , goal , limit ) ;
# else
2008-07-24 08:28:09 +04:00
bootmem_data_t * bdata ;
unsigned long pfn , goal , limit ;
2008-04-28 13:13:32 +04:00
pfn = section_nr_to_pfn ( section_nr ) ;
2008-07-24 08:28:09 +04:00
goal = pfn < < PAGE_SHIFT ;
limit = section_nr_to_pfn ( section_nr + 1 ) < < PAGE_SHIFT ;
bdata = & bootmem_node_data [ early_pfn_to_nid ( pfn ) ] ;
2008-04-28 13:13:32 +04:00
2008-07-24 08:28:09 +04:00
return alloc_bootmem_core ( bdata , size , SMP_CACHE_BYTES , goal , limit ) ;
2010-02-10 12:20:20 +03:00
# endif
2008-04-28 13:13:32 +04:00
}
# endif
2008-07-24 08:27:45 +04:00
void * __init __alloc_bootmem_node_nopanic ( pg_data_t * pgdat , unsigned long size ,
unsigned long align , unsigned long goal )
{
void * ptr ;
2009-06-11 09:10:28 +04:00
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc_node ( size , GFP_NOWAIT , pgdat - > node_id ) ;
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
ptr = __alloc_memory_core_early ( pgdat - > node_id , size , align ,
goal , - 1ULL ) ;
# else
2009-03-01 10:06:56 +03:00
ptr = alloc_arch_preferred_bootmem ( pgdat - > bdata , size , align , goal , 0 ) ;
if ( ptr )
return ptr ;
2008-07-24 08:27:45 +04:00
ptr = alloc_bootmem_core ( pgdat - > bdata , size , align , goal , 0 ) ;
2010-02-10 12:20:20 +03:00
# endif
2008-07-24 08:27:45 +04:00
if ( ptr )
return ptr ;
return __alloc_bootmem_nopanic ( size , align , goal ) ;
}
2006-09-26 10:31:33 +04:00
# ifndef ARCH_LOW_ADDRESS_LIMIT
# define ARCH_LOW_ADDRESS_LIMIT 0xffffffffUL
# endif
2006-01-06 11:11:01 +03:00
2008-07-24 08:28:01 +04:00
/**
* __alloc_bootmem_low - allocate low boot memory
* @ size : size of the request in bytes
* @ align : alignment of the region
* @ goal : preferred starting address of the region
*
* The goal is dropped if it can not be satisfied and the allocation will
* fall back to memory below @ goal .
*
* Allocation may happen on any node in the system .
*
* The function panics if the request can not be satisfied .
*/
2006-09-26 10:31:05 +04:00
void * __init __alloc_bootmem_low ( unsigned long size , unsigned long align ,
unsigned long goal )
2006-01-06 11:11:01 +03:00
{
2008-07-24 08:28:07 +04:00
return ___alloc_bootmem ( size , align , goal , ARCH_LOW_ADDRESS_LIMIT ) ;
2006-01-06 11:11:01 +03:00
}
2008-07-24 08:28:01 +04:00
/**
* __alloc_bootmem_low_node - allocate low boot memory from a specific node
* @ pgdat : node to allocate from
* @ size : size of the request in bytes
* @ align : alignment of the region
* @ goal : preferred starting address of the region
*
* The goal is dropped if it can not be satisfied and the allocation will
* fall back to memory below @ goal .
*
* Allocation may fall back to any node in the system if the specified node
* can not hold the requested memory .
*
* The function panics if the request can not be satisfied .
*/
2006-01-06 11:11:01 +03:00
void * __init __alloc_bootmem_low_node ( pg_data_t * pgdat , unsigned long size ,
unsigned long align , unsigned long goal )
{
2009-06-11 09:10:28 +04:00
if ( WARN_ON_ONCE ( slab_is_available ( ) ) )
return kzalloc_node ( size , GFP_NOWAIT , pgdat - > node_id ) ;
2010-02-10 12:20:20 +03:00
# ifdef CONFIG_NO_BOOTMEM
return __alloc_memory_core_early ( pgdat - > node_id , size , align ,
goal , ARCH_LOW_ADDRESS_LIMIT ) ;
# else
2008-07-24 08:28:08 +04:00
return ___alloc_bootmem_node ( pgdat - > bdata , size , align ,
goal , ARCH_LOW_ADDRESS_LIMIT ) ;
2010-02-10 12:20:20 +03:00
# endif
2006-01-06 11:11:01 +03:00
}