Jakub Czapiga | dd85c82 | 2020-12-10 11:16:47 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
| 2 | |
| 3 | #include <stdlib.h> |
| 4 | #include <string.h> |
| 5 | |
| 6 | #include <tests/test.h> |
| 7 | |
| 8 | #include <fmap.h> |
| 9 | #include <commonlib/region.h> |
| 10 | |
| 11 | #include <tests/lib/fmap/fmap_data.h> |
| 12 | #include <tests/lib/fmap/fmap_config.h> |
| 13 | |
| 14 | static struct mem_region_device mem_rdev_rw; |
| 15 | static struct mem_region_device mem_rdev_ro; |
| 16 | static char *flash_buffer = NULL; |
| 17 | static size_t flash_buffer_size = 0; |
| 18 | |
| 19 | static void prepare_flash_buffer(void) |
| 20 | { |
| 21 | /* Prepare flash buffer with dummy data and FMAP */ |
| 22 | flash_buffer = malloc(FMAP_SECTION_FLASH_SIZE); |
| 23 | flash_buffer_size = FMAP_SECTION_FLASH_SIZE; |
| 24 | |
| 25 | /* Fill first part of buffer with dummy data */ |
| 26 | for (int i = 0; i < FMAP_SECTION_FMAP_START; ++i) |
| 27 | flash_buffer[i] = 'a' + i % ('z' - 'a'); |
| 28 | |
| 29 | /* Copy FMAP section into buffer */ |
| 30 | memcpy(flash_buffer + FMAP_SECTION_FMAP_START, tests_fmap_bin, FMAP_SIZE); |
| 31 | |
| 32 | /* Fill rest of buffer with dummy data */ |
| 33 | for (int i = FMAP_SECTION_FMAP_START + FMAP_SECTION_FMAP_SIZE; |
| 34 | i < FMAP_SECTION_FLASH_SIZE; ++i) |
| 35 | flash_buffer[i] = 'a' + i % ('z' - 'a'); |
| 36 | } |
| 37 | |
| 38 | static int setup_fmap(void **state) |
| 39 | { |
| 40 | prepare_flash_buffer(); |
| 41 | |
| 42 | mem_rdev_rw = (struct mem_region_device) |
| 43 | MEM_REGION_DEV_RW_INIT(flash_buffer, FMAP_SECTION_FLASH_SIZE); |
| 44 | |
| 45 | mem_rdev_ro = (struct mem_region_device) |
| 46 | MEM_REGION_DEV_RO_INIT(flash_buffer, FMAP_SECTION_FLASH_SIZE); |
| 47 | |
| 48 | return 0; |
| 49 | } |
| 50 | |
| 51 | static int teardown_fmap(void **state) |
| 52 | { |
| 53 | struct mem_region_device empty = { |
| 54 | .base = NULL, |
| 55 | .rdev = { |
| 56 | .root = NULL, |
| 57 | .ops = NULL, |
| 58 | .region = { |
| 59 | .offset = 0, |
| 60 | .size = 0 |
| 61 | } |
| 62 | } |
| 63 | }; |
| 64 | |
| 65 | mem_rdev_rw = empty; |
| 66 | mem_rdev_ro = empty; |
| 67 | |
| 68 | free(flash_buffer); |
| 69 | flash_buffer = NULL; |
| 70 | flash_buffer_size = 0; |
| 71 | |
| 72 | return 0; |
| 73 | } |
| 74 | |
| 75 | void boot_device_init(void) |
| 76 | { |
| 77 | /* Setup in unit test setup function */ |
| 78 | } |
| 79 | |
| 80 | const struct region_device *boot_device_ro(void) |
| 81 | { |
| 82 | return &mem_rdev_rw.rdev; |
| 83 | } |
| 84 | |
| 85 | const struct region_device *boot_device_rw(void) |
| 86 | { |
| 87 | return &mem_rdev_rw.rdev; |
| 88 | } |
| 89 | |
| 90 | static void test_fmap_locate_area_as_rdev(void **state) |
| 91 | { |
| 92 | const char buffer[] = "abcdefghijk0123456789"; |
| 93 | struct region_device rdev; |
| 94 | |
| 95 | assert_int_not_equal(-1, fmap_locate_area_as_rdev("RO_VPD", &rdev)); |
| 96 | assert_int_equal(FMAP_SECTION_RO_VPD_START, region_device_offset(&rdev)); |
| 97 | assert_int_equal(FMAP_SECTION_RO_VPD_SIZE, region_device_sz(&rdev)); |
| 98 | |
| 99 | /* Check if locating area second time works */ |
| 100 | assert_int_not_equal(-1, fmap_locate_area_as_rdev("RO_VPD", &rdev)); |
| 101 | assert_int_equal(FMAP_SECTION_RO_VPD_START, region_device_offset(&rdev)); |
| 102 | assert_int_equal(FMAP_SECTION_RO_VPD_SIZE, region_device_sz(&rdev)); |
| 103 | |
| 104 | assert_int_not_equal(-1, fmap_locate_area_as_rdev("RECOVERY_MRC_CACHE", &rdev)); |
| 105 | assert_int_equal(FMAP_SECTION_RECOVERY_MRC_CACHE_START, region_device_offset(&rdev)); |
| 106 | assert_int_equal(FMAP_SECTION_RECOVERY_MRC_CACHE_SIZE, region_device_sz(&rdev)); |
| 107 | |
| 108 | /* Expect error when writing to read-only area */ |
| 109 | assert_int_equal(-1, rdev_writeat(&rdev, buffer, |
| 110 | region_device_offset(&rdev), sizeof(buffer))); |
| 111 | |
| 112 | /* Expect error when looking for incorrect area */ |
| 113 | assert_int_equal(-1, fmap_locate_area_as_rdev("NONEXISTENT_AREA", &rdev)); |
| 114 | assert_int_equal(-1, fmap_locate_area_as_rdev("", &rdev)); |
| 115 | assert_int_equal(-1, fmap_locate_area_as_rdev(NULL, &rdev)); |
| 116 | |
| 117 | /* Function fmap_locate_area_as_rdev is not tested with NULL |
| 118 | as region_device pointer as it is not allowed. */ |
| 119 | } |
| 120 | |
| 121 | static void test_fmap_locate_area_as_rdev_rw(void **state) |
| 122 | { |
| 123 | struct region_device rdev; |
| 124 | size_t ro_rw_section_size = FMAP_SECTION_MISC_RW_SIZE; |
| 125 | char *buffer1 = malloc(ro_rw_section_size); |
| 126 | char *buffer2 = malloc(ro_rw_section_size); |
| 127 | char *dummy_data = malloc(ro_rw_section_size); |
| 128 | |
| 129 | /* Fill buffer with dummy data */ |
| 130 | for (int i = 0; i < ro_rw_section_size; ++i) |
| 131 | dummy_data[i] = '0' + i % ('9' - '0'); |
| 132 | |
| 133 | assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("RW_SECTION_A", &rdev)); |
| 134 | assert_int_equal(FMAP_SECTION_RW_SECTION_A_START, region_device_offset(&rdev)); |
| 135 | assert_int_equal(FMAP_SECTION_RW_SECTION_A_SIZE, region_device_sz(&rdev)); |
| 136 | |
| 137 | /* Check if locating area second time works */ |
| 138 | assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("RW_SECTION_A", &rdev)); |
| 139 | assert_int_equal(FMAP_SECTION_RW_SECTION_A_START, region_device_offset(&rdev)); |
| 140 | assert_int_equal(FMAP_SECTION_RW_SECTION_A_SIZE, region_device_sz(&rdev)); |
| 141 | |
| 142 | assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("MISC_RW", &rdev)); |
| 143 | assert_int_equal(FMAP_SECTION_MISC_RW_START, region_device_offset(&rdev)); |
| 144 | assert_int_equal(FMAP_SECTION_MISC_RW_SIZE, region_device_sz(&rdev)); |
| 145 | |
| 146 | |
| 147 | /* Expect error when looking for incorrect area */ |
| 148 | assert_int_equal(-1, fmap_locate_area_as_rdev_rw("NONEXISTENT_AREA", &rdev)); |
| 149 | assert_int_equal(-1, fmap_locate_area_as_rdev_rw("", &rdev)); |
| 150 | |
| 151 | /* Expect error when passing invalid references */ |
| 152 | assert_int_equal(-1, fmap_locate_area_as_rdev_rw(NULL, &rdev)); |
| 153 | |
| 154 | /* Function fmap_locate_area_as_rdev_rw is not tested with NULL |
| 155 | as region_device pointer as it is not allowed. */ |
| 156 | |
| 157 | /* Test if returned section region device is writable */ |
| 158 | assert_int_not_equal(-1, fmap_locate_area_as_rdev_rw("MISC_RW", &rdev)); |
| 159 | assert_int_equal(ro_rw_section_size, |
| 160 | rdev_readat(&rdev, buffer1, 0, ro_rw_section_size)); |
| 161 | assert_int_equal(ro_rw_section_size, |
| 162 | rdev_writeat(&rdev, dummy_data, 0, ro_rw_section_size)); |
| 163 | /* Check if written data is visible and correct after locating area as RO */ |
| 164 | assert_int_not_equal(-1, fmap_locate_area_as_rdev("MISC_RW", &rdev)); |
| 165 | assert_int_equal(ro_rw_section_size, |
| 166 | rdev_readat(&rdev, buffer2, 0, ro_rw_section_size)); |
| 167 | assert_memory_not_equal(buffer1, buffer2, ro_rw_section_size); |
| 168 | assert_memory_equal(dummy_data, buffer2, ro_rw_section_size); |
| 169 | |
| 170 | free(buffer1); |
| 171 | free(buffer2); |
| 172 | free(dummy_data); |
| 173 | } |
| 174 | |
| 175 | static void test_fmap_locate_area(void **state) |
| 176 | { |
| 177 | struct region ar; |
| 178 | |
| 179 | /* Try to locate named area */ |
| 180 | assert_int_not_equal(-1, fmap_locate_area("COREBOOT", &ar)); |
| 181 | assert_int_equal(FMAP_SECTION_COREBOOT_START, region_offset(&ar)); |
| 182 | assert_int_equal(FMAP_SECTION_COREBOOT_SIZE, region_sz(&ar)); |
| 183 | |
| 184 | /* Check if locating area second time works */ |
| 185 | assert_int_not_equal(-1, fmap_locate_area("COREBOOT", &ar)); |
| 186 | assert_int_equal(FMAP_SECTION_COREBOOT_START, region_offset(&ar)); |
| 187 | assert_int_equal(FMAP_SECTION_COREBOOT_SIZE, region_sz(&ar)); |
| 188 | |
| 189 | /* Look for another area */ |
| 190 | assert_int_not_equal(-1, fmap_locate_area("GBB", &ar)); |
| 191 | assert_int_equal(FMAP_SECTION_GBB_START, region_offset(&ar)); |
| 192 | assert_int_equal(FMAP_SECTION_GBB_SIZE, region_sz(&ar)); |
| 193 | |
| 194 | /* Expect error when looking for incorrect area */ |
| 195 | assert_int_equal(-1, fmap_locate_area("NONEXISTENT_AREA", &ar)); |
| 196 | assert_int_equal(-1, fmap_locate_area("", &ar)); |
| 197 | assert_int_equal(-1, fmap_locate_area(NULL, &ar)); |
| 198 | |
| 199 | /* Expect error when passing invalid region pointer */ |
| 200 | assert_int_equal(-1, fmap_locate_area("SHARED_DATA", NULL)); |
| 201 | } |
| 202 | |
| 203 | static void test_fmap_find_region_name(void **state) |
| 204 | { |
| 205 | (void)state; |
| 206 | struct region ar; |
| 207 | char found_area_name[FMAP_STRLEN] = ""; |
| 208 | const char *area_name = "RW_PRESERVE"; |
| 209 | |
| 210 | /* Find area by name */ |
| 211 | assert_int_not_equal(-1, fmap_locate_area(area_name, &ar)); |
| 212 | |
| 213 | /* Find name of previously located region */ |
| 214 | assert_int_not_equal(-1, fmap_find_region_name(&ar, found_area_name)); |
| 215 | assert_string_equal(area_name, found_area_name); |
| 216 | |
| 217 | /* Expect error when passing invalid buffer */ |
| 218 | assert_int_equal(-1, fmap_find_region_name(&ar, NULL)); |
| 219 | |
| 220 | /* Expect error when passing invalid region pointer */ |
| 221 | assert_int_equal(-1, fmap_find_region_name(NULL, found_area_name)); |
| 222 | |
| 223 | /* Try to find area outside of flash region */ |
| 224 | ar.offset = FMAP_SECTION_FLASH_START + FMAP_SECTION_FLASH_SIZE + 0x100; |
| 225 | ar.size = 0x1000; |
| 226 | assert_int_equal(-1, fmap_find_region_name(&ar, found_area_name)); |
| 227 | |
| 228 | /* Try to find area with correct offset and incorrect size */ |
| 229 | ar.offset = FMAP_SECTION_COREBOOT_START; |
| 230 | ar.size = FMAP_SECTION_COREBOOT_SIZE / 4; |
| 231 | assert_int_equal(-1, fmap_find_region_name(&ar, found_area_name)); |
| 232 | |
| 233 | /* Try to find area with correct size and incorrect offset */ |
| 234 | ar.offset = FMAP_SECTION_GBB_START - 0x100; |
| 235 | ar.size = FMAP_SECTION_GBB_START; |
| 236 | assert_int_equal(-1, fmap_find_region_name(&ar, found_area_name)); |
| 237 | |
| 238 | /* Try to find area with correct offset overlapping with another area */ |
| 239 | ar.offset = FMAP_SECTION_MISC_RW_START; |
| 240 | ar.size = FMAP_SECTION_MISC_RW_START + 0x1000; |
| 241 | assert_int_equal(-1, fmap_find_region_name(&ar, found_area_name)); |
| 242 | } |
| 243 | |
| 244 | static void test_fmap_read_area(void **state) |
| 245 | { |
| 246 | const unsigned int section_size = FMAP_SECTION_RW_SECTION_A_SIZE; |
| 247 | const unsigned int section_start = FMAP_SECTION_RW_SECTION_A_START; |
| 248 | char *buffer = malloc(section_size); |
| 249 | |
| 250 | /* Find and read area data. Compare with memory device simulating flash. */ |
| 251 | assert_int_equal(section_size, fmap_read_area("RW_SECTION_A", buffer, section_size)); |
| 252 | assert_memory_equal(flash_buffer + section_start, buffer, section_size); |
| 253 | |
| 254 | /* Expect error when reading incorrect area */ |
| 255 | assert_int_equal(-1, fmap_read_area("NONEXISTENT_SECTION", buffer, section_size)); |
| 256 | assert_int_equal(-1, fmap_read_area("", buffer, section_size)); |
| 257 | assert_int_equal(-1, fmap_read_area(NULL, buffer, section_size)); |
| 258 | |
| 259 | /* Function fmap_read_area is not tested with NULL |
| 260 | as output buffer pointer as it is not allowed. */ |
| 261 | |
| 262 | free(buffer); |
| 263 | } |
| 264 | |
| 265 | static void test_fmap_overwrite_area(void **state) |
| 266 | { |
| 267 | const char *section_name = "FW_MAIN_A"; |
| 268 | const unsigned int section_size = FMAP_SECTION_FW_MAIN_A_SIZE; |
| 269 | char *buffer1 = malloc(section_size); |
| 270 | char *buffer2 = malloc(section_size); |
| 271 | char *new_data = malloc(section_size / 2); |
| 272 | char *zero_buffer = malloc(section_size / 2); |
| 273 | memset(zero_buffer, 0, section_size / 2); |
| 274 | memset(new_data, 0x42, section_size / 2); |
| 275 | |
| 276 | /* Save buffer for future comparisons */ |
| 277 | assert_int_equal(section_size, fmap_read_area(section_name, buffer1, section_size)); |
| 278 | |
| 279 | /* Overwrite part of section. */ |
| 280 | assert_int_equal(section_size / 2, |
| 281 | fmap_overwrite_area(section_name, new_data, section_size / 2)); |
| 282 | |
| 283 | /* Read and check if memory has changed as expected */ |
| 284 | assert_int_equal(section_size, fmap_read_area(section_name, buffer2, section_size)); |
| 285 | assert_memory_not_equal(buffer1, buffer2, section_size); |
| 286 | /* Check if requested section area was overwritten properly */ |
| 287 | assert_memory_equal(buffer2, new_data, section_size / 2); |
| 288 | /* Check if rest of section was zero-filled */ |
| 289 | assert_memory_equal(buffer2 + (section_size / 2), zero_buffer, section_size / 2); |
| 290 | |
| 291 | /* Expect error when overwriting incorrect section */ |
| 292 | assert_int_equal(-1, fmap_overwrite_area("NONEXISTENT_SECTION", |
| 293 | new_data, section_size / 2)); |
| 294 | assert_int_equal(-1, fmap_overwrite_area(NULL, new_data, section_size / 2)); |
| 295 | |
| 296 | /* Function fmap_overwrite_area is not tested with NULL |
| 297 | as input buffer pointer as it is not allowed. */ |
| 298 | |
| 299 | free(buffer1); |
| 300 | free(buffer2); |
| 301 | free(new_data); |
| 302 | free(zero_buffer); |
| 303 | } |
| 304 | |
| 305 | int main(void) |
| 306 | { |
| 307 | const struct CMUnitTest tests[] = { |
| 308 | cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev, |
| 309 | setup_fmap, teardown_fmap), |
| 310 | cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev_rw, |
| 311 | setup_fmap, teardown_fmap), |
| 312 | cmocka_unit_test_setup_teardown(test_fmap_locate_area, |
| 313 | setup_fmap, teardown_fmap), |
| 314 | cmocka_unit_test_setup_teardown(test_fmap_find_region_name, |
| 315 | setup_fmap, teardown_fmap), |
| 316 | cmocka_unit_test_setup_teardown(test_fmap_read_area, |
| 317 | setup_fmap, teardown_fmap), |
| 318 | cmocka_unit_test_setup_teardown(test_fmap_overwrite_area, |
| 319 | setup_fmap, teardown_fmap), |
| 320 | }; |
| 321 | |
| 322 | return cmocka_run_group_tests(tests, NULL, NULL); |
| 323 | } |