From c893197352acc9b53c1beef5082cbc0271f63688 Mon Sep 17 00:00:00 2001 From: Julius Werner Date: Fri, 16 Apr 2021 16:48:32 -0700 Subject: [PATCH] commonlib/region: Turn addrspace_32bit into a more official API We had the addrspace_32bit rdev in prog_loaders.c for a while to help represent memory ranges as an rdev, and we've found it useful for a couple of things that have nothing to do with program loading. This patch moves the concept straight into commonlib/region.c so it is no longer anchored in such a weird place, and easier to use in unit tests. Also expand the concept to the whole address space (there's no real need to restrict it to 32 bits in 64-bit environments) and introduce an rdev_chain_mem() helper function to make it a bit easier to use. Replace some direct uses of struct mem_region_device with this new API where it seems to make sense. Signed-off-by: Julius Werner Change-Id: Ie4c763b77f77d227768556a9528681d771a08dca Reviewed-on: https://review.coreboot.org/c/coreboot/+/52533 Tested-by: build bot (Jenkins) Reviewed-by: Aaron Durbin --- src/commonlib/include/commonlib/region.h | 13 ++- src/commonlib/region.c | 13 +++ src/drivers/elog/elog.c | 7 +- src/drivers/intel/gma/opregion.c | 9 +-- src/drivers/smmstore/store.c | 6 +- src/drivers/vpd/vpd.c | 6 +- src/include/program_loading.h | 6 +- src/lib/cbfs.c | 4 +- src/lib/fmap.c | 14 ++-- src/lib/prog_loaders.c | 4 - src/soc/intel/apollolake/mmap_boot.c | 9 +-- src/soc/samsung/exynos5250/alternate_cbfs.c | 7 +- src/soc/samsung/exynos5420/alternate_cbfs.c | 5 +- tests/commonlib/region-test.c | 23 +++--- tests/lib/fmap-test.c | 49 ++++-------- tests/lib/region_file-test.c | 89 +++++++++------------ 16 files changed, 117 insertions(+), 147 deletions(-) diff --git a/src/commonlib/include/commonlib/region.h b/src/commonlib/include/commonlib/region.h index 0080c441a5..764870f46c 100644 --- a/src/commonlib/include/commonlib/region.h +++ b/src/commonlib/include/commonlib/region.h @@ -164,14 +164,18 @@ static inline int rdev_chain_full(struct region_device *child, ssize_t rdev_relative_offset(const struct region_device *p, const struct region_device *c); +/* Helper functions to create an rdev that represents memory. */ +int rdev_chain_mem(struct region_device *child, const void *base, size_t size); +int rdev_chain_mem_rw(struct region_device *child, void *base, size_t size); + struct mem_region_device { char *base; struct region_device rdev; }; -/* Initialize at runtime a mem_region_device. This would be used when - * the base and size are dynamic or can't be known during linking. - * There are two variants: read-only and read-write. */ +/* Initialize at runtime a mem_region_device. Should only be used for mappings + that need to fit right up to the edge of the physical address space. Most use + cases will want to use rdev_chain_mem() instead. */ void mem_region_device_ro_init(struct mem_region_device *mdev, void *base, size_t size); @@ -182,7 +186,8 @@ extern const struct region_device_ops mem_rdev_ro_ops; extern const struct region_device_ops mem_rdev_rw_ops; -/* Statically initialize mem_region_device. */ +/* Statically initialize mem_region_device. Should normally only be used for + const globals. Most use cases will want to use rdev_chain_mem() instead. */ #define MEM_REGION_DEV_INIT(base_, size_, ops_) \ { \ .base = (void *)(base_), \ diff --git a/src/commonlib/region.c b/src/commonlib/region.c index 55c0679033..04c3180754 100644 --- a/src/commonlib/region.c +++ b/src/commonlib/region.c @@ -287,6 +287,19 @@ const struct region_device_ops mem_rdev_rw_ops = { .eraseat = mdev_eraseat, }; +static const struct mem_region_device mem_rdev = MEM_REGION_DEV_RO_INIT(0, ~(size_t)0); +static const struct mem_region_device mem_rdev_rw = MEM_REGION_DEV_RW_INIT(0, ~(size_t)0); + +int rdev_chain_mem(struct region_device *child, const void *base, size_t size) +{ + return rdev_chain(child, &mem_rdev.rdev, (uintptr_t)base, size); +} + +int rdev_chain_mem_rw(struct region_device *child, void *base, size_t size) +{ + return rdev_chain(child, &mem_rdev_rw.rdev, (uintptr_t)base, size); +} + void *mmap_helper_rdev_mmap(const struct region_device *rd, size_t offset, size_t size) { diff --git a/src/drivers/elog/elog.c b/src/drivers/elog/elog.c index 82df989e25..4769559ca0 100644 --- a/src/drivers/elog/elog.c +++ b/src/drivers/elog/elog.c @@ -44,7 +44,7 @@ struct elog_state { struct region_device nv_dev; /* Device that mirrors the eventlog in memory. */ - struct mem_region_device mirror_dev; + struct region_device mirror_dev; enum elog_init_state elog_initialized; }; @@ -56,7 +56,7 @@ static uint8_t elog_mirror_buf[ELOG_SIZE]; static inline struct region_device *mirror_dev_get(void) { - return &elog_state.mirror_dev.rdev; + return &elog_state.mirror_dev; } static size_t elog_events_start(void) @@ -798,8 +798,7 @@ int elog_init(void) printk(BIOS_ERR, "ELOG: Unable to allocate backing store\n"); return -1; } - mem_region_device_rw_init(&elog_state.mirror_dev, mirror_buffer, - elog_size); + rdev_chain_mem_rw(&elog_state.mirror_dev, mirror_buffer, elog_size); /* * Mark as initialized to allow elog_init() to be called and deemed diff --git a/src/drivers/intel/gma/opregion.c b/src/drivers/intel/gma/opregion.c index e1ed6c8285..cf2c5d9846 100644 --- a/src/drivers/intel/gma/opregion.c +++ b/src/drivers/intel/gma/opregion.c @@ -128,16 +128,14 @@ static enum cb_err locate_vbt_vbios(const u8 *vbios, struct region_device *rdev) size_t offset; // FIXME: caller should supply a region_device instead of vbios pointer - if (rdev_chain(&rd, &addrspace_32bit.rdev, (uintptr_t)vbios, - sizeof(*oprom))) + if (rdev_chain_mem(&rd, vbios, sizeof(*oprom))) return CB_ERR; if (rdev_readat(&rd, &opromsize, offsetof(optionrom_header_t, size), sizeof(opromsize)) != sizeof(opromsize) || !opromsize) return CB_ERR; - if (rdev_chain(&rd, &addrspace_32bit.rdev, (uintptr_t)vbios, - opromsize * 512)) + if (rdev_chain_mem(&rd, vbios, opromsize * 512)) return CB_ERR; oprom = rdev_mmap(&rd, 0, sizeof(*oprom)); @@ -200,8 +198,7 @@ static enum cb_err locate_vbt_cbfs(struct region_device *rdev) if (vbt == NULL) return CB_ERR; - if (rdev_chain(rdev, &addrspace_32bit.rdev, (uintptr_t)vbt, - vbt_data_size)) + if (rdev_chain_mem(rdev, vbt, vbt_data_size)) return CB_ERR; printk(BIOS_INFO, "GMA: Found VBT in CBFS\n"); diff --git a/src/drivers/smmstore/store.c b/src/drivers/smmstore/store.c index 9f9ab0199d..a12cd58e10 100644 --- a/src/drivers/smmstore/store.c +++ b/src/drivers/smmstore/store.c @@ -267,14 +267,14 @@ int smmstore_clear_region(void) /* Implementation of Version 2 */ static bool store_initialized; -static struct mem_region_device mdev_com_buf; +static struct region_device mdev_com_buf; static int smmstore_rdev_chain(struct region_device *rdev) { if (!store_initialized) return -1; - return rdev_chain_full(rdev, &mdev_com_buf.rdev); + return rdev_chain_full(rdev, &mdev_com_buf); } /** @@ -289,7 +289,7 @@ int smmstore_init(void *buf, size_t len) if (store_initialized) return -1; - mem_region_device_rw_init(&mdev_com_buf, buf, len); + rdev_chain_mem_rw(&mdev_com_buf, buf, len); store_initialized = true; diff --git a/src/drivers/vpd/vpd.c b/src/drivers/vpd/vpd.c index d3ff37019d..a099b3be37 100644 --- a/src/drivers/vpd/vpd.c +++ b/src/drivers/vpd/vpd.c @@ -101,10 +101,8 @@ static int init_vpd_rdevs_from_cbmem(void) if (!cbmem) return -1; - rdev_chain(&ro_vpd, &addrspace_32bit.rdev, - (uintptr_t)cbmem->blob, cbmem->ro_size); - rdev_chain(&rw_vpd, &addrspace_32bit.rdev, - (uintptr_t)cbmem->blob + cbmem->ro_size, cbmem->rw_size); + rdev_chain_mem(&ro_vpd, cbmem->blob, cbmem->ro_size); + rdev_chain_mem(&rw_vpd, cbmem->blob + cbmem->ro_size, cbmem->rw_size); return 0; } diff --git a/src/include/program_loading.h b/src/include/program_loading.h index d01eff64d8..65a36b9b2a 100644 --- a/src/include/program_loading.h +++ b/src/include/program_loading.h @@ -91,15 +91,11 @@ static inline void *prog_entry_arg(const struct prog *prog) return prog->arg; } -/* region_device representing the 32-bit flat address space. */ -extern const struct mem_region_device addrspace_32bit; - /* Can be used to get an rdev representation of program area in memory. */ static inline void prog_chain_rdev(const struct prog *prog, struct region_device *rdev_out) { - rdev_chain(rdev_out, &addrspace_32bit.rdev, - (uintptr_t)prog->start, prog->size); + rdev_chain_mem(rdev_out, prog->start, prog->size); } static inline void prog_set_area(struct prog *prog, void *start, size_t size) diff --git a/src/lib/cbfs.c b/src/lib/cbfs.c index 23e8f41db1..32ebfafbf6 100644 --- a/src/lib/cbfs.c +++ b/src/lib/cbfs.c @@ -89,7 +89,7 @@ int cbfs_boot_locate(struct cbfsf *fh, const char *name, uint32_t *type) return -1; size_t msize = be32toh(fh->mdata.h.offset); - if (rdev_chain(&fh->metadata, &addrspace_32bit.rdev, (uintptr_t)&fh->mdata, msize)) + if (rdev_chain_mem(&fh->metadata, &fh->mdata, msize)) return -1; if (type) { @@ -436,7 +436,7 @@ cb_err_t cbfs_prog_stage_load(struct prog *pstage) void *compr_start = prog_start(pstage) + prog_size(pstage) - in_size; if (rdev_readat(&rdev, compr_start, 0, in_size) != in_size) return CB_ERR; - rdev_chain(&rdev, &addrspace_32bit.rdev, (uintptr_t)compr_start, in_size); + rdev_chain_mem(&rdev, compr_start, in_size); } size_t fsize = cbfs_load_and_decompress(&rdev, prog_start(pstage), prog_size(pstage), diff --git a/src/lib/fmap.c b/src/lib/fmap.c index 418e715b3e..254d7877f6 100644 --- a/src/lib/fmap.c +++ b/src/lib/fmap.c @@ -16,7 +16,7 @@ */ static int fmap_print_once; -static struct mem_region_device fmap_cache; +static struct region_device fmap_cache; #define print_once(...) do { \ if (!fmap_print_once) \ @@ -53,7 +53,7 @@ static void report(const struct fmap *fmap) fmap_print_once = 1; } -static void setup_preram_cache(struct mem_region_device *cache_mrdev) +static void setup_preram_cache(struct region_device *cache_rdev) { if (CONFIG(NO_FMAP_CACHE)) return; @@ -99,7 +99,7 @@ static void setup_preram_cache(struct mem_region_device *cache_mrdev) report(fmap); register_cache: - mem_region_device_ro_init(cache_mrdev, fmap, FMAP_SIZE); + rdev_chain_mem(cache_rdev, fmap, FMAP_SIZE); } static int find_fmap_directory(struct region_device *fmrd) @@ -109,10 +109,10 @@ static int find_fmap_directory(struct region_device *fmrd) size_t offset = FMAP_OFFSET; /* Try FMAP cache first */ - if (!region_device_sz(&fmap_cache.rdev)) + if (!region_device_sz(&fmap_cache)) setup_preram_cache(&fmap_cache); - if (region_device_sz(&fmap_cache.rdev)) - return rdev_chain_full(fmrd, &fmap_cache.rdev); + if (region_device_sz(&fmap_cache)) + return rdev_chain_full(fmrd, &fmap_cache); boot_device_init(); boot = boot_device_ro(); @@ -281,7 +281,7 @@ static void fmap_register_cbmem_cache(int unused) if (!e) return; - mem_region_device_ro_init(&fmap_cache, cbmem_entry_start(e), cbmem_entry_size(e)); + rdev_chain_mem(&fmap_cache, cbmem_entry_start(e), cbmem_entry_size(e)); } /* diff --git a/src/lib/prog_loaders.c b/src/lib/prog_loaders.c index 28c6bf7978..40f51ebf48 100644 --- a/src/lib/prog_loaders.c +++ b/src/lib/prog_loaders.c @@ -16,10 +16,6 @@ #include #include -/* Only can represent up to 1 byte less than size_t. */ -const struct mem_region_device addrspace_32bit = - MEM_REGION_DEV_RO_INIT(0, ~0UL); - void run_romstage(void) { struct prog romstage = diff --git a/src/soc/intel/apollolake/mmap_boot.c b/src/soc/intel/apollolake/mmap_boot.c index 23c819e3a0..6e0800cd65 100644 --- a/src/soc/intel/apollolake/mmap_boot.c +++ b/src/soc/intel/apollolake/mmap_boot.c @@ -42,7 +42,7 @@ static size_t bios_size; -static struct mem_region_device shadow_dev; +static struct region_device shadow_dev; static struct xlate_region_device real_dev; static struct xlate_window real_dev_window; @@ -67,10 +67,9 @@ static void bios_mmap_init(void) */ bios_mapped_size = size - 256 * KiB; - mem_region_device_ro_init(&shadow_dev, (void *)base, - bios_mapped_size); + rdev_chain_mem(&shadow_dev, (void *)base, bios_mapped_size); - xlate_window_init(&real_dev_window, &shadow_dev.rdev, start, bios_mapped_size); + xlate_window_init(&real_dev_window, &shadow_dev, start, bios_mapped_size); xlate_region_device_ro_init(&real_dev, 1, &real_dev_window, CONFIG_ROM_SIZE); bios_size = size; @@ -98,7 +97,7 @@ uint32_t spi_flash_get_mmap_windows(struct flash_mmap_window *table) bios_mmap_init(); table->flash_base = region_offset(&real_dev_window.sub_region); - table->host_base = (uintptr_t)rdev_mmap_full(&shadow_dev.rdev); + table->host_base = (uintptr_t)rdev_mmap_full(&shadow_dev); table->size = region_sz(&real_dev_window.sub_region); return 1; diff --git a/src/soc/samsung/exynos5250/alternate_cbfs.c b/src/soc/samsung/exynos5250/alternate_cbfs.c index a4ae71aafc..a540c3cadf 100644 --- a/src/soc/samsung/exynos5250/alternate_cbfs.c +++ b/src/soc/samsung/exynos5250/alternate_cbfs.c @@ -92,8 +92,8 @@ static int sdmmc_cbfs_open(void) return 0; } -static struct mem_region_device alternate_rdev = - MEM_REGION_DEV_RO_INIT(NULL, 0); +const static struct mem_region_device alternate_rdev = + MEM_REGION_DEV_RO_INIT(_cbfs_cache, REGION_SIZE(cbfs_cache)); const struct region_device *boot_device_ro(void) { @@ -114,9 +114,6 @@ const struct region_device *boot_device_ro(void) void boot_device_init(void) { - mem_region_device_ro_init(&alternate_rdev, _cbfs_cache, - REGION_SIZE(cbfs_cache)); - if (*iram_secondary_base == SECONDARY_BASE_BOOT_USB) { printk(BIOS_DEBUG, "Using Exynos alternate boot mode USB A-A\n"); usb_cbfs_open(); diff --git a/src/soc/samsung/exynos5420/alternate_cbfs.c b/src/soc/samsung/exynos5420/alternate_cbfs.c index 0eb8c08604..99f14a13f2 100644 --- a/src/soc/samsung/exynos5420/alternate_cbfs.c +++ b/src/soc/samsung/exynos5420/alternate_cbfs.c @@ -100,7 +100,7 @@ static int sdmmc_cbfs_open(void) } static struct mem_region_device alternate_rdev = - MEM_REGION_DEV_RO_INIT(NULL, 0); + MEM_REGION_DEV_RO_INIT(_cbfs_cache, REGION_SIZE(cbfs_cache)); const struct region_device *boot_device_ro(void) { @@ -121,9 +121,6 @@ const struct region_device *boot_device_ro(void) void boot_device_init(void) { - mem_region_device_ro_init(&alternate_rdev, _cbfs_cache, - REGION_SIZE(cbfs_cache)); - if (*iram_secondary_base == SECONDARY_BASE_BOOT_USB) { printk(BIOS_DEBUG, "Using Exynos alternate boot mode USB A-A\n"); usb_cbfs_open(); diff --git a/tests/commonlib/region-test.c b/tests/commonlib/region-test.c index 545463e1dd..fab5961173 100644 --- a/tests/commonlib/region-test.c +++ b/tests/commonlib/region-test.c @@ -333,32 +333,33 @@ static void test_mem_rdev(void **state) u8 backing[size]; u8 scratch[size]; int i; - struct mem_region_device mem = MEM_REGION_DEV_RW_INIT(backing, size); + struct region_device mem; + rdev_chain_mem_rw(&mem, backing, size); /* Test writing to and reading from full mapping. */ memset(backing, 0xa5, size); - u8 *mapping = rdev_mmap_full(&mem.rdev); + u8 *mapping = rdev_mmap_full(&mem); assert_non_null(mapping); for (i = 0; i < size; i++) assert_int_equal(mapping[i], 0xa5); memset(mapping, 0x5a, size); for (i = 0; i < size; i++) assert_int_equal(backing[i], 0x5a); - assert_int_equal(rdev_munmap(&mem.rdev, mapping), 0); + assert_int_equal(rdev_munmap(&mem, mapping), 0); /* Test read/write/erase of single bytes. */ for (i = 0; i < size; i++) { u8 val = i + 0xaa; scratch[0] = val; - assert_int_equal(rdev_writeat(&mem.rdev, &scratch, i, 1), 1); + assert_int_equal(rdev_writeat(&mem, &scratch, i, 1), 1); assert_int_equal(backing[i], val); assert_int_equal(scratch[0], val); val = i + 0x55; backing[i] = val; - assert_int_equal(rdev_readat(&mem.rdev, &scratch, i, 1), 1); + assert_int_equal(rdev_readat(&mem, &scratch, i, 1), 1); assert_int_equal(scratch[0], val); assert_int_equal(backing[i], val); - assert_int_equal(rdev_eraseat(&mem.rdev, i, 1), 1); + assert_int_equal(rdev_eraseat(&mem, i, 1), 1); assert_int_equal(backing[i], 0); } @@ -368,25 +369,25 @@ static void test_mem_rdev(void **state) memset(backing, 0, size); memset(scratch, 0, size); memset(scratch + offs, 0x39, chunk); - assert_int_equal(rdev_writeat(&mem.rdev, scratch + offs, offs, chunk), chunk); + assert_int_equal(rdev_writeat(&mem, scratch + offs, offs, chunk), chunk); assert_memory_equal(backing, scratch, size); memset(backing, 0, size); - assert_int_equal(rdev_readat(&mem.rdev, scratch + offs, offs, chunk), chunk); + assert_int_equal(rdev_readat(&mem, scratch + offs, offs, chunk), chunk); assert_memory_equal(backing, scratch, size); memset(scratch + offs + 1, 0, chunk - 1); - assert_int_equal(rdev_eraseat(&mem.rdev, offs + 1, chunk - 1), chunk - 1); + assert_int_equal(rdev_eraseat(&mem, offs + 1, chunk - 1), chunk - 1); assert_memory_equal(backing, scratch, size); /* Test mapping of larger chunk. */ memset(backing, 0, size); - mapping = rdev_mmap(&mem.rdev, offs, chunk); + mapping = rdev_mmap(&mem, offs, chunk); assert_non_null(mapping); memset(scratch, 0x93, size); memcpy(mapping, scratch, chunk); memset(scratch, 0, size); memset(scratch + offs, 0x93, chunk); assert_memory_equal(backing, scratch, size); - assert_int_equal(rdev_munmap(&mem.rdev, mapping), 0); + assert_int_equal(rdev_munmap(&mem, mapping), 0); assert_memory_equal(backing, scratch, size); } diff --git a/tests/lib/fmap-test.c b/tests/lib/fmap-test.c index 372bb85a86..444af5a705 100644 --- a/tests/lib/fmap-test.c +++ b/tests/lib/fmap-test.c @@ -11,8 +11,8 @@ #include #include -static struct mem_region_device mem_rdev_rw; -static struct mem_region_device mem_rdev_ro; +static struct region_device flash_rdev_rw; +static struct region_device flash_rdev_ro; static char *flash_buffer = NULL; static size_t flash_buffer_size = 0; @@ -38,32 +38,15 @@ static void prepare_flash_buffer(void) static int setup_fmap(void **state) { prepare_flash_buffer(); - - mem_rdev_rw = (struct mem_region_device) - MEM_REGION_DEV_RW_INIT(flash_buffer, FMAP_SECTION_FLASH_SIZE); - - mem_rdev_ro = (struct mem_region_device) - MEM_REGION_DEV_RO_INIT(flash_buffer, FMAP_SECTION_FLASH_SIZE); - + rdev_chain_mem_rw(&flash_rdev_rw, flash_buffer, FMAP_SECTION_FLASH_SIZE); + rdev_chain_mem(&flash_rdev_ro, flash_buffer, FMAP_SECTION_FLASH_SIZE); return 0; } static int teardown_fmap(void **state) { - struct mem_region_device empty = { - .base = NULL, - .rdev = { - .root = NULL, - .ops = NULL, - .region = { - .offset = 0, - .size = 0 - } - } - }; - - mem_rdev_rw = empty; - mem_rdev_ro = empty; + rdev_chain_mem_rw(&flash_rdev_rw, NULL, 0); + rdev_chain_mem(&flash_rdev_ro, NULL, 0); free(flash_buffer); flash_buffer = NULL; @@ -79,12 +62,12 @@ void boot_device_init(void) const struct region_device *boot_device_ro(void) { - return &mem_rdev_rw.rdev; + return &flash_rdev_ro; } const struct region_device *boot_device_rw(void) { - return &mem_rdev_rw.rdev; + return &flash_rdev_rw; } static void test_fmap_locate_area_as_rdev(void **state) @@ -93,21 +76,21 @@ static void test_fmap_locate_area_as_rdev(void **state) struct region_device rdev; assert_int_not_equal(-1, fmap_locate_area_as_rdev("RO_VPD", &rdev)); - assert_int_equal(FMAP_SECTION_RO_VPD_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_RO_VPD_START, rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_RO_VPD_SIZE, region_device_sz(&rdev)); /* Check if locating area second time works */ assert_int_not_equal(-1, fmap_locate_area_as_rdev("RO_VPD", &rdev)); - assert_int_equal(FMAP_SECTION_RO_VPD_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_RO_VPD_START, rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_RO_VPD_SIZE, region_device_sz(&rdev)); assert_int_not_equal(-1, fmap_locate_area_as_rdev("RECOVERY_MRC_CACHE", &rdev)); - assert_int_equal(FMAP_SECTION_RECOVERY_MRC_CACHE_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_RECOVERY_MRC_CACHE_START, + rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_RECOVERY_MRC_CACHE_SIZE, region_device_sz(&rdev)); /* Expect error when writing to read-only area */ - assert_int_equal(-1, rdev_writeat(&rdev, buffer, - region_device_offset(&rdev), sizeof(buffer))); + assert_int_equal(-1, rdev_writeat(&rdev, buffer, 0, sizeof(buffer))); /* Expect error when looking for incorrect area */ assert_int_equal(-1, fmap_locate_area_as_rdev("NONEXISTENT_AREA", &rdev)); @@ -131,16 +114,16 @@ static void test_fmap_locate_area_as_rdev_rw(void **state) dummy_data[i] = '0' + i % ('9' - '0'); assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("RW_SECTION_A", &rdev)); - assert_int_equal(FMAP_SECTION_RW_SECTION_A_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_RW_SECTION_A_START, rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_RW_SECTION_A_SIZE, region_device_sz(&rdev)); /* Check if locating area second time works */ assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("RW_SECTION_A", &rdev)); - assert_int_equal(FMAP_SECTION_RW_SECTION_A_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_RW_SECTION_A_START, rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_RW_SECTION_A_SIZE, region_device_sz(&rdev)); assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("MISC_RW", &rdev)); - assert_int_equal(FMAP_SECTION_MISC_RW_START, region_device_offset(&rdev)); + assert_ptr_equal(flash_buffer + FMAP_SECTION_MISC_RW_START, rdev_mmap_full(&rdev)); assert_int_equal(FMAP_SECTION_MISC_RW_SIZE, region_device_sz(&rdev)); diff --git a/tests/lib/region_file-test.c b/tests/lib/region_file-test.c index 6bd1382ad9..aeeaa4efcb 100644 --- a/tests/lib/region_file-test.c +++ b/tests/lib/region_file-test.c @@ -8,17 +8,15 @@ #include #include -static void clear_region_file(struct mem_region_device *mrdev) +static void clear_region_file(struct region_device *rdev) { - uint8_t *mem_buffer = (uint8_t *)mrdev->base; - - memset(mem_buffer, 0xff, REGION_FILE_BUFFER_SIZE); + memset(rdev_mmap_full(rdev), 0xff, REGION_FILE_BUFFER_SIZE); } static int setup_region_file_test_group(void **state) { void *mem_buffer = malloc(REGION_FILE_BUFFER_SIZE); - struct mem_region_device *dev = malloc(sizeof(struct mem_region_device)); + struct region_device *dev = malloc(sizeof(struct region_device)); if (mem_buffer == NULL || dev == NULL) { free(mem_buffer); @@ -26,8 +24,7 @@ static int setup_region_file_test_group(void **state) return -1; } - *dev = (struct mem_region_device) - MEM_REGION_DEV_RW_INIT(mem_buffer, REGION_FILE_BUFFER_SIZE); + rdev_chain_mem_rw(dev, mem_buffer, REGION_FILE_BUFFER_SIZE); *state = dev; clear_region_file(dev); @@ -37,8 +34,8 @@ static int setup_region_file_test_group(void **state) static int teardown_region_file_test_group(void **state) { - struct mem_region_device *dev = *state; - void *mem_buffer = dev->base; + struct region_device *dev = *state; + void *mem_buffer = rdev_mmap_full(dev); free(mem_buffer); free(dev); @@ -51,7 +48,7 @@ static int teardown_region_file_test_group(void **state) everything twice is known, but acceptable as it grants safety and makes tests independent. */ static int setup_teardown_region_file_test(void **state) { - struct mem_region_device *dev = *state; + struct region_device *dev = *state; clear_region_file(dev); @@ -60,116 +57,110 @@ static int setup_teardown_region_file_test(void **state) static void test_region_file_init_empty(void **state) { - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; + struct region_device *rdev = *state; struct region_file regf; /* Test general approach using valid mem_region_device with buffer filled with 0xff. Parameters cannot be NULL. */ - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(RF_EMPTY, regf.slot); } static void test_region_file_init_invalid_metadata(void **state) { - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; - uint16_t *mem_buffer16 = (uint16_t *)mdev->base; + struct region_device *rdev = *state; + uint16_t *mem_buffer16 = (uint16_t *)rdev_mmap_full(rdev); struct region_file regf; /* Set number of metadata blocks to 0 */ mem_buffer16[0] = 0; - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(RF_NEED_TO_EMPTY, regf.slot); } static void test_region_file_init_valid_no_data(void **state) { - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; - uint16_t *mem_buffer16 = (uint16_t *)mdev->base; + struct region_device *rdev = *state; + uint16_t *mem_buffer16 = (uint16_t *)rdev_mmap_full(rdev); struct region_file regf; /* Manually allocate 4 metadata blocks and no data. */ mem_buffer16[0] = 4; - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(0, regf.slot); } static void test_region_file_init_invalid_data_offset(void **state) { - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; - uint16_t *mem_buffer16 = (uint16_t *)mdev->base; + struct region_device *rdev = *state; + uint16_t *mem_buffer16 = (uint16_t *)rdev_mmap_full(rdev); struct region_file regf; /* Manually allocate 4 metadata blocks and no data. */ mem_buffer16[0] = 4; mem_buffer16[1] = 4; - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(RF_NEED_TO_EMPTY, regf.slot); /* Set data size to be larger than region */ mem_buffer16[0] = 4; mem_buffer16[1] = 4 + 4096; - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(RF_NEED_TO_EMPTY, regf.slot); } static void test_region_file_init_correct_data_offset(void **state) { - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; - uint16_t *mem_buffer16 = (uint16_t *)mdev->base; + struct region_device *rdev = *state; + uint16_t *mem_buffer16 = (uint16_t *)rdev_mmap_full(rdev); struct region_file regf; /* Set data size to 8 blocks which is correct value. */ mem_buffer16[0] = 4; mem_buffer16[1] = 4 + 8; - assert_int_equal(0, region_file_init(®f, mrdev)); + assert_int_equal(0, region_file_init(®f, rdev)); assert_int_equal(1, regf.slot); } static void test_region_file_init_real_data(void **state) { - struct mem_region_device dev = MEM_REGION_DEV_RW_INIT(region_file_data_buffer1, - REGION_FILE_BUFFER_SIZE); - struct region_device *rdev = &dev.rdev; + struct region_device rdev; struct region_file regf; + rdev_chain_mem_rw(&rdev, region_file_data_buffer1, REGION_FILE_BUFFER_SIZE); + /* Check on real example with one update */ - assert_int_equal(0, region_file_init(®f, rdev)); + assert_int_equal(0, region_file_init(®f, &rdev)); /* There is one update available */ assert_int_equal(1, regf.slot); /* Check on real example with multiple updates */ - dev = (struct mem_region_device) MEM_REGION_DEV_RW_INIT(region_file_data_buffer2, - REGION_FILE_BUFFER_SIZE); - rdev = &dev.rdev; - assert_int_equal(0, region_file_init(®f, rdev)); + rdev_chain_mem_rw(&rdev, region_file_data_buffer2, REGION_FILE_BUFFER_SIZE); + assert_int_equal(0, region_file_init(®f, &rdev)); /* There are three update available */ assert_int_equal(3, regf.slot); } static void test_region_file_init_invalid_region_device(void **state) { - struct mem_region_device bad_dev = MEM_REGION_DEV_RW_INIT(NULL, 0); + struct region_device bad_dev; struct region_file regf; + rdev_chain_mem_rw(&bad_dev, NULL, 0); + /* Expect fail when passing invalid region_device. */ - assert_int_equal(-1, region_file_init(®f, &bad_dev.rdev)); + assert_int_equal(-1, region_file_init(®f, &bad_dev)); } static void test_region_file_data(void **state) { /* region_device with empty data buffer */ - struct mem_region_device *mdev = *state; - struct region_device *mrdev = &mdev->rdev; + struct region_device *mrdev = *state; /* region_device with prepared data buffer */ - struct mem_region_device dev = MEM_REGION_DEV_RW_INIT(region_file_data_buffer1, - REGION_FILE_BUFFER_SIZE); - struct region_device *rdev = &dev.rdev; + struct region_device rdev; + rdev_chain_mem_rw(&rdev, region_file_data_buffer1, REGION_FILE_BUFFER_SIZE); + struct region_file regf; struct region_device read_rdev; int ret; @@ -182,7 +173,7 @@ static void test_region_file_data(void **state) /* Check if region_file_data() correctly returns region_device for hardcoded region_file data with update of 256 bytes */ - ret = region_file_init(®f, rdev); + ret = region_file_init(®f, &rdev); assert_int_equal(0, ret); ret = region_file_data(®f, &read_rdev); assert_int_equal(0, ret); @@ -192,8 +183,7 @@ static void test_region_file_data(void **state) static void test_region_file_update_data(void **state) { - struct mem_region_device *dev = *state; - struct region_device *rdev = &dev->rdev; + struct region_device *rdev = *state; struct region_file regf; struct region_device read_rdev; const size_t dummy_data_size = 256; @@ -235,8 +225,7 @@ static void test_region_file_update_data(void **state) static void test_region_file_update_data_arr(void **state) { - struct mem_region_device *dev = *state; - struct region_device *rdev = &dev->rdev; + struct region_device *rdev = *state; struct region_file regf; struct region_device read_rdev; const size_t dummy_data_size = 256;