Contributors: 2
Author Tokens Token Proportion Commits Commit Proportion
Karolina Drobnik 1044 82.99% 5 55.56%
Rebecca Mckeever 214 17.01% 4 44.44%
Total 1258 9 
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414
// 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(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(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;
}