2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2008-07-23 22:28:00 -06:00
|
|
|
* bootmem - A boot-time physical memory allocator and configurator
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 1999 Ingo Molnar
|
2008-07-23 22:28:00 -06:00
|
|
|
* 1999 Kanoj Sarcar, SGI
|
|
|
|
* 2008 Johannes Weiner
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-07-23 22:28:00 -06:00
|
|
|
* Access to this subsystem has to be serialized externally (which is true
|
|
|
|
* for the boot process anyway).
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
2006-09-26 00:31:07 -06: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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/bootmem.h>
|
2011-10-16 00:01:52 -06:00
|
|
|
#include <linux/export.h>
|
2009-07-07 03:33:01 -06:00
|
|
|
#include <linux/kmemleak.h>
|
2010-02-10 02:20:20 -07:00
|
|
|
#include <linux/range.h>
|
2010-08-25 14:39:17 -06:00
|
|
|
#include <linux/memblock.h>
|
2006-09-26 00:31:06 -06:00
|
|
|
|
|
|
|
#include <asm/bug.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
2006-09-26 00:31:33 -06:00
|
|
|
#include <asm/processor.h>
|
2006-09-26 00:31:06 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "internal.h"
|
|
|
|
|
2011-02-24 06:43:06 -07:00
|
|
|
#ifndef CONFIG_NEED_MULTIPLE_NODES
|
|
|
|
struct pglist_data __refdata contig_page_data = {
|
|
|
|
.bdata = &bootmem_node_data[0]
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(contig_page_data);
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long max_low_pfn;
|
|
|
|
unsigned long min_low_pfn;
|
|
|
|
unsigned long max_pfn;
|
|
|
|
|
2008-07-23 22:26:55 -06:00
|
|
|
bootmem_data_t bootmem_node_data[MAX_NUMNODES] __initdata;
|
|
|
|
|
2008-07-23 22:28:03 -06:00
|
|
|
static struct list_head bdata_list __initdata = LIST_HEAD_INIT(bdata_list);
|
|
|
|
|
2008-07-23 22:28:02 -06: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-15 23:01:25 -06:00
|
|
|
__func__, ## args); \
|
2008-07-23 22:28:02 -06:00
|
|
|
})
|
|
|
|
|
2008-07-23 22:28:02 -06:00
|
|
|
static unsigned long __init bootmap_bytes(unsigned long pages)
|
2008-07-23 22:28:00 -06:00
|
|
|
{
|
2012-01-10 16:08:00 -07:00
|
|
|
unsigned long bytes = DIV_ROUND_UP(pages, 8);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:02 -06:00
|
|
|
return ALIGN(bytes, sizeof(long));
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06:00
|
|
|
/**
|
|
|
|
* bootmem_bootmap_pages - calculate bitmap size in pages
|
|
|
|
* @pages: number of pages the bitmap has to represent
|
|
|
|
*/
|
2006-09-26 00:31:08 -06:00
|
|
|
unsigned long __init bootmem_bootmap_pages(unsigned long pages)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-23 22:28:02 -06:00
|
|
|
unsigned long bytes = bootmap_bytes(pages);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:02 -06:00
|
|
|
return PAGE_ALIGN(bytes) >> PAGE_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-09-26 00:31:08 -06:00
|
|
|
|
2006-03-27 02:15:58 -07:00
|
|
|
/*
|
|
|
|
* link bdata in order
|
|
|
|
*/
|
2006-09-26 00:31:04 -06:00
|
|
|
static void __init link_bootmem(bootmem_data_t *bdata)
|
2006-03-27 02:15:58 -07:00
|
|
|
{
|
2012-05-29 16:06:46 -06:00
|
|
|
bootmem_data_t *ent;
|
2006-09-26 00:31:08 -06:00
|
|
|
|
2012-05-29 16:06:46 -06:00
|
|
|
list_for_each_entry(ent, &bdata_list, list) {
|
|
|
|
if (bdata->node_min_pfn < ent->node_min_pfn) {
|
|
|
|
list_add_tail(&bdata->list, &ent->list);
|
|
|
|
return;
|
|
|
|
}
|
2006-03-27 02:15:58 -07:00
|
|
|
}
|
2012-05-29 16:06:46 -06:00
|
|
|
|
|
|
|
list_add_tail(&bdata->list, &bdata_list);
|
2006-03-27 02:15:58 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Called once to set up the allocator itself.
|
|
|
|
*/
|
2008-07-23 22:26:59 -06:00
|
|
|
static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long mapstart, unsigned long start, unsigned long end)
|
|
|
|
{
|
2006-09-26 00:31:07 -06:00
|
|
|
unsigned long mapsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:26:52 -06:00
|
|
|
mminit_validate_memmodel_limits(&start, &end);
|
2006-09-26 00:31:07 -06:00
|
|
|
bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
|
2008-07-23 22:28:09 -06:00
|
|
|
bdata->node_min_pfn = start;
|
2005-04-16 16:20:36 -06:00
|
|
|
bdata->node_low_pfn = end;
|
2006-03-27 02:15:58 -07:00
|
|
|
link_bootmem(bdata);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initially all pages are reserved - setup_arch() has to
|
|
|
|
* register free RAM areas explicitly.
|
|
|
|
*/
|
2008-07-23 22:28:02 -06:00
|
|
|
mapsize = bootmap_bytes(end - start);
|
2005-04-16 16:20:36 -06:00
|
|
|
memset(bdata->node_bootmem_map, 0xff, mapsize);
|
|
|
|
|
2008-07-23 22:28:02 -06:00
|
|
|
bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",
|
|
|
|
bdata - bootmem_node_data, start, mapstart, end, mapsize);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return mapsize;
|
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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-23 22:28:00 -06: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-23 22:28:01 -06: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-23 22:28:00 -06: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);
|
|
|
|
}
|
2011-02-24 06:43:05 -07:00
|
|
|
|
2009-11-10 03:46:17 -07:00
|
|
|
/*
|
|
|
|
* free_bootmem_late - free bootmem pages directly to page allocator
|
2012-12-11 17:03:10 -07:00
|
|
|
* @addr: starting physical address of the range
|
2009-11-10 03:46:17 -07:00
|
|
|
* @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.
|
|
|
|
*/
|
2012-12-11 17:03:10 -07:00
|
|
|
void __init free_bootmem_late(unsigned long physaddr, unsigned long size)
|
2009-11-10 03:46:17 -07:00
|
|
|
{
|
|
|
|
unsigned long cursor, end;
|
|
|
|
|
2012-12-11 17:03:10 -07:00
|
|
|
kmemleak_free_part(__va(physaddr), size);
|
2009-11-10 03:46:17 -07:00
|
|
|
|
2012-12-11 17:03:10 -07:00
|
|
|
cursor = PFN_UP(physaddr);
|
|
|
|
end = PFN_DOWN(physaddr + size);
|
2009-11-10 03:46:17 -07:00
|
|
|
|
|
|
|
for (; cursor < end; cursor++) {
|
|
|
|
__free_pages_bootmem(pfn_to_page(cursor), 0);
|
|
|
|
totalram_pages++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:00 -06:00
|
|
|
static unsigned long __init free_all_bootmem_core(bootmem_data_t *bdata)
|
|
|
|
{
|
|
|
|
struct page *page;
|
2008-07-23 22:28:03 -06:00
|
|
|
unsigned long start, end, pages, count = 0;
|
|
|
|
|
|
|
|
if (!bdata->node_bootmem_map)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-23 22:28:09 -06:00
|
|
|
start = bdata->node_min_pfn;
|
2008-07-23 22:28:03 -06:00
|
|
|
end = bdata->node_low_pfn;
|
|
|
|
|
2012-01-10 16:08:15 -07:00
|
|
|
bdebug("nid=%td start=%lx end=%lx\n",
|
|
|
|
bdata - bootmem_node_data, start, end);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:03 -06:00
|
|
|
while (start < end) {
|
|
|
|
unsigned long *map, idx, vec;
|
2013-01-11 15:31:52 -07:00
|
|
|
unsigned shift;
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:03 -06:00
|
|
|
map = bdata->node_bootmem_map;
|
2008-07-23 22:28:09 -06:00
|
|
|
idx = start - bdata->node_min_pfn;
|
2013-01-11 15:31:52 -07:00
|
|
|
shift = idx & (BITS_PER_LONG - 1);
|
|
|
|
/*
|
|
|
|
* vec holds at most BITS_PER_LONG map bits,
|
|
|
|
* bit 0 corresponds to start.
|
|
|
|
*/
|
2008-07-23 22:28:03 -06:00
|
|
|
vec = ~map[idx / BITS_PER_LONG];
|
2013-01-11 15:31:52 -07:00
|
|
|
|
|
|
|
if (shift) {
|
|
|
|
vec >>= shift;
|
|
|
|
if (end - start >= BITS_PER_LONG)
|
|
|
|
vec |= ~map[idx / BITS_PER_LONG + 1] <<
|
|
|
|
(BITS_PER_LONG - shift);
|
|
|
|
}
|
2012-01-10 16:08:15 -07:00
|
|
|
/*
|
|
|
|
* If we have a properly aligned and fully unreserved
|
|
|
|
* BITS_PER_LONG block of pages in front of us, free
|
|
|
|
* it in one go.
|
|
|
|
*/
|
|
|
|
if (IS_ALIGNED(start, BITS_PER_LONG) && vec == ~0UL) {
|
2008-07-23 22:28:03 -06:00
|
|
|
int order = ilog2(BITS_PER_LONG);
|
|
|
|
|
|
|
|
__free_pages_bootmem(pfn_to_page(start), order);
|
2008-07-23 22:28:00 -06:00
|
|
|
count += BITS_PER_LONG;
|
2012-01-10 16:08:15 -07:00
|
|
|
start += BITS_PER_LONG;
|
2008-07-23 22:28:03 -06:00
|
|
|
} else {
|
2013-01-11 15:31:52 -07:00
|
|
|
unsigned long cur = start;
|
2008-07-23 22:28:03 -06:00
|
|
|
|
2013-01-11 15:31:52 -07:00
|
|
|
start = ALIGN(start + 1, BITS_PER_LONG);
|
|
|
|
while (vec && cur != start) {
|
2008-07-23 22:28:03 -06:00
|
|
|
if (vec & 1) {
|
2013-01-11 15:31:52 -07:00
|
|
|
page = pfn_to_page(cur);
|
2008-07-23 22:28:00 -06:00
|
|
|
__free_pages_bootmem(page, 0);
|
2008-07-23 22:28:03 -06:00
|
|
|
count++;
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
2008-07-23 22:28:03 -06:00
|
|
|
vec >>= 1;
|
2013-01-11 15:31:52 -07:00
|
|
|
++cur;
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
page = virt_to_page(bdata->node_bootmem_map);
|
2008-07-23 22:28:09 -06:00
|
|
|
pages = bdata->node_low_pfn - bdata->node_min_pfn;
|
2008-07-23 22:28:03 -06:00
|
|
|
pages = bootmem_bootmap_pages(pages);
|
|
|
|
count += pages;
|
2012-11-16 15:15:06 -07:00
|
|
|
while (pages--)
|
2008-07-23 22:28:03 -06:00
|
|
|
__free_pages_bootmem(page++, 0);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:02 -06:00
|
|
|
bdebug("nid=%td released=%lx\n", bdata - bootmem_node_data, count);
|
|
|
|
|
2008-07-23 22:28:00 -06:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2012-12-12 14:52:12 -07:00
|
|
|
static void reset_node_lowmem_managed_pages(pg_data_t *pgdat)
|
|
|
|
{
|
|
|
|
struct zone *z;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In free_area_init_core(), highmem zone's managed_pages is set to
|
|
|
|
* present_pages, and bootmem allocator doesn't allocate from highmem
|
|
|
|
* zones. So there's no need to recalculate managed_pages because all
|
|
|
|
* highmem pages will be managed by the buddy system. Here highmem
|
|
|
|
* zone also includes highmem movable zone.
|
|
|
|
*/
|
|
|
|
for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
|
|
|
|
if (!is_highmem(z))
|
|
|
|
z->managed_pages = 0;
|
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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-23 22:28:00 -06:00
|
|
|
unsigned long __init free_all_bootmem_node(pg_data_t *pgdat)
|
|
|
|
{
|
|
|
|
register_page_bootmem_info_node(pgdat);
|
2012-12-12 14:52:12 -07:00
|
|
|
reset_node_lowmem_managed_pages(pgdat);
|
2008-07-23 22:28:00 -06:00
|
|
|
return free_all_bootmem_core(pgdat->bdata);
|
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06:00
|
|
|
/**
|
|
|
|
* free_all_bootmem - release free pages to the buddy allocator
|
|
|
|
*
|
|
|
|
* Returns the number of pages actually released.
|
|
|
|
*/
|
2008-07-23 22:28:00 -06:00
|
|
|
unsigned long __init free_all_bootmem(void)
|
|
|
|
{
|
2010-03-31 21:45:27 -06:00
|
|
|
unsigned long total_pages = 0;
|
|
|
|
bootmem_data_t *bdata;
|
2012-12-12 14:52:12 -07:00
|
|
|
struct pglist_data *pgdat;
|
|
|
|
|
|
|
|
for_each_online_pgdat(pgdat)
|
|
|
|
reset_node_lowmem_managed_pages(pgdat);
|
2010-03-31 21:45:27 -06:00
|
|
|
|
|
|
|
list_for_each_entry(bdata, &bdata_list, list)
|
|
|
|
total_pages += free_all_bootmem_core(bdata);
|
|
|
|
|
|
|
|
return total_pages;
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:05 -06: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-23 22:28:09 -06:00
|
|
|
sidx + bdata->node_min_pfn,
|
|
|
|
eidx + bdata->node_min_pfn);
|
2008-07-23 22:28:05 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
if (bdata->hint_idx > sidx)
|
|
|
|
bdata->hint_idx = sidx;
|
|
|
|
|
2008-07-23 22:28:05 -06: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-23 22:28:09 -06:00
|
|
|
sidx + bdata->node_min_pfn,
|
|
|
|
eidx + bdata->node_min_pfn,
|
2008-07-23 22:28:05 -06: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-23 22:28:09 -06:00
|
|
|
idx + bdata->node_min_pfn);
|
2008-07-23 22:28:05 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
static int __init mark_bootmem_node(bootmem_data_t *bdata,
|
|
|
|
unsigned long start, unsigned long end,
|
|
|
|
int reserve, int flags)
|
2008-07-23 22:28:00 -06:00
|
|
|
{
|
|
|
|
unsigned long sidx, eidx;
|
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",
|
|
|
|
bdata - bootmem_node_data, start, end, reserve, flags);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:09 -06:00
|
|
|
BUG_ON(start < bdata->node_min_pfn);
|
2008-07-23 22:28:06 -06:00
|
|
|
BUG_ON(end > bdata->node_low_pfn);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:09 -06:00
|
|
|
sidx = start - bdata->node_min_pfn;
|
|
|
|
eidx = end - bdata->node_min_pfn;
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
if (reserve)
|
|
|
|
return __reserve(bdata, sidx, eidx, flags);
|
2008-07-23 22:28:00 -06:00
|
|
|
else
|
2008-07-23 22:28:06 -06: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-23 22:28:09 -06:00
|
|
|
if (pos < bdata->node_min_pfn ||
|
|
|
|
pos >= bdata->node_low_pfn) {
|
2008-07-23 22:28:06 -06:00
|
|
|
BUG_ON(pos != start);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
max = min(bdata->node_low_pfn, end);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
err = mark_bootmem_node(bdata, pos, max, reserve, flags);
|
|
|
|
if (reserve && err) {
|
|
|
|
mark_bootmem(start, pos, 0, 0);
|
|
|
|
return err;
|
|
|
|
}
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
if (max == end)
|
|
|
|
return 0;
|
|
|
|
pos = bdata->node_low_pfn;
|
|
|
|
}
|
|
|
|
BUG();
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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-23 22:28:06 -06:00
|
|
|
* The range must reside completely on the specified node.
|
2008-07-23 22:28:01 -06:00
|
|
|
*/
|
2008-07-23 22:28:00 -06:00
|
|
|
void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
2008-07-23 22:28:06 -06:00
|
|
|
unsigned long start, end;
|
|
|
|
|
2009-07-07 03:33:01 -06:00
|
|
|
kmemleak_free_part(__va(physaddr), size);
|
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
start = PFN_UP(physaddr);
|
|
|
|
end = PFN_DOWN(physaddr + size);
|
|
|
|
|
|
|
|
mark_bootmem_node(pgdat->bdata, start, end, 0, 0);
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06:00
|
|
|
/**
|
|
|
|
* free_bootmem - mark a page range as usable
|
2012-12-11 17:03:10 -07:00
|
|
|
* @addr: starting physical address of the range
|
2008-07-23 22:28:01 -06:00
|
|
|
* @size: size of the range in bytes
|
|
|
|
*
|
|
|
|
* Partial pages will be considered reserved and left as they are.
|
|
|
|
*
|
2008-07-23 22:28:06 -06:00
|
|
|
* The range must be contiguous but may span node boundaries.
|
2008-07-23 22:28:01 -06:00
|
|
|
*/
|
2012-12-11 17:03:10 -07:00
|
|
|
void __init free_bootmem(unsigned long physaddr, unsigned long size)
|
2008-07-23 22:28:00 -06:00
|
|
|
{
|
2008-07-23 22:28:06 -06:00
|
|
|
unsigned long start, end;
|
2008-03-18 13:49:12 -06:00
|
|
|
|
2012-12-11 17:03:10 -07:00
|
|
|
kmemleak_free_part(__va(physaddr), size);
|
2009-07-07 03:33:01 -06:00
|
|
|
|
2012-12-11 17:03:10 -07:00
|
|
|
start = PFN_UP(physaddr);
|
|
|
|
end = PFN_DOWN(physaddr + size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
mark_bootmem(start, end, 0, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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-23 22:28:06 -06:00
|
|
|
* The range must reside completely on the specified node.
|
2008-07-23 22:28:01 -06:00
|
|
|
*/
|
2008-07-23 22:28:00 -06:00
|
|
|
int __init reserve_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
|
|
|
|
unsigned long size, int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-23 22:28:06 -06:00
|
|
|
unsigned long start, end;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
start = PFN_DOWN(physaddr);
|
|
|
|
end = PFN_UP(physaddr + size);
|
|
|
|
|
|
|
|
return mark_bootmem_node(pgdat->bdata, start, end, 1, flags);
|
2008-07-23 22:28:00 -06:00
|
|
|
}
|
2008-03-24 13:29:45 -06:00
|
|
|
|
2008-07-23 22:28:01 -06:00
|
|
|
/**
|
2012-08-24 11:09:31 -06:00
|
|
|
* reserve_bootmem - mark a page range as reserved
|
2008-07-23 22:28:01 -06:00
|
|
|
* @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-23 22:28:06 -06:00
|
|
|
* The range must be contiguous but may span node boundaries.
|
2008-07-23 22:28:01 -06:00
|
|
|
*/
|
2008-07-23 22:28:00 -06:00
|
|
|
int __init reserve_bootmem(unsigned long addr, unsigned long size,
|
|
|
|
int flags)
|
|
|
|
{
|
2008-07-23 22:28:06 -06:00
|
|
|
unsigned long start, end;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
start = PFN_DOWN(addr);
|
|
|
|
end = PFN_UP(addr + size);
|
2008-07-23 22:28:00 -06:00
|
|
|
|
2008-07-23 22:28:06 -06:00
|
|
|
return mark_bootmem(start, end, 1, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-12-14 18:59:46 -07:00
|
|
|
static unsigned long __init align_idx(struct bootmem_data *bdata,
|
|
|
|
unsigned long idx, unsigned long step)
|
2008-08-20 15:09:15 -06: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-14 18:59:46 -07:00
|
|
|
static unsigned long __init align_off(struct bootmem_data *bdata,
|
|
|
|
unsigned long off, unsigned long align)
|
2008-08-20 15:09:15 -06:00
|
|
|
{
|
|
|
|
unsigned long base = PFN_PHYS(bdata->node_min_pfn);
|
|
|
|
|
|
|
|
/* Same as align_idx for byte offsets */
|
|
|
|
|
|
|
|
return ALIGN(base + off, align) - base;
|
|
|
|
}
|
|
|
|
|
2012-05-29 16:06:33 -06:00
|
|
|
static void * __init alloc_bootmem_bdata(struct bootmem_data *bdata,
|
2009-03-01 00:06:56 -07:00
|
|
|
unsigned long size, unsigned long align,
|
|
|
|
unsigned long goal, unsigned long limit)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-23 22:28:07 -06:00
|
|
|
unsigned long fallback = 0;
|
2008-07-23 22:28:05 -06:00
|
|
|
unsigned long min, max, start, sidx, midx, step;
|
|
|
|
|
2009-01-06 15:40:32 -07: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-23 22:28:05 -06:00
|
|
|
BUG_ON(!size);
|
|
|
|
BUG_ON(align & (align - 1));
|
|
|
|
BUG_ON(limit && goal + size > limit);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-06 21:32:41 -07:00
|
|
|
if (!bdata->node_bootmem_map)
|
|
|
|
return NULL;
|
|
|
|
|
2008-07-23 22:28:09 -06:00
|
|
|
min = bdata->node_min_pfn;
|
2008-07-23 22:28:05 -06:00
|
|
|
max = bdata->node_low_pfn;
|
2008-03-18 13:44:48 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
goal >>= PAGE_SHIFT;
|
|
|
|
limit >>= PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (limit && max > limit)
|
|
|
|
max = limit;
|
|
|
|
if (max <= min)
|
2008-03-18 13:44:48 -06:00
|
|
|
return NULL;
|
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
step = max(align >> PAGE_SHIFT, 1UL);
|
2005-10-19 16:52:18 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
if (goal && min < goal && goal < max)
|
|
|
|
start = ALIGN(goal, step);
|
|
|
|
else
|
|
|
|
start = ALIGN(min, step);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-20 15:09:15 -06:00
|
|
|
sidx = start - bdata->node_min_pfn;
|
2008-07-23 22:28:09 -06:00
|
|
|
midx = max - bdata->node_min_pfn;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
if (bdata->hint_idx > sidx) {
|
2008-07-23 22:28:07 -06:00
|
|
|
/*
|
|
|
|
* Handle the valid case of sidx being zero and still
|
|
|
|
* catch the fallback below.
|
|
|
|
*/
|
|
|
|
fallback = sidx + 1;
|
2008-08-20 15:09:15 -06:00
|
|
|
sidx = align_idx(bdata, bdata->hint_idx, step);
|
2008-07-23 22:28:05 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:05 -06: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-20 15:09:15 -06:00
|
|
|
sidx = align_idx(bdata, sidx, step);
|
2008-07-23 22:28:05 -06:00
|
|
|
eidx = sidx + PFN_UP(size);
|
2008-03-11 00:23:42 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
if (sidx >= midx || eidx > midx)
|
2005-12-12 01:37:39 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
for (i = sidx; i < eidx; i++)
|
|
|
|
if (test_bit(i, bdata->node_bootmem_map)) {
|
2008-08-20 15:09:15 -06:00
|
|
|
sidx = align_idx(bdata, i, step);
|
2008-07-23 22:28:05 -06:00
|
|
|
if (sidx == i)
|
|
|
|
sidx += step;
|
|
|
|
goto find_block;
|
|
|
|
}
|
2005-04-16 16:20:36 -06: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 01:40:17 -06:00
|
|
|
if (bdata->last_end_off & (PAGE_SIZE - 1) &&
|
2008-07-23 22:28:05 -06:00
|
|
|
PFN_DOWN(bdata->last_end_off) + 1 == sidx)
|
2008-08-20 15:09:15 -06:00
|
|
|
start_off = align_off(bdata, bdata->last_end_off, align);
|
2008-07-23 22:28:05 -06: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-23 22:28:05 -06:00
|
|
|
if (__reserve(bdata, PFN_DOWN(start_off) + merge,
|
|
|
|
PFN_UP(end_off), BOOTMEM_EXCLUSIVE))
|
|
|
|
BUG();
|
2008-07-23 22:28:05 -06:00
|
|
|
|
2008-07-23 22:28:09 -06:00
|
|
|
region = phys_to_virt(PFN_PHYS(bdata->node_min_pfn) +
|
|
|
|
start_off);
|
2008-07-23 22:28:05 -06:00
|
|
|
memset(region, 0, size);
|
2009-08-27 07:29:17 -06: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-23 22:28:05 -06:00
|
|
|
return region;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:07 -06:00
|
|
|
if (fallback) {
|
2008-08-20 15:09:15 -06:00
|
|
|
sidx = align_idx(bdata, fallback - 1, step);
|
2008-07-23 22:28:07 -06:00
|
|
|
fallback = 0;
|
|
|
|
goto find_block;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-05-29 16:06:33 -06:00
|
|
|
static void * __init alloc_bootmem_core(unsigned long size,
|
2008-07-23 22:28:07 -06:00
|
|
|
unsigned long align,
|
|
|
|
unsigned long goal,
|
|
|
|
unsigned long limit)
|
|
|
|
{
|
|
|
|
bootmem_data_t *bdata;
|
2009-03-01 00:06:56 -07:00
|
|
|
void *region;
|
2008-07-23 22:28:07 -06:00
|
|
|
|
2012-12-12 14:50:43 -07:00
|
|
|
if (WARN_ON_ONCE(slab_is_available()))
|
|
|
|
return kzalloc(size, GFP_NOWAIT);
|
2008-07-23 22:28:07 -06:00
|
|
|
|
2009-03-01 00:06:56 -07:00
|
|
|
list_for_each_entry(bdata, &bdata_list, list) {
|
2008-07-23 22:28:07 -06:00
|
|
|
if (goal && bdata->node_low_pfn <= PFN_DOWN(goal))
|
|
|
|
continue;
|
2008-07-23 22:28:09 -06:00
|
|
|
if (limit && bdata->node_min_pfn >= PFN_DOWN(limit))
|
2008-07-23 22:28:07 -06:00
|
|
|
break;
|
|
|
|
|
2012-05-29 16:06:33 -06:00
|
|
|
region = alloc_bootmem_bdata(bdata, size, align, goal, limit);
|
2008-07-23 22:28:07 -06:00
|
|
|
if (region)
|
|
|
|
return region;
|
|
|
|
}
|
|
|
|
|
2012-05-29 16:06:33 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void * __init ___alloc_bootmem_nopanic(unsigned long size,
|
|
|
|
unsigned long align,
|
|
|
|
unsigned long goal,
|
|
|
|
unsigned long limit)
|
|
|
|
{
|
|
|
|
void *ptr;
|
|
|
|
|
|
|
|
restart:
|
|
|
|
ptr = alloc_bootmem_core(size, align, goal, limit);
|
|
|
|
if (ptr)
|
|
|
|
return ptr;
|
2008-07-23 22:28:05 -06:00
|
|
|
if (goal) {
|
|
|
|
goal = 0;
|
2008-07-23 22:28:07 -06:00
|
|
|
goto restart;
|
2008-07-23 22:28:05 -06:00
|
|
|
}
|
2008-07-23 22:28:02 -06:00
|
|
|
|
2008-07-23 22:28:05 -06:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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 00:31:05 -06:00
|
|
|
void * __init __alloc_bootmem_nopanic(unsigned long size, unsigned long align,
|
2008-07-23 22:28:07 -06:00
|
|
|
unsigned long goal)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-02-10 02:20:20 -07:00
|
|
|
unsigned long limit = 0;
|
|
|
|
|
|
|
|
return ___alloc_bootmem_nopanic(size, align, goal, limit);
|
2008-07-23 22:28:07 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:07 -06: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 11:49:21 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 22:28:01 -06: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 00:31:05 -06:00
|
|
|
void * __init __alloc_bootmem(unsigned long size, unsigned long align,
|
|
|
|
unsigned long goal)
|
2006-04-07 11:49:21 -06:00
|
|
|
{
|
2010-02-10 02:20:20 -07:00
|
|
|
unsigned long limit = 0;
|
|
|
|
|
|
|
|
return ___alloc_bootmem(size, align, goal, limit);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-07-11 15:02:53 -06:00
|
|
|
void * __init ___alloc_bootmem_node_nopanic(pg_data_t *pgdat,
|
2008-07-23 22:28:08 -06:00
|
|
|
unsigned long size, unsigned long align,
|
|
|
|
unsigned long goal, unsigned long limit)
|
|
|
|
{
|
|
|
|
void *ptr;
|
|
|
|
|
2012-12-12 14:50:43 -07:00
|
|
|
if (WARN_ON_ONCE(slab_is_available()))
|
|
|
|
return kzalloc(size, GFP_NOWAIT);
|
2012-05-29 16:06:34 -06:00
|
|
|
again:
|
2009-03-01 00:06:56 -07:00
|
|
|
|
2012-07-17 16:47:51 -06:00
|
|
|
/* do not panic in alloc_bootmem_bdata() */
|
|
|
|
if (limit && goal + size > limit)
|
|
|
|
limit = 0;
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
ptr = alloc_bootmem_bdata(pgdat->bdata, size, align, goal, limit);
|
2008-07-23 22:28:08 -06:00
|
|
|
if (ptr)
|
|
|
|
return ptr;
|
|
|
|
|
2012-05-29 16:06:34 -06:00
|
|
|
ptr = alloc_bootmem_core(size, align, goal, limit);
|
|
|
|
if (ptr)
|
|
|
|
return ptr;
|
|
|
|
|
|
|
|
if (goal) {
|
|
|
|
goal = 0;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2012-05-29 16:06:34 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void * __init __alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size,
|
|
|
|
unsigned long align, unsigned long goal)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(slab_is_available()))
|
|
|
|
return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
return ___alloc_bootmem_node_nopanic(pgdat, size, align, goal, 0);
|
2012-05-29 16:06:34 -06:00
|
|
|
}
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
void * __init ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
|
2012-05-29 16:06:34 -06:00
|
|
|
unsigned long align, unsigned long goal,
|
|
|
|
unsigned long limit)
|
|
|
|
{
|
|
|
|
void *ptr;
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
ptr = ___alloc_bootmem_node_nopanic(pgdat, size, align, goal, 0);
|
2012-05-29 16:06:34 -06:00
|
|
|
if (ptr)
|
|
|
|
return ptr;
|
|
|
|
|
2012-05-29 16:06:34 -06:00
|
|
|
printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size);
|
|
|
|
panic("Out of memory");
|
|
|
|
return NULL;
|
2008-07-23 22:28:08 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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 00:31:05 -06:00
|
|
|
void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
|
|
|
|
unsigned long align, unsigned long goal)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-06-10 23:10:28 -06:00
|
|
|
if (WARN_ON_ONCE(slab_is_available()))
|
|
|
|
return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
return ___alloc_bootmem_node(pgdat, size, align, goal, 0);
|
2010-02-10 02:20:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2012-05-29 16:06:33 -06:00
|
|
|
ptr = alloc_bootmem_bdata(pgdat->bdata, size, align,
|
2010-02-10 02:20:20 -07:00
|
|
|
new_goal, 0);
|
|
|
|
if (ptr)
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return __alloc_bootmem_node(pgdat, size, align, goal);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 00:31:33 -06:00
|
|
|
#ifndef ARCH_LOW_ADDRESS_LIMIT
|
|
|
|
#define ARCH_LOW_ADDRESS_LIMIT 0xffffffffUL
|
|
|
|
#endif
|
2006-01-06 01:11:01 -07:00
|
|
|
|
2008-07-23 22:28:01 -06: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 00:31:05 -06:00
|
|
|
void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
|
|
|
|
unsigned long goal)
|
2006-01-06 01:11:01 -07:00
|
|
|
{
|
2008-07-23 22:28:07 -06:00
|
|
|
return ___alloc_bootmem(size, align, goal, ARCH_LOW_ADDRESS_LIMIT);
|
2006-01-06 01:11:01 -07:00
|
|
|
}
|
|
|
|
|
2008-07-23 22:28:01 -06: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 01:11:01 -07:00
|
|
|
void * __init __alloc_bootmem_low_node(pg_data_t *pgdat, unsigned long size,
|
|
|
|
unsigned long align, unsigned long goal)
|
|
|
|
{
|
2009-06-10 23:10:28 -06:00
|
|
|
if (WARN_ON_ONCE(slab_is_available()))
|
|
|
|
return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
|
|
|
|
|
2012-05-29 16:06:36 -06:00
|
|
|
return ___alloc_bootmem_node(pgdat, size, align,
|
|
|
|
goal, ARCH_LOW_ADDRESS_LIMIT);
|
2006-01-06 01:11:01 -07:00
|
|
|
}
|