631 lines
19 KiB
C
631 lines
19 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
|
|
/*
|
|
* Include Unit Under Test source code directly instead of linking it.
|
|
* This will allow access to internal structures and data without having
|
|
* to extract them to another header file.
|
|
*/
|
|
#include "../lib/imd_cbmem.c"
|
|
|
|
#include <tests/test.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <commonlib/bsd/helpers.h>
|
|
#include <imd.h>
|
|
#include <cbmem.h>
|
|
#include <imd_private.h>
|
|
|
|
#include <tests/lib/imd_cbmem_data.h>
|
|
|
|
#define CBMEM_ENTRY_ID 0xA001
|
|
|
|
static void reset_imd(void)
|
|
{
|
|
imd.lg.limit = (uintptr_t)NULL;
|
|
imd.lg.r = NULL;
|
|
imd.sm.limit = (uintptr_t)NULL;
|
|
imd.sm.r = NULL;
|
|
|
|
cbmem_initialized = 0;
|
|
}
|
|
|
|
/* This implementation allows imd_cbmem module tests without linking lib/cbmem_common.c
|
|
Function indicates to each hook if cbmem is being recovered or not. */
|
|
void cbmem_run_init_hooks(int is_recovery)
|
|
{
|
|
function_called();
|
|
}
|
|
|
|
void *__wrap_cbmem_top_chipset(void)
|
|
{
|
|
return (void *)_cbmem_top_ptr;
|
|
}
|
|
|
|
static void *get_cbmem_ptr(void)
|
|
{
|
|
void *cbmem_top_ptr = (void *)_cbmem_top_ptr;
|
|
if (cbmem_top_ptr)
|
|
return cbmem_top_ptr - CBMEM_SIZE;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static void clear_cbmem(void)
|
|
{
|
|
void *ptr = get_cbmem_ptr();
|
|
if (ptr)
|
|
memset(ptr, 0, CBMEM_SIZE);
|
|
}
|
|
|
|
static void reset_and_clear_cbmem(void)
|
|
{
|
|
reset_imd();
|
|
clear_cbmem();
|
|
}
|
|
|
|
void prepare_simple_cbmem(void)
|
|
{
|
|
reset_and_clear_cbmem();
|
|
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
cbmem_initialize_empty();
|
|
|
|
cbmem_entry_add(CBMEM_ENTRY_1_ID, CBMEM_ENTRY_1_SIZE);
|
|
cbmem_entry_add(CBMEM_ENTRY_2_ID, CBMEM_ENTRY_2_SIZE);
|
|
|
|
cbmem_entry_add(CBMEM_ENTRY_SM_1_ID, CBMEM_ENTRY_SM_1_SIZE);
|
|
cbmem_entry_add(CBMEM_ENTRY_SM_2_ID, CBMEM_ENTRY_SM_2_SIZE);
|
|
}
|
|
|
|
static void test_cbmem_top(void **state)
|
|
{
|
|
cbmem_top_init_once();
|
|
|
|
if (ENV_ROMSTAGE)
|
|
assert_ptr_equal(cbmem_top_chipset(), cbmem_top());
|
|
|
|
if (ENV_POSTCAR || ENV_RAMSTAGE)
|
|
assert_ptr_equal((void *)_cbmem_top_ptr, cbmem_top());
|
|
}
|
|
|
|
static void test_cbmem_initialize_empty(void **state)
|
|
{
|
|
const struct cbmem_entry *found;
|
|
|
|
/* Expect clean call without recovery */
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
cbmem_initialize_empty();
|
|
|
|
found = cbmem_entry_find(SMALL_REGION_ID);
|
|
assert_non_null(found);
|
|
/* Check that cbmem has only root, large and small entry. */
|
|
assert_int_equal(2, ((struct imd_root *)imd.lg.r)->num_entries);
|
|
assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
|
|
}
|
|
|
|
static void test_cbmem_initialize_empty_id_size(void **state)
|
|
{
|
|
const struct cbmem_entry *entry1, *entry2;
|
|
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
|
|
entry1 = cbmem_entry_find(SMALL_REGION_ID);
|
|
entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);
|
|
|
|
assert_non_null(entry1);
|
|
assert_non_null(entry2);
|
|
assert_ptr_not_equal(entry1, entry2);
|
|
/* Check that cbmem has root, large, small entries
|
|
and entry with id passed to init function. */
|
|
assert_int_equal(3, ((struct imd_root *)imd.lg.r)->num_entries);
|
|
assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
|
|
}
|
|
|
|
static void test_cbmem_initialize(void **state)
|
|
{
|
|
int res;
|
|
|
|
/* Expect call to fail as there is no previous cbmem to recover */
|
|
res = cbmem_initialize();
|
|
assert_int_equal(1, res);
|
|
|
|
/* Create cbmem with few entries and check if initialization will recover */
|
|
prepare_simple_cbmem();
|
|
reset_imd();
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
res = cbmem_initialize();
|
|
assert_int_equal(0, res);
|
|
}
|
|
|
|
void test_cbmem_initialize_id_size_ramstage(void **state)
|
|
{
|
|
int res;
|
|
const struct cbmem_entry *entry1, *entry2;
|
|
|
|
/* Expect call to fail as there is no previous cbmem to recover */
|
|
res = cbmem_initialize_id_size(0, 0);
|
|
assert_int_equal(1, res);
|
|
|
|
reset_and_clear_cbmem();
|
|
|
|
res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
assert_int_equal(1, res);
|
|
|
|
/* Initialize empty cbmem with small region and check if next initialization
|
|
correctly recovers and creates its root entry with small region */
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
cbmem_initialize_empty_id_size(0, 0);
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
assert_int_equal(0, res);
|
|
|
|
entry1 = cbmem_entry_find(SMALL_REGION_ID);
|
|
entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);
|
|
assert_non_null(entry1);
|
|
assert_non_null(entry2);
|
|
assert_ptr_not_equal(entry1, entry2);
|
|
/* Check that cbmem has root, large, small entries and entry with id passed
|
|
to init function. */
|
|
assert_int_equal(3, ((struct imd_root *)imd.lg.r)->num_entries);
|
|
assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
|
|
}
|
|
|
|
void test_cbmem_initialize_id_size_romstage(void **state)
|
|
{
|
|
int res;
|
|
const struct cbmem_entry *entry1, *entry2;
|
|
|
|
/* Expect call to fail as there is no previous cbmem to recover */
|
|
res = cbmem_initialize_id_size(0, 0);
|
|
assert_int_equal(1, res);
|
|
|
|
/* Initialize empty cbmem with small region and check if next initialization
|
|
correctly recovers and creates its root entry with small region */
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
cbmem_initialize_empty_id_size(0, 0);
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
assert_int_equal(0, res);
|
|
|
|
entry1 = cbmem_entry_find(SMALL_REGION_ID);
|
|
assert_non_null(entry1);
|
|
|
|
/* Romstage locks imd cbmem initialization after recovery,
|
|
so entry with CBMEM_ENTRY_ID id is not present if it was not recovered. */
|
|
entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);
|
|
assert_null(entry2);
|
|
|
|
/* Initialize cbmem with few large and small entries */
|
|
prepare_simple_cbmem();
|
|
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
|
|
|
|
reset_imd();
|
|
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
assert_int_equal(0, res);
|
|
|
|
/* Initialization function should be able to recover entries left in cbmem
|
|
while having imd structure clean */
|
|
entry1 = cbmem_entry_find(SMALL_REGION_ID);
|
|
assert_non_null(entry1);
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
|
|
}
|
|
|
|
static void test_cbmem_recovery(void **state)
|
|
{
|
|
int is_wakeup = 1;
|
|
|
|
/* Reset imd, initialize cbmem and add entries for recovery */
|
|
prepare_simple_cbmem();
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
assert_int_equal(0, cbmem_recovery(is_wakeup));
|
|
|
|
/* Check that entries have been correctly recovered */
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
|
|
assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
|
|
|
|
is_wakeup = 0;
|
|
expect_function_call(cbmem_run_init_hooks);
|
|
assert_int_equal(0, cbmem_recovery(is_wakeup));
|
|
|
|
/* Check that after recovery with is_wakeup equal to 0 the cbmem is empty
|
|
and in initial state. */
|
|
assert_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
|
|
assert_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
|
|
assert_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
|
|
assert_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
|
|
/* Check that cbmem has root, large and small entry. */
|
|
assert_int_equal(2, ((struct imd_root *)imd.lg.r)->num_entries);
|
|
assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
|
|
}
|
|
|
|
static void test_cbmem_entry_add(void **state)
|
|
{
|
|
/* IDs used for testing. Don't have to be sequential.
|
|
Must not be equal to SMALL_REGION_ID. */
|
|
const int id1 = 0x10;
|
|
const int id2 = 0x11;
|
|
const int id3 = 0x12;
|
|
const struct cbmem_entry *entry1, *entry2;
|
|
const struct cbmem_entry *entry_ret2, *entry_ret3;
|
|
|
|
/* cbmem_run_init_hooks() will be called by init functions
|
|
but this test does not aim to check it */
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(id1, CBMEM_ROOT_SIZE);
|
|
|
|
/* Expect NULL while looking for nonexistent entries */
|
|
assert_null(cbmem_entry_find(id2));
|
|
assert_null(cbmem_entry_find(id3));
|
|
|
|
entry_ret2 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE);
|
|
/* Expect error when trying to add entry with zero size */
|
|
assert_null(cbmem_entry_add(id3, 0));
|
|
|
|
/* Check if entries have been added correctly and are not the same */
|
|
entry1 = cbmem_entry_find(id1);
|
|
entry2 = cbmem_entry_find(id2);
|
|
assert_non_null(entry1);
|
|
assert_non_null(entry2);
|
|
assert_ptr_not_equal(entry1, entry2);
|
|
assert_ptr_equal(entry_ret2, entry2);
|
|
|
|
/* Add entry again and make sure that it has been
|
|
found instead of creating again. */
|
|
entry_ret3 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE / 2);
|
|
assert_ptr_equal(entry_ret2, entry_ret3);
|
|
}
|
|
|
|
static void test_cbmem_add(void **state)
|
|
{
|
|
const int id0 = 0x55;
|
|
const int id1 = 0x66;
|
|
const int id2 = 0x77;
|
|
const int id3 = 0x88;
|
|
const int entry1_size = 0x2000;
|
|
const int entry2_size = 0x4d1;
|
|
const int entry3_size = 0x30;
|
|
void *entry1, *entry2, *entry3, *entry4;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(id1, entry1_size);
|
|
entry2 = cbmem_add(id2, entry2_size);
|
|
entry3 = cbmem_add(id3, entry3_size);
|
|
entry1 = cbmem_find(id1);
|
|
|
|
/* All pointers should be non-null and distinct. */
|
|
assert_non_null(entry1);
|
|
assert_non_null(entry2);
|
|
assert_non_null(entry3);
|
|
assert_ptr_not_equal(entry1, entry2);
|
|
assert_ptr_not_equal(entry1, entry3);
|
|
assert_ptr_not_equal(entry2, entry3);
|
|
|
|
/* Adding the same ID should yield the same entry pointer. */
|
|
entry4 = cbmem_add(id2, entry2_size);
|
|
assert_ptr_equal(entry2, entry4);
|
|
|
|
/* Expect error while trying to add range with zero size */
|
|
assert_null(cbmem_add(id0, 0));
|
|
}
|
|
|
|
static void test_cbmem_entry_find(void **state)
|
|
{
|
|
const int id1 = 0xA0;
|
|
const int id2 = 0xDD;
|
|
const int id3 = 0xBD;
|
|
const size_t entry1_size = CBMEM_ROOT_SIZE;
|
|
const size_t entry2_size = CBMEM_ROOT_SIZE / 2;
|
|
const size_t entry3_size = 6321;
|
|
const struct cbmem_entry *cbm_e1, *cbm_e2, *cbm_e3;
|
|
const struct cbmem_entry *entry1, *entry2, *entry3;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty();
|
|
cbm_e1 = cbmem_entry_add(id1, entry1_size);
|
|
cbm_e2 = cbmem_entry_add(id2, entry2_size);
|
|
cbm_e3 = cbmem_entry_add(id3, entry3_size);
|
|
|
|
/* Check pointers correctness and size for each entry */
|
|
entry1 = cbmem_entry_find(id1);
|
|
assert_ptr_equal(cbm_e1, entry1);
|
|
assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e1) % CBMEM_SM_ALIGN);
|
|
assert_int_equal(entry1_size, cbmem_entry_size(entry1));
|
|
|
|
entry2 = cbmem_entry_find(id2);
|
|
assert_ptr_equal(cbm_e2, entry2);
|
|
assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e2) % CBMEM_SM_ALIGN);
|
|
assert_int_equal(entry2_size, cbmem_entry_size(entry2));
|
|
|
|
entry3 = cbmem_entry_find(id3);
|
|
assert_ptr_equal(cbm_e3, entry3);
|
|
assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e3) % CBMEM_SM_ALIGN);
|
|
assert_int_equal(entry3_size, cbmem_entry_size(entry3));
|
|
}
|
|
|
|
static void test_cbmem_find(void **state)
|
|
{
|
|
const int id1 = 0x30;
|
|
const int id2 = 0x22;
|
|
const int id3 = 0x101;
|
|
void *cbm_e1, *cbm_e2, *entry1, *entry2;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty();
|
|
cbm_e1 = cbmem_add(id1, CBMEM_ROOT_SIZE);
|
|
cbm_e2 = cbmem_add(id2, CBMEM_ROOT_SIZE);
|
|
|
|
entry1 = cbmem_find(id1);
|
|
assert_non_null(entry1);
|
|
assert_ptr_equal(cbm_e1, entry1);
|
|
|
|
entry2 = cbmem_find(id2);
|
|
assert_non_null(entry2);
|
|
assert_ptr_equal(cbm_e2, entry2);
|
|
|
|
/* Expect error when looking for non-existent id */
|
|
assert_null(cbmem_find(id3));
|
|
}
|
|
|
|
static void test_cbmem_entry_remove(void **state)
|
|
{
|
|
const int id1 = 0x2D;
|
|
const int id2 = 0x3D;
|
|
const int id3 = 0x4D;
|
|
const struct cbmem_entry *cbm_e1, *cbm_e2;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty();
|
|
cbm_e1 = cbmem_entry_add(id1, CBMEM_ROOT_SIZE);
|
|
cbm_e2 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE);
|
|
|
|
/* Entries can be removed only in reverse order they have been added. */
|
|
assert_int_equal(-1, cbmem_entry_remove(cbm_e1));
|
|
assert_int_equal(0, cbmem_entry_remove(cbm_e2));
|
|
assert_int_equal(0, cbmem_entry_remove(cbm_e1));
|
|
|
|
/* Expect error when removing non-existent entry */
|
|
assert_int_equal(-1, cbmem_entry_remove(cbmem_entry_find(id3)));
|
|
}
|
|
|
|
static void test_cbmem_entry_size(void **state)
|
|
{
|
|
const int id1 = 0x4422;
|
|
const int id2 = 0x2137;
|
|
const int id3 = 0xb111;
|
|
const size_t size1 = CBMEM_ROOT_SIZE * 4;
|
|
const size_t size2 = 0x43;
|
|
const size_t size3 = CBMEM_ROOT_SIZE * 8 + 7;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(id1, size1);
|
|
assert_non_null(cbmem_entry_add(id2, size2));
|
|
assert_non_null(cbmem_entry_add(id3, size3));
|
|
|
|
/* Entry size needs not to be aligned.
|
|
It has to be the same as provided while adding it. */
|
|
assert_int_equal(size1, cbmem_entry_size(cbmem_entry_find(id1)));
|
|
assert_int_equal(size2, cbmem_entry_size(cbmem_entry_find(id2)));
|
|
assert_int_equal(size3, cbmem_entry_size(cbmem_entry_find(id3)));
|
|
}
|
|
|
|
static void test_cbmem_entry_start(void **state)
|
|
{
|
|
const int id1 = 0x62;
|
|
const int id2 = 0x26;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
cbmem_entry_find(CBMEM_ENTRY_ID);
|
|
cbmem_entry_add(id1, 0x40);
|
|
cbmem_entry_add(id2, CBMEM_ROOT_SIZE * 2);
|
|
|
|
/* Check if start address of found entry is the same
|
|
as the one returned by cbmem_find() function */
|
|
assert_ptr_equal(cbmem_find(CBMEM_ENTRY_ID),
|
|
cbmem_entry_start(cbmem_entry_find(CBMEM_ENTRY_ID)));
|
|
assert_ptr_equal(cbmem_find(id1), cbmem_entry_start(cbmem_entry_find(id1)));
|
|
assert_ptr_equal(cbmem_find(id2), cbmem_entry_start(cbmem_entry_find(id2)));
|
|
}
|
|
|
|
/* Reimplementation for testing purposes */
|
|
void bootmem_add_range(uint64_t start, uint64_t size,
|
|
const enum bootmem_type tag)
|
|
{
|
|
check_expected(start);
|
|
check_expected(size);
|
|
check_expected(tag);
|
|
}
|
|
|
|
static void test_cbmem_add_bootmem(void **state)
|
|
{
|
|
void *base_ptr = NULL;
|
|
size_t size = 0;
|
|
const int id1 = 0xCA;
|
|
const int id2 = 0xEA;
|
|
const int id3 = 0xDA;
|
|
const size_t size1 = 1024;
|
|
const size_t size2 = 128;
|
|
const size_t size3 = 8192;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
cbmem_entry_add(id1, size1);
|
|
cbmem_entry_add(id2, size2);
|
|
cbmem_entry_add(id3, size3);
|
|
|
|
cbmem_get_region(&base_ptr, &size);
|
|
assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);
|
|
|
|
expect_value(bootmem_add_range, start, base_ptr);
|
|
expect_value(bootmem_add_range, size, size);
|
|
expect_value(bootmem_add_range, tag, BM_MEM_TABLE);
|
|
cbmem_add_bootmem();
|
|
|
|
/* Check that adding bootmem does not change base or size of cbmem */
|
|
cbmem_get_region(&base_ptr, &size);
|
|
assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);
|
|
}
|
|
|
|
static void test_cbmem_get_region(void **state)
|
|
{
|
|
int i;
|
|
void *base_ptr = NULL;
|
|
size_t size = 0;
|
|
size_t size_counter = 0;
|
|
const size_t entry_size = 0x2000;
|
|
const size_t alloc_num = 32;
|
|
const size_t small_entry_size = 64;
|
|
const size_t small_alloc_num = 3;
|
|
|
|
ignore_function_calls(cbmem_run_init_hooks);
|
|
|
|
cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
|
|
|
|
/* Check size and base pointer for empty initialized cbmem */
|
|
cbmem_get_region(&base_ptr, &size);
|
|
assert_non_null(base_ptr);
|
|
assert_int_not_equal(0, size);
|
|
assert_int_equal(CBMEM_ROOT_SIZE + cbmem_overhead_size(), size);
|
|
assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);
|
|
|
|
/* Check for multiple big allocations */
|
|
for (i = 1; i <= alloc_num; ++i) {
|
|
const struct cbmem_entry *e = cbmem_entry_add(i, entry_size);
|
|
assert_non_null(e);
|
|
size_counter += cbmem_entry_size(e);
|
|
|
|
/* Check if size is correct after each big allocation */
|
|
cbmem_get_region(&base_ptr, &size);
|
|
assert_int_equal(size_counter + cbmem_overhead_size() + CBMEM_ROOT_SIZE, size);
|
|
}
|
|
|
|
/* Check for few small allocations. */
|
|
for (; i <= alloc_num + small_alloc_num; ++i) {
|
|
const struct cbmem_entry *e = cbmem_entry_add(i, small_entry_size);
|
|
assert_non_null(e);
|
|
|
|
/* Check if size is correct after each small allocation. It should not change
|
|
as small entries have their region allocated and entry size is selected
|
|
to fit in it couple of times */
|
|
cbmem_get_region(&base_ptr, &size);
|
|
assert_int_equal(size_counter + cbmem_overhead_size() + CBMEM_ROOT_SIZE, size);
|
|
}
|
|
}
|
|
|
|
static void test_general_data_structure(void **state)
|
|
{
|
|
/* Initialize cbmem with few big and small entries, then check if binary data structure
|
|
is the same as stored in array containing hardcoded dumped cbmem */
|
|
prepare_simple_cbmem();
|
|
assert_memory_equal(get_cbmem_ptr(), test_cbmem_data, CBMEM_SIZE);
|
|
}
|
|
|
|
static int setup_teardown_test_imd_cbmem(void **state)
|
|
{
|
|
reset_and_clear_cbmem();
|
|
return 0;
|
|
}
|
|
|
|
static int setup_group_imd_cbmem(void **state)
|
|
{
|
|
/* Allocate more data to have space for alignment */
|
|
void *top_ptr = malloc(CBMEM_SIZE + DYN_CBMEM_ALIGN_SIZE);
|
|
|
|
if (!top_ptr)
|
|
return -1;
|
|
|
|
*state = top_ptr;
|
|
|
|
_cbmem_top_ptr = ALIGN_UP((uintptr_t)top_ptr + CBMEM_SIZE, DYN_CBMEM_ALIGN_SIZE);
|
|
return 0;
|
|
}
|
|
|
|
static int teardown_group_imd_cbmem(void **state)
|
|
{
|
|
reset_imd();
|
|
free(*state);
|
|
return 0;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
const struct CMUnitTest tests[] = {
|
|
cmocka_unit_test_setup_teardown(test_cbmem_top,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_initialize_empty,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_initialize_empty_id_size,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_initialize,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
#if ENV_ROMSTAGE_OR_BEFORE
|
|
cmocka_unit_test_setup_teardown(test_cbmem_initialize_id_size_romstage,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
#else
|
|
cmocka_unit_test_setup_teardown(test_cbmem_initialize_id_size_ramstage,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
#endif
|
|
cmocka_unit_test_setup_teardown(test_cbmem_recovery,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_entry_add,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_add,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_entry_find,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_find,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_entry_remove,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_entry_size,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_entry_start,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_add_bootmem,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_cbmem_get_region,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
cmocka_unit_test_setup_teardown(test_general_data_structure,
|
|
setup_teardown_test_imd_cbmem,
|
|
setup_teardown_test_imd_cbmem),
|
|
};
|
|
|
|
return cmocka_run_group_tests(tests, setup_group_imd_cbmem, teardown_group_imd_cbmem);
|
|
}
|