Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 12:42:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

mm/memblock: fix overlapping allocation when doubling reserved array

Browse Source 
__alloc_memory_core_early() asks memblock for a range of memory then try
to reserve it.  If the reserved region array lacks space for the new
range, memblock_double_array() is called to allocate more space for the
array.  If memblock is used to allocate memory for the new array it can
end up using a range that overlaps with the range originally allocated in
__alloc_memory_core_early(), leading to possible data corruption.

With this patch memblock_double_array() now calls memblock_find_in_range()
with a narrowed candidate range (in cases where the reserved.regions array
is being doubled) so any memory allocated will not overlap with the
original range that was being reserved.  The range is narrowed by passing
in the starting address and size of the previously allocated range.  Then
the range above the ending address is searched and if a candidate is not
found, the range below the starting address is searched.

Signed-off-by: Greg Pearson <greg.pearson@hp.com>
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Greg Pearson 2012-06-20 12:53:05 -07:00 committed by Linus Torvalds
parent 5702c5eeab
commit 48c3b583bb
1 changed files with 32 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
mm/memblock.c
View File

@ -184,7 +184,24 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
} }
} }
static int __init_memblock memblock_double_array(struct memblock_type *type) /**
* memblock_double_array - double the size of the memblock regions array
* @type: memblock type of the regions array being doubled
* @new_area_start: starting address of memory range to avoid overlap with
* @new_area_size: size of memory range to avoid overlap with
*
* Double the size of the @type regions array. If memblock is being used to
* allocate memory for a new reserved regions array and there is a previously
* allocated memory range [@new_area_start,@new_area_start+@new_area_size]
* waiting to be reserved, ensure the memory used by the new array does
* not overlap.
*
* RETURNS:
* 0 on success, -1 on failure.
*/
static int __init_memblock memblock_double_array(struct memblock_type *type,
phys_addr_t new_area_start,
phys_addr_t new_area_size)
{ {
struct memblock_region *new_array, *old_array; struct memblock_region *new_array, *old_array;
phys_addr_t old_size, new_size, addr; phys_addr_t old_size, new_size, addr;
@ -222,7 +239,18 @@ static int __init_memblock memblock_double_array(struct memblock_type *type)
new_array = kmalloc(new_size, GFP_KERNEL); new_array = kmalloc(new_size, GFP_KERNEL);
addr = new_array ? __pa(new_array) : 0; addr = new_array ? __pa(new_array) : 0;
} else { } else {
addr = memblock_find_in_range(0, MEMBLOCK_ALLOC_ACCESSIBLE, new_size, sizeof(phys_addr_t)); /* only exclude range when trying to double reserved.regions */
if (type != &memblock.reserved)
new_area_start = new_area_size = 0;
addr = memblock_find_in_range(new_area_start + new_area_size,
memblock.current_limit,
new_size, sizeof(phys_addr_t));
if (!addr && new_area_size)
addr = memblock_find_in_range(0,
min(new_area_start, memblock.current_limit),
new_size, sizeof(phys_addr_t));
new_array = addr ? __va(addr) : 0; new_array = addr ? __va(addr) : 0;
} }
if (!addr) { if (!addr) {
@ -399,7 +427,7 @@ repeat:
*/ */
if (!insert) { if (!insert) {
while (type->cnt + nr_new > type->max) while (type->cnt + nr_new > type->max)
if (memblock_double_array(type) < 0) if (memblock_double_array(type, obase, size) < 0)
return -ENOMEM; return -ENOMEM;
insert = true; insert = true;
goto repeat; goto repeat;
@ -450,7 +478,7 @@ static int __init_memblock memblock_isolate_range(struct memblock_type *type,
/* we'll create at most two more regions */ /* we'll create at most two more regions */
while (type->cnt + 2 > type->max) while (type->cnt + 2 > type->max)
if (memblock_double_array(type) < 0) if (memblock_double_array(type, base, size) < 0)
return -ENOMEM; return -ENOMEM;
for (i = 0; i < type->cnt; i++) { for (i = 0; i < type->cnt; i++) {