Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415// SPDX-License-Identifier: GPL-2.0-or-later#include "alloc_helpers_api.h"
/* * A simple test that tries to allocate a memory region above a specified, * aligned address: * * + * | +-----------+ | * | | rgn | | * +----------+-----------+---------+ * ^ * | * Aligned min_addr * * Expect to allocate a cleared region at the minimal memory address. */static int alloc_from_simple_generic_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t size = SZ_16; phys_addr_t min_addr;
PREFIX_PUSH(); setup_memblock();
min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_MEM_EQ(allocated_ptr, 0, size);
ASSERT_EQ(rgn->size, size); ASSERT_EQ(rgn->base, min_addr);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region above a certain address. * The minimal address here is not aligned: * * + + * | + +---------+ | * | | | rgn | | * +------+------+---------+------------+ * ^ ^------. * | | * min_addr Aligned address * boundary * * Expect to allocate a cleared region at the closest aligned memory address. */static int alloc_from_misaligned_generic_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t size = SZ_32; phys_addr_t min_addr;
PREFIX_PUSH(); setup_memblock();
/* A misaligned address */ min_addr = memblock_end_of_DRAM() - (SMP_CACHE_BYTES * 2 - 1);
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_MEM_EQ(allocated_ptr, 0, size);
ASSERT_EQ(rgn->size, size); ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region above an address that is too * close to the end of the memory: * * + + * | +--------+---+ | * | | rgn + | | * +-----------+--------+---+------+ * ^ ^ * | | * | min_addr * | * Aligned address * boundary * * Expect to prioritize granting memory over satisfying the minimal address * requirement. */static int alloc_from_top_down_high_addr_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t size = SZ_32; phys_addr_t min_addr;
PREFIX_PUSH(); setup_memblock();
/* The address is too close to the end of the memory */ min_addr = memblock_end_of_DRAM() - SZ_16;
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->size, size); ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region when there is no space * available above the minimal address above a certain address: * * + * | +---------+-------------| * | | rgn | | * +--------+---------+-------------+ * ^ * | * min_addr * * Expect to prioritize granting memory over satisfying the minimal address * requirement and to allocate next to the previously reserved region. The * regions get merged into one. */static int alloc_from_top_down_no_space_above_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t r1_size = SZ_64; phys_addr_t r2_size = SZ_2; phys_addr_t total_size = r1_size + r2_size; phys_addr_t min_addr;
PREFIX_PUSH(); setup_memblock();
min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
/* No space above this address */ memblock_reserve_kern(min_addr, r2_size);
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->base, min_addr - r1_size); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region with a minimal address below * the start address of the available memory. As the allocation is top-down, * first reserve a region that will force allocation near the start. * Expect successful allocation and merge of both regions. */static int alloc_from_top_down_min_addr_cap_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t r1_size = SZ_64; phys_addr_t min_addr; phys_addr_t start_addr;
PREFIX_PUSH(); setup_memblock();
start_addr = (phys_addr_t)memblock_start_of_DRAM(); min_addr = start_addr - SMP_CACHE_BYTES * 3;
memblock_reserve_kern(start_addr + r1_size, MEM_SIZE - r1_size);
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->base, start_addr); ASSERT_EQ(rgn->size, MEM_SIZE);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region above an address that is too * close to the end of the memory: * * + * |-----------+ + | * | rgn | | | * +-----------+--------------+-----+ * ^ ^ * | | * Aligned address min_addr * boundary * * Expect to prioritize granting memory over satisfying the minimal address * requirement. Allocation happens at beginning of the available memory. */static int alloc_from_bottom_up_high_addr_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t size = SZ_32; phys_addr_t min_addr;
PREFIX_PUSH(); setup_memblock();
/* The address is too close to the end of the memory */ min_addr = memblock_end_of_DRAM() - SZ_8;
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->size, size); ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region when there is no space * available above the minimal address above a certain address: * * + * |-----------+ +-------------------| * | rgn | | | * +-----------+----+-------------------+ * ^ * | * min_addr * * Expect to prioritize granting memory over satisfying the minimal address * requirement and to allocate at the beginning of the available memory. */static int alloc_from_bottom_up_no_space_above_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t r1_size = SZ_64; phys_addr_t min_addr; phys_addr_t r2_size;
PREFIX_PUSH(); setup_memblock();
min_addr = memblock_start_of_DRAM() + SZ_128; r2_size = memblock_end_of_DRAM() - min_addr;
/* No space above this address */ memblock_reserve(min_addr - SMP_CACHE_BYTES, r2_size);
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); ASSERT_EQ(rgn->size, r1_size);
ASSERT_EQ(memblock.reserved.cnt, 2); ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
test_pass_pop();
return 0;}
/* * A test that tries to allocate a memory region with a minimal address below * the start address of the available memory. Expect to allocate a region * at the beginning of the available memory. */static int alloc_from_bottom_up_min_addr_cap_check(void){ struct memblock_region *rgn = &memblock.reserved.regions[0]; void *allocated_ptr = NULL; phys_addr_t r1_size = SZ_64; phys_addr_t min_addr; phys_addr_t start_addr;
PREFIX_PUSH(); setup_memblock();
start_addr = (phys_addr_t)memblock_start_of_DRAM(); min_addr = start_addr - SMP_CACHE_BYTES * 3;
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
ASSERT_NE(allocated_ptr, NULL); ASSERT_EQ(rgn->base, start_addr); ASSERT_EQ(rgn->size, r1_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, r1_size);
test_pass_pop();
return 0;}
/* Test case wrappers */static int alloc_from_simple_check(void){ test_print("\tRunning %s...\n", __func__); run_top_down(alloc_from_simple_generic_check); run_bottom_up(alloc_from_simple_generic_check);
return 0;}
static int alloc_from_misaligned_check(void){ test_print("\tRunning %s...\n", __func__); run_top_down(alloc_from_misaligned_generic_check); run_bottom_up(alloc_from_misaligned_generic_check);
return 0;}
static int alloc_from_high_addr_check(void){ test_print("\tRunning %s...\n", __func__); memblock_set_bottom_up(false); alloc_from_top_down_high_addr_check(); memblock_set_bottom_up(true); alloc_from_bottom_up_high_addr_check();
return 0;}
static int alloc_from_no_space_above_check(void){ test_print("\tRunning %s...\n", __func__); memblock_set_bottom_up(false); alloc_from_top_down_no_space_above_check(); memblock_set_bottom_up(true); alloc_from_bottom_up_no_space_above_check();
return 0;}
static int alloc_from_min_addr_cap_check(void){ test_print("\tRunning %s...\n", __func__); memblock_set_bottom_up(false); alloc_from_top_down_min_addr_cap_check(); memblock_set_bottom_up(true); alloc_from_bottom_up_min_addr_cap_check();
return 0;}
int memblock_alloc_helpers_checks(void){ const char *func_testing = "memblock_alloc_from";
prefix_reset(); prefix_push(func_testing); test_print("Running %s tests...\n", func_testing);
reset_memblock_attributes(); dummy_physical_memory_init();
alloc_from_simple_check(); alloc_from_misaligned_check(); alloc_from_high_addr_check(); alloc_from_no_space_above_check(); alloc_from_min_addr_cap_check();
dummy_physical_memory_cleanup();
prefix_pop();
return 0;}