coreboot-kgpe-d16/tests/lib/cbfs-lookup-test.c

1066 lines
35 KiB
C

/* SPDX-License-Identifier: GPL-2.0-only */
#include <assert.h>
#include <cbfs.h>
#include <commonlib/bsd/cbfs_mdata.h>
#include <commonlib/bsd/cbfs_private.h>
#include <commonlib/region.h>
#include <string.h>
#include <tests/lib/cbfs_util.h>
#include <tests/test.h>
static struct cbfs_boot_device cbd;
static u8 aligned_cbfs_buffer[(sizeof(struct cbfs_test_file) + CBFS_ALIGNMENT) * 10] __aligned(
CBFS_ALIGNMENT);
static u8 *unaligned_cbfs_buffer = &aligned_cbfs_buffer[3];
static uintptr_t unaligned_cbfs_buffer_size = sizeof(aligned_cbfs_buffer) - 3;
static u8 cbfs_mcache[TEST_MCACHE_SIZE] __aligned(CBFS_MCACHE_ALIGNMENT);
/* Add files to CBFS buffer. NULL in files list equals to one CBFS_ALIGNMENT of spacing. */
static int create_cbfs(const struct cbfs_test_file *files[], const size_t nfiles, u8 *buffer,
const size_t buffer_size)
{
u8 *data_ptr = buffer;
size_t file_size = 0;
memset(buffer, 0, buffer_size);
for (size_t i = 0; i < nfiles; ++i) {
if (files[i] == NULL) {
file_size = CBFS_ALIGNMENT;
assert_true(&data_ptr[file_size] < &buffer[buffer_size]);
} else {
file_size = be32_to_cpu(files[i]->header.len)
+ be32_to_cpu(files[i]->header.offset);
assert_true(&data_ptr[file_size] < &buffer[buffer_size]);
memcpy(data_ptr, files[i], file_size);
}
data_ptr = &data_ptr[file_size];
const uintptr_t offset = (uintptr_t)data_ptr - (uintptr_t)buffer;
data_ptr = &buffer[ALIGN_UP(offset, CBFS_ALIGNMENT)];
}
return 0;
}
/* Mocks */
const struct cbfs_boot_device *cbfs_get_boot_device(bool force_ro)
{
return &cbd;
}
size_t ulzman(const void *src, size_t srcn, void *dst, size_t dstn)
{
check_expected(srcn);
check_expected(dstn);
memcpy(dst, src, dstn);
return dstn;
}
size_t ulz4fn(const void *src, size_t srcn, void *dst, size_t dstn)
{
check_expected(srcn);
check_expected(dstn);
memcpy(dst, src, dstn);
return dstn;
}
extern enum cb_err __real_cbfs_lookup(cbfs_dev_t dev, const char *name,
union cbfs_mdata *mdata_out, size_t *data_offset_out,
struct vb2_hash *metadata_hash);
enum cb_err cbfs_lookup(cbfs_dev_t dev, const char *name, union cbfs_mdata *mdata_out,
size_t *data_offset_out, struct vb2_hash *metadata_hash)
{
const enum cb_err err =
__real_cbfs_lookup(dev, name, mdata_out, data_offset_out, metadata_hash);
assert_int_equal(err, mock_type(enum cb_err));
return err;
}
extern enum cb_err __real_cbfs_mcache_lookup(const void *mcache, size_t mcache_size,
const char *name, union cbfs_mdata *mdata_out,
size_t *data_offset_out);
enum cb_err cbfs_mcache_lookup(const void *mcache, size_t mcache_size, const char *name,
union cbfs_mdata *mdata_out, size_t *data_offset_out)
{
const enum cb_err err = __real_cbfs_mcache_lookup(mcache, mcache_size, name, mdata_out,
data_offset_out);
assert_int_equal(err, mock_type(enum cb_err));
return err;
}
extern void *__real_mem_pool_alloc(struct mem_pool *mp, size_t sz);
void *mem_pool_alloc(struct mem_pool *mp, size_t sz)
{
check_expected(sz);
assert_ptr_equal(mp, &cbfs_cache);
return __real_mem_pool_alloc(mp, sz);
}
extern void __real_mem_pool_free(struct mem_pool *mp, void *p);
void mem_pool_free(struct mem_pool *mp, void *p)
{
check_expected(p);
assert_ptr_equal(mp, &cbfs_cache);
return __real_mem_pool_free(mp, p);
}
static u8 cbmem_test_buf[2 * MiB];
void *cbmem_add(u32 id, u64 size)
{
check_expected(id);
check_expected(size);
return cbmem_test_buf;
}
/* Setup, teardown and utils */
struct cbfs_test_state_ex {
u32 file_type;
u32 file_length;
enum cb_err lookup_result;
};
struct cbfs_test_state {
u8 *cbfs_buf;
size_t cbfs_size;
/* Optionals */
struct cbfs_test_state_ex ex;
};
static int setup_test_cbfs_aligned(void **state)
{
struct cbfs_test_state *s = malloc(sizeof(struct cbfs_test_state));
if (!s)
return 1;
s->cbfs_buf = aligned_cbfs_buffer;
s->cbfs_size = sizeof(aligned_cbfs_buffer);
memset(&s->ex, 0, sizeof(s->ex));
/* Prestate */
if (*state != NULL)
s->ex = *((struct cbfs_test_state_ex *)*state);
*state = s;
rdev_chain_mem(&cbd.rdev, aligned_cbfs_buffer, sizeof(aligned_cbfs_buffer));
memset(aligned_cbfs_buffer, 0, sizeof(aligned_cbfs_buffer));
cbd.mcache = cbfs_mcache;
cbd.mcache_size = TEST_MCACHE_SIZE;
return 0;
}
static int setup_test_cbfs_unaligned(void **state)
{
struct cbfs_test_state *s = malloc(sizeof(struct cbfs_test_state));
if (!s)
return 1;
s->cbfs_buf = unaligned_cbfs_buffer;
s->cbfs_size = unaligned_cbfs_buffer_size;
memset(&s->ex, 0, sizeof(s->ex));
/* Prestate */
if (*state != NULL)
s->ex = *((struct cbfs_test_state_ex *)*state);
*state = s;
rdev_chain_mem(&cbd.rdev, unaligned_cbfs_buffer, unaligned_cbfs_buffer_size);
memset(unaligned_cbfs_buffer, 0, unaligned_cbfs_buffer_size);
cbd.mcache = cbfs_mcache;
cbd.mcache_size = TEST_MCACHE_SIZE;
return 0;
}
static int teardown_test_cbfs(void **state)
{
free(*state);
memset(&cbd, 0, sizeof(cbd));
return 0;
}
/* Utils */
static void expect_lookup_result(enum cb_err res)
{
if (CONFIG(NO_CBFS_MCACHE))
will_return(cbfs_lookup, (res));
else
will_return(cbfs_mcache_lookup, (res));
}
/* Tests */
/* Test case for cbfs_map() function. Validate file searching in the correct CBFS */
static void test_cbfs_map(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
const struct cbfs_test_file *cbfs_files[] = {
&test_file_int_1, &test_file_2, NULL, &test_file_int_2,
&test_file_1, NULL, NULL, &test_file_int_3,
};
assert_int_equal(
0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), s->cbfs_buf, s->cbfs_size));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
/* Existing files */
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_1_SIZE, size_out);
assert_memory_equal(mapping, test_data_1, TEST_DATA_1_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_value(ulzman, srcn, TEST_DATA_2_SIZE);
expect_value(ulzman, dstn, TEST_DATA_2_SIZE);
expect_value(mem_pool_alloc, sz, TEST_DATA_2_SIZE);
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_2_SIZE, size_out);
assert_memory_equal(mapping, test_data_2, TEST_DATA_2_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_INT_1_SIZE, size_out);
assert_memory_equal(mapping, test_data_int_1, TEST_DATA_INT_1_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
/* Do not pass output pointer to size. It should work correctly. */
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, NULL);
assert_non_null(mapping);
assert_memory_equal(mapping, test_data_int_2, TEST_DATA_INT_2_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_value(ulz4fn, srcn, TEST_DATA_INT_3_SIZE);
expect_value(ulz4fn, dstn, TEST_DATA_INT_3_SIZE);
expect_value(mem_pool_alloc, sz, TEST_DATA_INT_3_SIZE);
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_3_FILENAME, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_INT_3_SIZE, size_out);
assert_memory_equal(mapping, test_data_int_3, TEST_DATA_INT_3_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
/* Nonexistent files */
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map("unknown_fname", &size_out);
assert_ptr_equal(NULL, mapping);
assert_int_equal(0, size_out);
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map("", &size_out);
assert_ptr_equal(NULL, mapping);
assert_int_equal(0, size_out);
}
static void test_cbfs_cbmem_alloc(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
const struct cbfs_test_file *cbfs_files[] = {
NULL, &test_file_1, &test_file_2, &test_file_int_1,
NULL, &test_file_int_2, &test_file_int_3, NULL,
};
assert_int_equal(
0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), s->cbfs_buf, s->cbfs_size));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
/* Existing files */
expect_lookup_result(CB_SUCCESS);
expect_value(cbmem_add, id, 0x0101);
expect_value(cbmem_add, size, TEST_DATA_1_SIZE);
mapping = cbfs_cbmem_alloc(TEST_DATA_1_FILENAME, 0x0101, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_1_SIZE, size_out);
assert_memory_equal(mapping, test_data_1, TEST_DATA_1_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
/* Do not pass output pointer to size. It should work correctly. */
expect_value(ulzman, srcn, TEST_DATA_2_SIZE);
expect_value(ulzman, dstn, TEST_DATA_2_SIZE);
expect_lookup_result(CB_SUCCESS);
expect_value(cbmem_add, id, 0x0102);
expect_value(cbmem_add, size, TEST_DATA_2_SIZE);
mapping = cbfs_cbmem_alloc(TEST_DATA_2_FILENAME, 0x0102, NULL);
assert_non_null(mapping);
assert_memory_equal(mapping, test_data_2, TEST_DATA_2_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_lookup_result(CB_SUCCESS);
expect_value(cbmem_add, id, 0x0201);
expect_value(cbmem_add, size, TEST_DATA_INT_1_SIZE);
mapping = cbfs_cbmem_alloc(TEST_DATA_INT_1_FILENAME, 0x0201, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_INT_1_SIZE, size_out);
assert_memory_equal(mapping, test_data_int_1, TEST_DATA_INT_1_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_lookup_result(CB_SUCCESS);
expect_value(cbmem_add, id, 0x0202);
expect_value(cbmem_add, size, TEST_DATA_INT_2_SIZE);
mapping = cbfs_cbmem_alloc(TEST_DATA_INT_2_FILENAME, 0x0202, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_INT_2_SIZE, size_out);
assert_memory_equal(mapping, test_data_int_2, TEST_DATA_INT_2_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
size_out = 0;
expect_value(ulz4fn, srcn, TEST_DATA_INT_3_SIZE);
expect_value(ulz4fn, dstn, TEST_DATA_INT_3_SIZE);
expect_lookup_result(CB_SUCCESS);
expect_value(cbmem_add, id, 0x0203);
expect_value(cbmem_add, size, TEST_DATA_INT_2_SIZE);
mapping = cbfs_cbmem_alloc(TEST_DATA_INT_3_FILENAME, 0x0203, &size_out);
assert_non_null(mapping);
assert_int_equal(TEST_DATA_INT_3_SIZE, size_out);
assert_memory_equal(mapping, test_data_int_3, TEST_DATA_INT_3_SIZE);
expect_value(mem_pool_free, p, mapping);
cbfs_unmap(mapping);
/* Nonexistent files */
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_cbmem_alloc("nothing-file", 0x0301, &size_out);
assert_null(mapping);
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_cbmem_alloc("", 0x0302, &size_out);
assert_null(mapping);
}
static void test_cbfs_image_not_aligned(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
const struct cbfs_test_file *cbfs_files[] = {
&test_file_int_1,
&test_file_2,
};
assert_int_equal(0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), &s->cbfs_buf[5],
s->cbfs_size - 5));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_null(mapping);
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_file_not_aligned(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
memcpy(s->cbfs_buf, &test_file_int_2, sizeof(test_file_int_2));
memcpy(&s->cbfs_buf[ALIGN_UP(sizeof(test_file_int_2), CBFS_ALIGNMENT) + 5],
&test_file_1, sizeof(test_file_1));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_ptr_equal(mapping,
&s->cbfs_buf[offsetof(struct cbfs_test_file, attrs_and_data)]);
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_garbage_data_before_aligned_file(void **state)
{
void *mapping;
size_t size_out;
const char garbage[] =
"NOT so USEFUL DaTa BYTES that should have at least CBFS_ALIGNMENT bytes";
const size_t garbage_sz = CBFS_ALIGNMENT;
struct cbfs_test_state *s = *state;
/* Garbage data size has to be aligned to CBFS_ALIGNMENT */
memcpy(s->cbfs_buf, garbage, garbage_sz);
memcpy(&s->cbfs_buf[garbage_sz], &test_file_int_2, sizeof(test_file_int_2));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_ptr_equal(
mapping,
&s->cbfs_buf[garbage_sz + offsetof(struct cbfs_test_file, attrs_and_data)]);
}
static void test_cbfs_garbage_data_before_unaligned_file(void **state)
{
void *mapping;
size_t size_out;
const char garbage[] =
"NOT so USEFUL DaTa BYTES that should have at least CBFS_ALIGNMENT + 3 bytes";
const size_t garbage_sz = CBFS_ALIGNMENT + 3;
struct cbfs_test_state *s = *state;
assert_true(garbage_sz == (CBFS_ALIGNMENT + 3));
memcpy(s->cbfs_buf, garbage, garbage_sz);
memcpy(&s->cbfs_buf[garbage_sz], &test_file_int_2, sizeof(test_file_int_2));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_file_bigger_than_rdev(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
/* File with length equal to region_device size will go beyond it */
f->header.len = cpu_to_be32(s->cbfs_size);
/* Initialization and mcache building will succeed, because it only does access file
headers, and not actual data */
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
/* Lookup should not succeed, because data is too long, so reading it later would cause
memory access issues */
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_fail_beyond_rdev(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT);
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[second_file_start], &test_file_2, s->ex.file_length);
assert_true((second_file_start + s->ex.file_length) <= region_sz(&cbd.rdev.region));
/* Adjust size of region device to cut everything after selected offset */
cbd.rdev.region.size = second_file_start + s->ex.file_length;
/* CBFS initialization should not fail if last file is not valid */
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]);
assert_int_equal(size_out, TEST_DATA_1_SIZE);
size_out = 0;
if (s->ex.lookup_result == CB_SUCCESS) {
expect_value(ulzman, srcn, TEST_DATA_2_SIZE);
expect_value(ulzman, dstn, TEST_DATA_2_SIZE);
expect_value(mem_pool_alloc, sz, TEST_DATA_2_SIZE);
}
expect_lookup_result(s->ex.lookup_result);
cbfs_map(TEST_DATA_2_FILENAME, &size_out);
}
static void test_cbfs_unaligned_file_in_the_middle(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT) + 5;
size_t third_file_start =
ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT);
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1));
memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_null(mapping);
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_ptr_equal(
mapping,
&s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_2.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_int_2.header.len));
}
static void test_cbfs_overlapping_files(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT);
size_t third_file_start =
ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT);
size_t second_file_size =
third_file_start + sizeof(test_file_int_2) - second_file_start;
struct cbfs_test_file *f;
/* Third file is inside second file, thus it should not be found */
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1));
memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2));
f = (struct cbfs_test_file *)&s->cbfs_buf[second_file_start];
f->header.len = cpu_to_be32(second_file_size);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_ptr_equal(
mapping,
&s->cbfs_buf[second_file_start + be32_to_cpu(test_file_int_1.header.offset)]);
assert_int_equal(size_out, second_file_size);
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_incorrect_file_in_the_middle(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT);
size_t third_file_start =
ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT);
struct cbfs_test_file *f;
/* Zero offset is illegal. File is not correct */
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1));
memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2));
f = (struct cbfs_test_file *)&s->cbfs_buf[second_file_start];
f->header.offset = cpu_to_be32(0);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_null(mapping);
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out);
assert_ptr_equal(
mapping,
&s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_2.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_int_2.header.len));
}
static void test_cbfs_two_files_with_same_name(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT);
size_t third_file_start =
ALIGN_UP(sizeof(test_file_1) + second_file_start, CBFS_ALIGNMENT);
/* Only first occurrence of file will be found */
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[second_file_start], &test_file_1, sizeof(test_file_1));
memcpy(&s->cbfs_buf[third_file_start], &test_file_int_1, sizeof(test_file_int_1));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_ptr_equal(
mapping,
&s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_1.header.offset)]);
assert_int_equal(size_out, be32_to_cpu(test_file_int_1.header.len));
}
static void test_cbfs_filename_not_terminated(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
const char fname[] = "abcdefghijklmnop";
assert_true(sizeof(test_file_1.filename) == strlen(fname));
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
memcpy(f->filename, fname, strlen(fname));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
/* Filename is too long and does not include NULL-terminator. */
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(fname, &size_out);
assert_null(mapping);
}
static void test_cbfs_filename_terminated_but_too_long(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
/* Filename length in header offset field is too short by one to include
NULL-terminator of filename */
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.offset = cpu_to_be32(offsetof(struct cbfs_test_file, filename)
+ strlen(TEST_DATA_1_FILENAME));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_attributes_offset_larger_than_offset(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
/* Require attributes for this test */
assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE
+ sizeof(struct cbfs_file_attr_compression));
f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_attributes_offset_cut_off_at_len(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
/* Require attributes for this test */
assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.attributes_offset =
cpu_to_be32(offsetof(struct cbfs_test_file, attrs_and_data)
+ offsetof(struct cbfs_file_attribute, len));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
/* No attributes will be found, because attributes_offset value is too big to cover
cbfs_file_attribute tag. Compression attribute of ths file will not be found, and
that is why there is no need to call expect_value(ulzma).
However, file will be found, because the offset is correct. */
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(f->header.offset)]);
assert_int_equal(size_out, TEST_DATA_2_SIZE);
}
static void test_cbfs_attributes_offset_cut_off_at_data(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
/* Require attributes for this test */
assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE
+ offsetof(struct cbfs_file_attribute, data));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
/* No attributes will be found, because attributes_offset value is too big to cover
cbfs_file_attribute tag and length. Compression attribute of ths file will not be
found, and that is why there is no need to call expect_value(ulzma).
However, file will be found, because the offset is correct. */
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(f->header.offset)]);
assert_int_equal(size_out, TEST_DATA_2_SIZE);
}
static void test_cbfs_attributes_offset_smaller_than_file_struct(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) / 2);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_offset_smaller_than_header_size(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0);
memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) / 2);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_attributes_offset_is_zero(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0);
memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_int_equal(TEST_DATA_INT_1_SIZE, size_out);
assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_int_1.header.offset)]);
}
static void test_cbfs_offset_is_zero(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0);
memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.offset = cpu_to_be32(0);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_attributes_too_large(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf;
/* Offset determines size of header and attributes. CBFS module uses cbfs_mdata union to
store it, so offset (thus attributes) bigger than it should cause an error in the
lookup code. */
f->header.offset =
cpu_to_be32(be32_to_cpu(f->header.offset) + sizeof(union cbfs_mdata));
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out);
assert_null(mapping);
}
/* Requires cbfs_test_state.ex.file_length to be set */
static void test_cbfs_file_length(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_1.header.attributes_offset) == 0);
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.len = cpu_to_be32(s->ex.file_length);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_null(mapping);
}
static void test_cbfs_attributes_offset_uint32_max(void **state)
{
void *mapping;
size_t size_out;
struct cbfs_test_state *s = *state;
struct cbfs_test_file *f;
assert_true(be32_to_cpu(test_file_1.header.attributes_offset) == 0);
memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1));
f = (struct cbfs_test_file *)s->cbfs_buf;
f->header.attributes_offset = cpu_to_be32(UINT32_MAX);
assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL));
size_out = 0;
expect_lookup_result(CB_CBFS_NOT_FOUND);
mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out);
assert_null(mapping);
}
#define CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(name, test_fn, setup_fn, prestate) \
{ \
(name), (test_fn), (setup_fn), teardown_test_cbfs, (prestate), \
}
#define CBFS_LOOKUP_NAME_PRESTATE_TEST(name, test_fn, prestate) \
EMPTY_WRAP( \
CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST( \
("aligned, " name), (test_fn), setup_test_cbfs_aligned, (prestate)), \
CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(("unaligned, " name), (test_fn), \
setup_test_cbfs_unaligned, \
(prestate)))
#define CBFS_LOOKUP_TEST(test_fn) CBFS_LOOKUP_NAME_PRESTATE_TEST(#test_fn, test_fn, NULL)
#define CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV(name, file_len, lookup_res) \
EMPTY_WRAP(CBFS_LOOKUP_NAME_PRESTATE_TEST(name ", CBFS_TYPE_RAW", \
test_cbfs_fail_beyond_rdev, \
(&(struct cbfs_test_state_ex){ \
.file_type = CBFS_TYPE_RAW, \
.file_length = (file_len), \
.lookup_result = (lookup_res), \
})), \
CBFS_LOOKUP_NAME_PRESTATE_TEST(name ", CBFS_TYPE_NULL", \
test_cbfs_fail_beyond_rdev, \
(&(struct cbfs_test_state_ex){ \
.file_type = CBFS_TYPE_NULL, \
.file_length = (file_len), \
.lookup_result = (lookup_res), \
})))
#define CBFS_LOOKUP_TEST_FILE_LENGTH(file_len) \
CBFS_LOOKUP_NAME_PRESTATE_TEST("test_cbfs_file_length, " #file_len, \
test_cbfs_file_length, \
(&(struct cbfs_test_state_ex){ \
.file_length = (file_len), \
}))
int main(void)
{
const struct CMUnitTest cbfs_lookup_aligned_and_unaligned_tests[] = {
CBFS_LOOKUP_TEST(test_cbfs_map),
CBFS_LOOKUP_TEST(test_cbfs_cbmem_alloc),
CBFS_LOOKUP_TEST(test_cbfs_image_not_aligned),
CBFS_LOOKUP_TEST(test_cbfs_file_not_aligned),
CBFS_LOOKUP_TEST(test_cbfs_garbage_data_before_aligned_file),
CBFS_LOOKUP_TEST(test_cbfs_garbage_data_before_unaligned_file),
CBFS_LOOKUP_TEST(test_cbfs_file_bigger_than_rdev),
/* Correct file */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("File fitting in rdev",
sizeof(struct cbfs_test_file), CB_SUCCESS),
/* Attributes beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV(
"Attributes and data beyond rdev",
offsetof(struct cbfs_test_file, attrs_and_data), CB_CBFS_NOT_FOUND),
/* Attributes except tag beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV(
"Attributes except tag beyond rdev",
offsetof(struct cbfs_test_file, attrs_and_data)
- offsetof(struct cbfs_file_attribute, len),
CB_CBFS_NOT_FOUND),
/* Attributes except tag and len beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV(
"Attributes except tag and len beyond rdev",
offsetof(struct cbfs_test_file, attrs_and_data)
- offsetof(struct cbfs_file_attribute, data),
CB_CBFS_NOT_FOUND),
/* Filename beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Filename beyond rdev",
offsetof(struct cbfs_test_file, filename),
CB_CBFS_NOT_FOUND),
/* Part of filename beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Part of filename beyond rdev",
offsetof(struct cbfs_test_file, filename)
+ FILENAME_SIZE / 2,
CB_CBFS_NOT_FOUND),
/* Part of cbfs_file struct beyond rdev */
CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Part of cbfs_file struct beyond rdev",
offsetof(struct cbfs_test_file, filename) / 2,
CB_CBFS_NOT_FOUND),
CBFS_LOOKUP_TEST(test_cbfs_unaligned_file_in_the_middle),
CBFS_LOOKUP_TEST(test_cbfs_overlapping_files),
CBFS_LOOKUP_TEST(test_cbfs_incorrect_file_in_the_middle),
CBFS_LOOKUP_TEST(test_cbfs_two_files_with_same_name),
CBFS_LOOKUP_TEST(test_cbfs_filename_not_terminated),
CBFS_LOOKUP_TEST(test_cbfs_filename_terminated_but_too_long),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_larger_than_offset),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_cut_off_at_len),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_cut_off_at_data),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_smaller_than_file_struct),
CBFS_LOOKUP_TEST(test_cbfs_offset_smaller_than_header_size),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_is_zero),
CBFS_LOOKUP_TEST(test_cbfs_offset_is_zero),
CBFS_LOOKUP_TEST(test_cbfs_attributes_too_large),
CBFS_LOOKUP_TEST_FILE_LENGTH(UINT32_MAX),
CBFS_LOOKUP_TEST_FILE_LENGTH(UINT32_MAX
- offsetof(struct cbfs_test_file, attrs_and_data)),
CBFS_LOOKUP_TEST_FILE_LENGTH(
UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) / 2),
CBFS_LOOKUP_TEST_FILE_LENGTH(
UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) * 2),
CBFS_LOOKUP_TEST_FILE_LENGTH(
UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) - 1),
CBFS_LOOKUP_TEST_FILE_LENGTH(
UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) + 1),
CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_uint32_max),
};
return cb_run_group_tests(cbfs_lookup_aligned_and_unaligned_tests, NULL, NULL);
}