summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/include/tests/lib/cbfs_util.h13
-rw-r--r--tests/lib/Makefile.inc23
-rw-r--r--tests/lib/cbfs-lookup-test.c1062
-rw-r--r--tests/mock/cbfs_file_mock.c57
4 files changed, 1152 insertions, 3 deletions
diff --git a/tests/include/tests/lib/cbfs_util.h b/tests/include/tests/lib/cbfs_util.h
index ebf2fb8b7e..8475946382 100644
--- a/tests/include/tests/lib/cbfs_util.h
+++ b/tests/include/tests/lib/cbfs_util.h
@@ -14,6 +14,14 @@
BE32(((be64) >> 32) & 0xFFFFFFFF), \
BE32(((be64) >> 0) & 0xFFFFFFFF))
+#define LE32(val32) EMPTY_WRAP(\
+ ((val32) >> 0) & 0xff, ((val32) >> 8) & 0xff, \
+ ((val32) >> 16) & 0xff, ((val32) >> 24) & 0xff)
+
+#define LE64(val64) EMPTY_WRAP( \
+ BE32(((val64) >> 0) & 0xFFFFFFFF), \
+ BE32(((val64) >> 32) & 0xFFFFFFFF))
+
#define FILENAME_SIZE 16
struct cbfs_test_file {
@@ -98,5 +106,10 @@ extern const u8 bad_hash[VB2_SHA256_DIGEST_SIZE];
extern const struct cbfs_test_file file_no_hash;
extern const struct cbfs_test_file file_valid_hash;
extern const struct cbfs_test_file file_broken_hash;
+extern const struct cbfs_test_file test_file_1;
+extern const struct cbfs_test_file test_file_2;
+extern const struct cbfs_test_file test_file_int_1;
+extern const struct cbfs_test_file test_file_int_2;
+extern const struct cbfs_test_file test_file_int_3;
#endif /* TESTS_LIB_CBFS_UTIL_H */
diff --git a/tests/lib/Makefile.inc b/tests/lib/Makefile.inc
index 44679eb08a..f28cd52fa0 100644
--- a/tests/lib/Makefile.inc
+++ b/tests/lib/Makefile.inc
@@ -36,6 +36,8 @@ tests-y += cbfs-verification-no-sha512-test
tests-y += cbfs-verification-has-sha512-test
tests-y += cbfs-no-verification-no-sha512-test
tests-y += cbfs-no-verification-has-sha512-test
+tests-y += cbfs-lookup-no-mcache-test
+tests-y += cbfs-lookup-has-mcache-test
string-test-srcs += tests/lib/string-test.c
string-test-srcs += src/lib/string.c
@@ -208,3 +210,24 @@ cbfs-no-verification-no-sha512-test-config += CONFIG_CBFS_VERIFICATION=0
$(call copy-test,cbfs-verification-no-sha512-test,cbfs-no-verification-has-sha512-test)
cbfs-no-verification-has-sha512-test-config += CONFIG_CBFS_VERIFICATION=0 \
VB2_SUPPORT_SHA512=1
+
+cbfs-lookup-no-mcache-test-srcs = tests/lib/cbfs-lookup-test.c \
+ tests/stubs/console.c \
+ tests/stubs/die.c \
+ tests/mock/cbfs_file_mock.c \
+ src/lib/cbfs.c \
+ src/commonlib/bsd/cbfs_private.c \
+ src/commonlib/bsd/cbfs_mcache.c \
+ src/commonlib/mem_pool.c \
+ src/commonlib/region.c
+cbfs-lookup-no-mcache-test-mocks += cbfs_get_boot_device \
+ cbfs_lookup \
+ cbfs_mcache_lookup \
+ mem_pool_alloc \
+ mem_pool_free
+cbfs-lookup-no-mcache-test-config += CONFIG_ARCH_X86=0 \
+ CONFIG_COLLECT_TIMESTAMPS=0 \
+ CONFIG_NO_CBFS_MCACHE=1
+
+$(call copy-test,cbfs-lookup-no-mcache-test,cbfs-lookup-has-mcache-test)
+cbfs-lookup-has-mcache-test-config += CONFIG_NO_CBFS_MCACHE=0
diff --git a/tests/lib/cbfs-lookup-test.c b/tests/lib/cbfs-lookup-test.c
new file mode 100644
index 0000000000..27abca3bd5
--- /dev/null
+++ b/tests/lib/cbfs-lookup-test.c
@@ -0,0 +1,1062 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+
+#include <assert.h>
+#include <cbfs.h>
+#include <commonlib/bsd/cbfs_mdata.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 cb_err_t __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);
+
+cb_err_t 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 cb_err_t err =
+ __real_cbfs_lookup(dev, name, mdata_out, data_offset_out, metadata_hash);
+ assert_int_equal(err, mock_type(cb_err_t));
+ return err;
+}
+
+extern cb_err_t __real_cbfs_mcache_lookup(const void *mcache, size_t mcache_size,
+ const char *name, union cbfs_mdata *mdata_out,
+ size_t *data_offset_out);
+
+cb_err_t cbfs_mcache_lookup(const void *mcache, size_t mcache_size, const char *name,
+ union cbfs_mdata *mdata_out, size_t *data_offset_out)
+{
+ const cb_err_t err = __real_cbfs_mcache_lookup(mcache, mcache_size, name, mdata_out,
+ data_offset_out);
+ assert_int_equal(err, mock_type(cb_err_t));
+ 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;
+ cb_err_t 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(cb_err_t 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);
+}
diff --git a/tests/mock/cbfs_file_mock.c b/tests/mock/cbfs_file_mock.c
index a4feb618f7..2be89b06b3 100644
--- a/tests/mock/cbfs_file_mock.c
+++ b/tests/mock/cbfs_file_mock.c
@@ -6,9 +6,9 @@ TEST_REGION(cbfs_cache, TEST_CBFS_CACHE_SIZE);
const u8 test_data_1[TEST_DATA_1_SIZE] = { TEST_DATA_1 };
const u8 test_data_2[TEST_DATA_2_SIZE] = { TEST_DATA_2 };
-const u8 test_data_int_1[TEST_DATA_INT_1_SIZE] = { BE64(TEST_DATA_INT_1) };
-const u8 test_data_int_2[TEST_DATA_INT_2_SIZE] = { BE64(TEST_DATA_INT_2) };
-const u8 test_data_int_3[TEST_DATA_INT_3_SIZE] = { BE64(TEST_DATA_INT_3) };
+const u8 test_data_int_1[TEST_DATA_INT_1_SIZE] = { LE64(TEST_DATA_INT_1) };
+const u8 test_data_int_2[TEST_DATA_INT_2_SIZE] = { LE64(TEST_DATA_INT_2) };
+const u8 test_data_int_3[TEST_DATA_INT_3_SIZE] = { LE64(TEST_DATA_INT_3) };
const u8 good_hash[VB2_SHA256_DIGEST_SIZE] = { TEST_SHA256 };
const u8 bad_hash[VB2_SHA256_DIGEST_SIZE] = { INVALID_SHA256 };
@@ -44,3 +44,54 @@ const struct cbfs_test_file file_broken_hash = {
TEST_DATA_1,
},
};
+
+
+const struct cbfs_test_file test_file_1 = {
+ .header = HEADER_INITIALIZER(CBFS_TYPE_RAW, 0, TEST_DATA_1_SIZE),
+ .filename = TEST_DATA_1_FILENAME,
+ .attrs_and_data = {
+ TEST_DATA_1,
+ },
+};
+
+const struct cbfs_test_file test_file_2 = {
+ .header = HEADER_INITIALIZER(CBFS_TYPE_RAW, sizeof(struct cbfs_file_attr_compression),
+ TEST_DATA_2_SIZE),
+ .filename = TEST_DATA_2_FILENAME,
+ .attrs_and_data = {
+ BE32(CBFS_FILE_ATTR_TAG_COMPRESSION),
+ BE32(sizeof(struct cbfs_file_attr_compression)),
+ BE32(CBFS_COMPRESS_LZMA),
+ BE32(TEST_DATA_2_SIZE),
+ TEST_DATA_2,
+ },
+};
+
+const struct cbfs_test_file test_file_int_1 = {
+ .header = HEADER_INITIALIZER(CBFS_TYPE_RAW, 0, TEST_DATA_INT_1_SIZE),
+ .filename = TEST_DATA_INT_1_FILENAME,
+ .attrs_and_data = {
+ LE64(TEST_DATA_INT_1),
+ },
+};
+
+const struct cbfs_test_file test_file_int_2 = {
+ .header = HEADER_INITIALIZER(CBFS_TYPE_RAW, 0, TEST_DATA_INT_2_SIZE),
+ .filename = TEST_DATA_INT_2_FILENAME,
+ .attrs_and_data = {
+ LE64(TEST_DATA_INT_2),
+ },
+};
+
+const struct cbfs_test_file test_file_int_3 = {
+ .header = HEADER_INITIALIZER(CBFS_TYPE_RAW, sizeof(struct cbfs_file_attr_compression),
+ TEST_DATA_INT_3_SIZE),
+ .filename = TEST_DATA_INT_3_FILENAME,
+ .attrs_and_data = {
+ BE32(CBFS_FILE_ATTR_TAG_COMPRESSION),
+ BE32(sizeof(struct cbfs_file_attr_compression)),
+ BE32(CBFS_COMPRESS_LZ4),
+ BE32(TEST_DATA_INT_3_SIZE),
+ LE64(TEST_DATA_INT_3),
+ },
+};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 16:26:47 +0000