/* 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); }