Skip to content

Commit

Permalink
---
Browse files Browse the repository at this point in the history 
yaml
---
r: 212704
b: refs/heads/master
c: 6ed311b
h: refs/heads/master
v: v3
  • Loading branch information
Benjamin Herrenschmidt committed Aug 5, 2010
1 parent eb13386 commit 21c1a9e
Show file tree
Hide file tree
Showing 2 changed files with 160 additions and 143 deletions.
2 changes: 1 addition & 1 deletion [refs]
View file
Original file line number Diff line number Diff line change
@@ -1,2 +1,2 @@
---
refs/heads/master: 7f219c736f9439acb1c50d264fbee93c353773ca
refs/heads/master: 6ed311b282210d23d1a2cb2665aa899979993628
301 changes: 159 additions & 142 deletions trunk/mm/memblock.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,40 +24,18 @@ static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_REGIO

#define MEMBLOCK_ERROR (~(phys_addr_t)0)

static int __init early_memblock(char *p)
{
if (p && strstr(p, "debug"))
memblock_debug = 1;
return 0;
}
early_param("memblock", early_memblock);
/*
* Address comparison utilities
*/

static void memblock_dump(struct memblock_type *region, char *name)
static phys_addr_t memblock_align_down(phys_addr_t addr, phys_addr_t size)
{
unsigned long long base, size;
int i;

pr_info(" %s.cnt = 0x%lx\n", name, region->cnt);

for (i = 0; i < region->cnt; i++) {
base = region->regions[i].base;
size = region->regions[i].size;

pr_info(" %s[0x%x]\t0x%016llx - 0x%016llx, 0x%llx bytes\n",
name, i, base, base + size - 1, size);
}
return addr & ~(size - 1);
}

void memblock_dump_all(void)
static phys_addr_t memblock_align_up(phys_addr_t addr, phys_addr_t size)
{
if (!memblock_debug)
return;

pr_info("MEMBLOCK configuration:\n");
pr_info(" memory size = 0x%llx\n", (unsigned long long)memblock.memory_size);

memblock_dump(&memblock.memory, "memory");
memblock_dump(&memblock.reserved, "reserved");
return (addr + (size - 1)) & ~(size - 1);
}

static unsigned long memblock_addrs_overlap(phys_addr_t base1, phys_addr_t size1,
Expand Down Expand Up @@ -88,6 +66,77 @@ static long memblock_regions_adjacent(struct memblock_type *type,
return memblock_addrs_adjacent(base1, size1, base2, size2);
}

long memblock_overlaps_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
{
unsigned long i;

for (i = 0; i < type->cnt; i++) {
phys_addr_t rgnbase = type->regions[i].base;
phys_addr_t rgnsize = type->regions[i].size;
if (memblock_addrs_overlap(base, size, rgnbase, rgnsize))
break;
}

return (i < type->cnt) ? i : -1;
}

/*
* Find, allocate, deallocate or reserve unreserved regions. All allocations
* are top-down.
*/

static phys_addr_t __init memblock_find_region(phys_addr_t start, phys_addr_t end,
phys_addr_t size, phys_addr_t align)
{
phys_addr_t base, res_base;
long j;

base = memblock_align_down((end - size), align);
while (start <= base) {
j = memblock_overlaps_region(&memblock.reserved, base, size);
if (j < 0)
return base;
res_base = memblock.reserved.regions[j].base;
if (res_base < size)
break;
base = memblock_align_down(res_base - size, align);
}

return MEMBLOCK_ERROR;
}

static phys_addr_t __init memblock_find_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
long i;
phys_addr_t base = 0;
phys_addr_t res_base;

BUG_ON(0 == size);

size = memblock_align_up(size, align);

/* Pump up max_addr */
if (max_addr == MEMBLOCK_ALLOC_ACCESSIBLE)
max_addr = memblock.current_limit;

/* We do a top-down search, this tends to limit memory
* fragmentation by keeping early boot allocs near the
* top of memory
*/
for (i = memblock.memory.cnt - 1; i >= 0; i--) {
phys_addr_t memblockbase = memblock.memory.regions[i].base;
phys_addr_t memblocksize = memblock.memory.regions[i].size;

if (memblocksize < size)
continue;
base = min(memblockbase + memblocksize, max_addr);
res_base = memblock_find_region(memblockbase, base, size, align);
if (res_base != MEMBLOCK_ERROR)
return res_base;
}
return MEMBLOCK_ERROR;
}

static void memblock_remove_region(struct memblock_type *type, unsigned long r)
{
unsigned long i;
Expand All @@ -107,22 +156,6 @@ static void memblock_coalesce_regions(struct memblock_type *type,
memblock_remove_region(type, r2);
}

void __init memblock_analyze(void)
{
int i;

/* Check marker in the unused last array entry */
WARN_ON(memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS].base
!= (phys_addr_t)RED_INACTIVE);
WARN_ON(memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS].base
!= (phys_addr_t)RED_INACTIVE);

memblock.memory_size = 0;

for (i = 0; i < memblock.memory.cnt; i++)
memblock.memory_size += memblock.memory.regions[i].size;
}

static long memblock_add_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
{
unsigned long coalesced = 0;
Expand Down Expand Up @@ -260,49 +293,47 @@ long __init memblock_reserve(phys_addr_t base, phys_addr_t size)
return memblock_add_region(_rgn, base, size);
}

long memblock_overlaps_region(struct memblock_type *type, phys_addr_t base, phys_addr_t size)
phys_addr_t __init __memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
unsigned long i;
phys_addr_t found;

for (i = 0; i < type->cnt; i++) {
phys_addr_t rgnbase = type->regions[i].base;
phys_addr_t rgnsize = type->regions[i].size;
if (memblock_addrs_overlap(base, size, rgnbase, rgnsize))
break;
}
/* We align the size to limit fragmentation. Without this, a lot of
* small allocs quickly eat up the whole reserve array on sparc
*/
size = memblock_align_up(size, align);

return (i < type->cnt) ? i : -1;
}
found = memblock_find_base(size, align, max_addr);
if (found != MEMBLOCK_ERROR &&
memblock_add_region(&memblock.reserved, found, size) >= 0)
return found;

static phys_addr_t memblock_align_down(phys_addr_t addr, phys_addr_t size)
{
return addr & ~(size - 1);
return 0;
}

static phys_addr_t memblock_align_up(phys_addr_t addr, phys_addr_t size)
phys_addr_t __init memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
return (addr + (size - 1)) & ~(size - 1);
phys_addr_t alloc;

alloc = __memblock_alloc_base(size, align, max_addr);

if (alloc == 0)
panic("ERROR: Failed to allocate 0x%llx bytes below 0x%llx.\n",
(unsigned long long) size, (unsigned long long) max_addr);

return alloc;
}

static phys_addr_t __init memblock_find_region(phys_addr_t start, phys_addr_t end,
phys_addr_t size, phys_addr_t align)
phys_addr_t __init memblock_alloc(phys_addr_t size, phys_addr_t align)
{
phys_addr_t base, res_base;
long j;
return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
}

base = memblock_align_down((end - size), align);
while (start <= base) {
j = memblock_overlaps_region(&memblock.reserved, base, size);
if (j < 0)
return base;
res_base = memblock.reserved.regions[j].base;
if (res_base < size)
break;
base = memblock_align_down(res_base - size, align);
}

return MEMBLOCK_ERROR;
}
/*
* Additional node-local allocators. Search for node memory is bottom up
* and walks memblock regions within that node bottom-up as well, but allocation
* within an memblock region is top-down.
*/

phys_addr_t __weak __init memblock_nid_range(phys_addr_t start, phys_addr_t end, int *nid)
{
Expand Down Expand Up @@ -364,72 +395,6 @@ phys_addr_t __init memblock_alloc_nid(phys_addr_t size, phys_addr_t align, int n
return memblock_alloc(size, align);
}

phys_addr_t __init memblock_alloc(phys_addr_t size, phys_addr_t align)
{
return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
}

static phys_addr_t __init memblock_find_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
long i;
phys_addr_t base = 0;
phys_addr_t res_base;

BUG_ON(0 == size);

/* Pump up max_addr */
if (max_addr == MEMBLOCK_ALLOC_ACCESSIBLE)
max_addr = memblock.current_limit;

/* We do a top-down search, this tends to limit memory
* fragmentation by keeping early boot allocs near the
* top of memory
*/
for (i = memblock.memory.cnt - 1; i >= 0; i--) {
phys_addr_t memblockbase = memblock.memory.regions[i].base;
phys_addr_t memblocksize = memblock.memory.regions[i].size;

if (memblocksize < size)
continue;
base = min(memblockbase + memblocksize, max_addr);
res_base = memblock_find_region(memblockbase, base, size, align);
if (res_base != MEMBLOCK_ERROR)
return res_base;
}
return MEMBLOCK_ERROR;
}

phys_addr_t __init __memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
phys_addr_t found;

/* We align the size to limit fragmentation. Without this, a lot of
* small allocs quickly eat up the whole reserve array on sparc
*/
size = memblock_align_up(size, align);

found = memblock_find_base(size, align, max_addr);
if (found != MEMBLOCK_ERROR &&
memblock_add_region(&memblock.reserved, found, size) >= 0)
return found;

return 0;
}

phys_addr_t __init memblock_alloc_base(phys_addr_t size, phys_addr_t align, phys_addr_t max_addr)
{
phys_addr_t alloc;

alloc = __memblock_alloc_base(size, align, max_addr);

if (alloc == 0)
panic("ERROR: Failed to allocate 0x%llx bytes below 0x%llx.\n",
(unsigned long long) size, (unsigned long long) max_addr);

return alloc;
}


/* You must call memblock_analyze() before this. */
phys_addr_t __init memblock_phys_mem_size(void)
{
Expand Down Expand Up @@ -534,6 +499,50 @@ void __init memblock_set_current_limit(phys_addr_t limit)
memblock.current_limit = limit;
}

static void memblock_dump(struct memblock_type *region, char *name)
{
unsigned long long base, size;
int i;

pr_info(" %s.cnt = 0x%lx\n", name, region->cnt);

for (i = 0; i < region->cnt; i++) {
base = region->regions[i].base;
size = region->regions[i].size;

pr_info(" %s[0x%x]\t0x%016llx - 0x%016llx, 0x%llx bytes\n",
name, i, base, base + size - 1, size);
}
}

void memblock_dump_all(void)
{
if (!memblock_debug)
return;

pr_info("MEMBLOCK configuration:\n");
pr_info(" memory size = 0x%llx\n", (unsigned long long)memblock.memory_size);

memblock_dump(&memblock.memory, "memory");
memblock_dump(&memblock.reserved, "reserved");
}

void __init memblock_analyze(void)
{
int i;

/* Check marker in the unused last array entry */
WARN_ON(memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS].base
!= (phys_addr_t)RED_INACTIVE);
WARN_ON(memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS].base
!= (phys_addr_t)RED_INACTIVE);

memblock.memory_size = 0;

for (i = 0; i < memblock.memory.cnt; i++)
memblock.memory_size += memblock.memory.regions[i].size;
}

void __init memblock_init(void)
{
/* Hookup the initial arrays */
Expand Down Expand Up @@ -561,3 +570,11 @@ void __init memblock_init(void)
memblock.current_limit = MEMBLOCK_ALLOC_ANYWHERE;
}

static int __init early_memblock(char *p)
{
if (p && strstr(p, "debug"))
memblock_debug = 1;
return 0;
}
early_param("memblock", early_memblock);

0 comments on commit 21c1a9e

Please sign in to comment.