Sean Anderson | 59b3633 | 2023-10-14 16:48:00 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
| 2 | /* |
| 3 | * Copyright (C) 2023 Sean Anderson <seanga2@gmail.com> |
| 4 | */ |
| 5 | |
| 6 | #include <common.h> |
| 7 | #include <blk.h> |
| 8 | #include <ext_common.h> |
| 9 | #include <ext4fs.h> |
| 10 | #include <fat.h> |
| 11 | #include <fs.h> |
| 12 | #include <memalign.h> |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 13 | #include <spl.h> |
Sean Anderson | 59b3633 | 2023-10-14 16:48:00 -0400 | [diff] [blame] | 14 | #include <asm/io.h> |
| 15 | #include <linux/stat.h> |
| 16 | #include <test/spl.h> |
| 17 | #include <test/ut.h> |
| 18 | |
| 19 | /** |
| 20 | * create_ext2() - Create an "ext2" filesystem with a single file |
| 21 | * @dst: The location of the new filesystem; MUST be zeroed |
| 22 | * @size: The size of the file |
| 23 | * @filename: The name of the file |
| 24 | * @data_offset: Filled with the offset of the file data from @dst |
| 25 | * |
| 26 | * Budget mke2fs. We use 1k blocks (to reduce overhead) with a single block |
| 27 | * group, which limits us to 8M of data. Almost every feature which increases |
| 28 | * complexity (checksums, hash tree directories, etc.) is disabled. We do cheat |
| 29 | * a little and use extents from ext4 to save having to deal with indirects, but |
| 30 | * U-Boot doesn't care. |
| 31 | * |
| 32 | * If @dst is %NULL, nothing is copied. |
| 33 | * |
| 34 | * Return: The size of the filesystem in bytes |
| 35 | */ |
| 36 | static size_t create_ext2(void *dst, size_t size, const char *filename, |
| 37 | size_t *data_offset) |
| 38 | { |
| 39 | u32 super_block = 1; |
| 40 | u32 group_block = 2; |
| 41 | u32 block_bitmap_block = 3; |
| 42 | u32 inode_bitmap_block = 4; |
| 43 | u32 inode_table_block = 5; |
| 44 | u32 root_block = 6; |
| 45 | u32 file_block = 7; |
| 46 | |
| 47 | u32 root_ino = EXT2_ROOT_INO; |
| 48 | u32 file_ino = EXT2_BOOT_LOADER_INO; |
| 49 | |
| 50 | u32 block_size = EXT2_MIN_BLOCK_SIZE; |
| 51 | u32 inode_size = sizeof(struct ext2_inode); |
| 52 | |
| 53 | u32 file_blocks = (size + block_size - 1) / block_size; |
| 54 | u32 blocks = file_block + file_blocks; |
| 55 | u32 inodes = block_size / inode_size; |
| 56 | u32 filename_len = strlen(filename); |
| 57 | u32 dirent_len = ALIGN(filename_len, sizeof(struct ext2_dirent)) + |
| 58 | sizeof(struct ext2_dirent); |
| 59 | |
| 60 | struct ext2_sblock *sblock = dst + super_block * block_size; |
| 61 | struct ext2_block_group *bg = dst + group_block * block_size; |
| 62 | struct ext2_inode *inode_table = dst + inode_table_block * block_size; |
| 63 | struct ext2_inode *root_inode = &inode_table[root_ino - 1]; |
| 64 | struct ext2_inode *file_inode = &inode_table[file_ino - 1]; |
| 65 | struct ext4_extent_header *ext_block = (void *)&file_inode->b; |
| 66 | struct ext4_extent *extent = (void *)(ext_block + 1); |
| 67 | struct ext2_dirent *dot = dst + root_block * block_size; |
| 68 | struct ext2_dirent *dotdot = dot + 2; |
| 69 | struct ext2_dirent *dirent = dotdot + 2; |
| 70 | struct ext2_dirent *last = ((void *)dirent) + dirent_len; |
| 71 | |
| 72 | /* Make sure we fit in one block group */ |
| 73 | if (blocks > block_size * 8) |
| 74 | return 0; |
| 75 | |
| 76 | if (filename_len > EXT2_NAME_LEN) |
| 77 | return 0; |
| 78 | |
| 79 | if (data_offset) |
| 80 | *data_offset = file_block * block_size; |
| 81 | |
| 82 | if (!dst) |
| 83 | goto out; |
| 84 | |
| 85 | sblock->total_inodes = cpu_to_le32(inodes); |
| 86 | sblock->total_blocks = cpu_to_le32(blocks); |
| 87 | sblock->first_data_block = cpu_to_le32(super_block); |
| 88 | sblock->blocks_per_group = cpu_to_le32(blocks); |
| 89 | sblock->fragments_per_group = cpu_to_le32(blocks); |
| 90 | sblock->inodes_per_group = cpu_to_le32(inodes); |
| 91 | sblock->magic = cpu_to_le16(EXT2_MAGIC); |
| 92 | /* Done mostly so we can pretend to be (in)compatible */ |
| 93 | sblock->revision_level = cpu_to_le32(EXT2_DYNAMIC_REV); |
| 94 | /* Not really accurate but it doesn't matter */ |
| 95 | sblock->first_inode = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO); |
| 96 | sblock->inode_size = cpu_to_le32(inode_size); |
| 97 | sblock->feature_incompat = cpu_to_le32(EXT4_FEATURE_INCOMPAT_EXTENTS); |
| 98 | |
| 99 | bg->block_id = cpu_to_le32(block_bitmap_block); |
| 100 | bg->inode_id = cpu_to_le32(inode_bitmap_block); |
| 101 | bg->inode_table_id = cpu_to_le32(inode_table_block); |
| 102 | |
| 103 | /* |
| 104 | * All blocks/inodes are in-use. I don't want to have to deal with |
| 105 | * endianness, so just fill everything in. |
| 106 | */ |
| 107 | memset(dst + block_bitmap_block * block_size, 0xff, block_size * 2); |
| 108 | |
| 109 | root_inode->mode = cpu_to_le16(S_IFDIR | 0755); |
| 110 | root_inode->size = cpu_to_le32(block_size); |
| 111 | root_inode->nlinks = cpu_to_le16(3); |
| 112 | root_inode->blockcnt = cpu_to_le32(1); |
| 113 | root_inode->flags = cpu_to_le32(EXT4_TOPDIR_FL); |
| 114 | root_inode->b.blocks.dir_blocks[0] = root_block; |
| 115 | |
| 116 | file_inode->mode = cpu_to_le16(S_IFREG | 0644); |
| 117 | file_inode->size = cpu_to_le32(size); |
| 118 | file_inode->nlinks = cpu_to_le16(1); |
| 119 | file_inode->blockcnt = cpu_to_le32(file_blocks); |
| 120 | file_inode->flags = cpu_to_le32(EXT4_EXTENTS_FL); |
| 121 | ext_block->eh_magic = cpu_to_le16(EXT4_EXT_MAGIC); |
| 122 | ext_block->eh_entries = cpu_to_le16(1); |
| 123 | ext_block->eh_max = cpu_to_le16(sizeof(file_inode->b) / |
| 124 | sizeof(*ext_block) - 1); |
| 125 | extent->ee_len = cpu_to_le16(file_blocks); |
| 126 | extent->ee_start_lo = cpu_to_le16(file_block); |
| 127 | |
| 128 | /* I'm not sure we need these, but it can't hurt */ |
| 129 | dot->inode = cpu_to_le32(root_ino); |
| 130 | dot->direntlen = cpu_to_le16(2 * sizeof(*dot)); |
| 131 | dot->namelen = 1; |
| 132 | dot->filetype = FILETYPE_DIRECTORY; |
| 133 | memcpy(dot + 1, ".", dot->namelen); |
| 134 | |
| 135 | dotdot->inode = cpu_to_le32(root_ino); |
| 136 | dotdot->direntlen = cpu_to_le16(2 * sizeof(*dotdot)); |
| 137 | dotdot->namelen = 2; |
| 138 | dotdot->filetype = FILETYPE_DIRECTORY; |
| 139 | memcpy(dotdot + 1, "..", dotdot->namelen); |
| 140 | |
| 141 | dirent->inode = cpu_to_le32(file_ino); |
| 142 | dirent->direntlen = cpu_to_le16(dirent_len); |
| 143 | dirent->namelen = filename_len; |
| 144 | dirent->filetype = FILETYPE_REG; |
| 145 | memcpy(dirent + 1, filename, filename_len); |
| 146 | |
| 147 | last->direntlen = block_size - dirent_len; |
| 148 | |
| 149 | out: |
| 150 | return (size_t)blocks * block_size; |
| 151 | } |
| 152 | |
| 153 | /** |
| 154 | * create_fat() - Create a FAT32 filesystem with a single file |
| 155 | * @dst: The location of the new filesystem; MUST be zeroed |
| 156 | * @size: The size of the file |
| 157 | * @filename: The name of the file |
| 158 | * @data_offset: Filled with the offset of the file data from @dst |
| 159 | * |
| 160 | * Budget mkfs.fat. We use FAT32 (so I don't have to deal with FAT12) with no |
| 161 | * info sector, and a single one-sector FAT. This limits us to 64k of data |
| 162 | * (enough for anyone). The filename must fit in 8.3. |
| 163 | * |
| 164 | * If @dst is %NULL, nothing is copied. |
| 165 | * |
| 166 | * Return: The size of the filesystem in bytes |
| 167 | */ |
| 168 | static size_t create_fat(void *dst, size_t size, const char *filename, |
| 169 | size_t *data_offset) |
| 170 | { |
| 171 | u16 boot_sector = 0; |
| 172 | u16 fat_sector = 1; |
| 173 | u32 root_sector = 2; |
| 174 | u32 file_sector = 3; |
| 175 | |
| 176 | u16 sector_size = 512; |
| 177 | u32 file_sectors = (size + sector_size - 1) / sector_size; |
| 178 | u32 sectors = file_sector + file_sectors; |
| 179 | |
| 180 | char *ext; |
| 181 | size_t filename_len, ext_len; |
| 182 | int i; |
| 183 | |
| 184 | struct boot_sector *bs = dst + boot_sector * sector_size; |
| 185 | struct volume_info *vi = (void *)(bs + 1); |
| 186 | __le32 *fat = dst + fat_sector * sector_size; |
| 187 | struct dir_entry *dirent = dst + root_sector * sector_size; |
| 188 | |
| 189 | /* Make sure we fit in the FAT */ |
| 190 | if (sectors > sector_size / sizeof(u32)) |
| 191 | return 0; |
| 192 | |
| 193 | ext = strchr(filename, '.'); |
| 194 | if (ext) { |
| 195 | filename_len = ext - filename; |
| 196 | ext++; |
| 197 | ext_len = strlen(ext); |
| 198 | } else { |
| 199 | filename_len = strlen(filename); |
| 200 | ext_len = 0; |
| 201 | } |
| 202 | |
| 203 | if (filename_len > 8 || ext_len > 3) |
| 204 | return 0; |
| 205 | |
| 206 | if (data_offset) |
| 207 | *data_offset = file_sector * sector_size; |
| 208 | |
| 209 | if (!dst) |
| 210 | goto out; |
| 211 | |
| 212 | bs->sector_size[0] = sector_size & 0xff; |
| 213 | bs->sector_size[1] = sector_size >> 8; |
| 214 | bs->cluster_size = 1; |
| 215 | bs->reserved = cpu_to_le16(fat_sector); |
| 216 | bs->fats = 1; |
| 217 | bs->media = 0xf8; |
| 218 | bs->total_sect = cpu_to_le32(sectors); |
| 219 | bs->fat32_length = cpu_to_le32(1); |
| 220 | bs->root_cluster = cpu_to_le32(root_sector); |
| 221 | |
| 222 | vi->ext_boot_sign = 0x29; |
| 223 | memcpy(vi->fs_type, FAT32_SIGN, sizeof(vi->fs_type)); |
| 224 | |
| 225 | memcpy(dst + 0x1fe, "\x55\xAA", 2); |
| 226 | |
| 227 | fat[0] = cpu_to_le32(0x0ffffff8); |
| 228 | fat[1] = cpu_to_le32(0x0fffffff); |
| 229 | fat[2] = cpu_to_le32(0x0ffffff8); |
| 230 | for (i = file_sector; file_sectors > 1; file_sectors--, i++) |
| 231 | fat[i] = cpu_to_le32(i + 1); |
| 232 | fat[i] = cpu_to_le32(0x0ffffff8); |
| 233 | |
| 234 | for (i = 0; i < sizeof(dirent->nameext.name); i++) { |
| 235 | if (i < filename_len) |
| 236 | dirent->nameext.name[i] = toupper(filename[i]); |
| 237 | else |
| 238 | dirent->nameext.name[i] = ' '; |
| 239 | } |
| 240 | |
| 241 | for (i = 0; i < sizeof(dirent->nameext.ext); i++) { |
| 242 | if (i < ext_len) |
| 243 | dirent->nameext.ext[i] = toupper(ext[i]); |
| 244 | else |
| 245 | dirent->nameext.ext[i] = ' '; |
| 246 | } |
| 247 | |
| 248 | dirent->start = cpu_to_le16(file_sector); |
| 249 | dirent->size = cpu_to_le32(size); |
| 250 | |
| 251 | out: |
| 252 | return sectors * sector_size; |
| 253 | } |
| 254 | |
| 255 | typedef size_t (*create_fs_t)(void *, size_t, const char *, size_t *); |
| 256 | |
| 257 | static int spl_test_fs(struct unit_test_state *uts, const char *test_name, |
| 258 | create_fs_t create) |
| 259 | { |
| 260 | const char *filename = CONFIG_SPL_FS_LOAD_PAYLOAD_NAME; |
| 261 | struct blk_desc *dev_desc; |
| 262 | char *data_write, *data_read; |
| 263 | void *fs; |
| 264 | size_t fs_size, fs_data, fs_blocks, data_size = SPL_TEST_DATA_SIZE; |
| 265 | loff_t actread; |
| 266 | |
| 267 | fs_size = create(NULL, data_size, filename, &fs_data); |
| 268 | ut_assert(fs_size); |
| 269 | fs = calloc(fs_size, 1); |
| 270 | ut_assertnonnull(fs); |
| 271 | |
| 272 | data_write = fs + fs_data; |
| 273 | generate_data(data_write, data_size, test_name); |
| 274 | ut_asserteq(fs_size, create(fs, data_size, filename, NULL)); |
| 275 | |
| 276 | dev_desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, 0); |
| 277 | ut_assertnonnull(dev_desc); |
| 278 | ut_asserteq(512, dev_desc->blksz); |
| 279 | fs_blocks = fs_size / dev_desc->blksz; |
| 280 | ut_asserteq(fs_blocks, blk_dwrite(dev_desc, 0, fs_blocks, fs)); |
| 281 | |
| 282 | /* We have to use malloc so we can call virt_to_phys */ |
| 283 | data_read = malloc_cache_aligned(data_size); |
| 284 | ut_assertnonnull(data_read); |
| 285 | ut_assertok(fs_set_blk_dev_with_part(dev_desc, 0)); |
| 286 | ut_assertok(fs_read("/" CONFIG_SPL_FS_LOAD_PAYLOAD_NAME, |
| 287 | virt_to_phys(data_read), 0, data_size, &actread)); |
| 288 | ut_asserteq(data_size, actread); |
| 289 | ut_asserteq_mem(data_write, data_read, data_size); |
| 290 | |
| 291 | free(data_read); |
| 292 | free(fs); |
| 293 | return 0; |
| 294 | } |
| 295 | |
| 296 | static int spl_test_ext(struct unit_test_state *uts) |
| 297 | { |
| 298 | return spl_test_fs(uts, __func__, create_ext2); |
| 299 | } |
| 300 | SPL_TEST(spl_test_ext, DM_FLAGS); |
| 301 | |
| 302 | static int spl_test_fat(struct unit_test_state *uts) |
| 303 | { |
| 304 | spl_fat_force_reregister(); |
| 305 | return spl_test_fs(uts, __func__, create_fat); |
| 306 | } |
| 307 | SPL_TEST(spl_test_fat, DM_FLAGS); |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 308 | |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 309 | static bool spl_mmc_raw; |
| 310 | |
| 311 | u32 spl_mmc_boot_mode(struct mmc *mmc, const u32 boot_device) |
| 312 | { |
| 313 | return spl_mmc_raw ? MMCSD_MODE_RAW : MMCSD_MODE_FS; |
| 314 | } |
| 315 | |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 316 | static int spl_test_mmc_fs(struct unit_test_state *uts, const char *test_name, |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 317 | enum spl_test_image type, create_fs_t create_fs, |
| 318 | bool blk_mode) |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 319 | { |
| 320 | const char *filename = CONFIG_SPL_FS_LOAD_PAYLOAD_NAME; |
| 321 | struct blk_desc *dev_desc; |
| 322 | size_t fs_size, fs_data, img_size, img_data, |
| 323 | data_size = SPL_TEST_DATA_SIZE; |
| 324 | struct spl_image_info info_write = { |
| 325 | .name = test_name, |
| 326 | .size = data_size, |
| 327 | }, info_read = { }; |
| 328 | struct disk_partition part = { |
| 329 | .start = 1, |
| 330 | .sys_ind = 0x83, |
| 331 | }; |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 332 | struct spl_image_loader *loader = |
| 333 | SPL_LOAD_IMAGE_GET(0, BOOT_DEVICE_MMC1, spl_mmc_load_image); |
| 334 | struct spl_boot_device bootdev = { |
| 335 | .boot_device = loader->boot_device, |
| 336 | }; |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 337 | void *fs; |
| 338 | char *data; |
| 339 | |
| 340 | img_size = create_image(NULL, type, &info_write, &img_data); |
| 341 | ut_assert(img_size); |
| 342 | fs_size = create_fs(NULL, img_size, filename, &fs_data); |
| 343 | ut_assert(fs_size); |
| 344 | fs = calloc(fs_size, 1); |
| 345 | ut_assertnonnull(fs); |
| 346 | |
| 347 | data = fs + fs_data + img_data; |
| 348 | generate_data(data, data_size, test_name); |
| 349 | ut_asserteq(img_size, create_image(fs + fs_data, type, &info_write, |
| 350 | NULL)); |
| 351 | ut_asserteq(fs_size, create_fs(fs, img_size, filename, NULL)); |
| 352 | |
| 353 | dev_desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, 0); |
| 354 | ut_assertnonnull(dev_desc); |
| 355 | |
| 356 | ut_asserteq(512, dev_desc->blksz); |
| 357 | part.size = fs_size / dev_desc->blksz; |
| 358 | ut_assertok(write_mbr_partitions(dev_desc, &part, 1, 0)); |
| 359 | ut_asserteq(part.size, blk_dwrite(dev_desc, part.start, part.size, fs)); |
| 360 | |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 361 | spl_mmc_raw = false; |
| 362 | if (blk_mode) |
| 363 | ut_assertok(spl_blk_load_image(&info_read, &bootdev, UCLASS_MMC, |
| 364 | 0, 1)); |
| 365 | else |
| 366 | ut_assertok(loader->load_image(&info_read, &bootdev)); |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 367 | if (check_image_info(uts, &info_write, &info_read)) |
| 368 | return CMD_RET_FAILURE; |
| 369 | ut_asserteq_mem(data, phys_to_virt(info_write.load_addr), data_size); |
| 370 | |
| 371 | free(fs); |
| 372 | return 0; |
| 373 | } |
| 374 | |
| 375 | static int spl_test_blk(struct unit_test_state *uts, const char *test_name, |
| 376 | enum spl_test_image type) |
| 377 | { |
| 378 | spl_fat_force_reregister(); |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 379 | if (spl_test_mmc_fs(uts, test_name, type, create_fat, true)) |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 380 | return CMD_RET_FAILURE; |
| 381 | |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 382 | return spl_test_mmc_fs(uts, test_name, type, create_ext2, true); |
Sean Anderson | 6c5d0d9 | 2023-10-14 16:48:01 -0400 | [diff] [blame] | 383 | } |
| 384 | SPL_IMG_TEST(spl_test_blk, LEGACY, DM_FLAGS); |
| 385 | SPL_IMG_TEST(spl_test_blk, FIT_EXTERNAL, DM_FLAGS); |
| 386 | SPL_IMG_TEST(spl_test_blk, FIT_INTERNAL, DM_FLAGS); |
Sean Anderson | 6ba8eca | 2023-10-14 16:48:02 -0400 | [diff] [blame] | 387 | |
| 388 | static int spl_test_mmc_write_image(struct unit_test_state *uts, void *img, |
| 389 | size_t img_size) |
| 390 | { |
| 391 | struct blk_desc *dev_desc; |
| 392 | size_t img_blocks; |
| 393 | |
| 394 | dev_desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, 0); |
| 395 | ut_assertnonnull(dev_desc); |
| 396 | |
| 397 | img_blocks = DIV_ROUND_UP(img_size, dev_desc->blksz); |
| 398 | ut_asserteq(img_blocks, blk_dwrite(dev_desc, |
| 399 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR, |
| 400 | img_blocks, img)); |
| 401 | |
| 402 | spl_mmc_raw = true; |
| 403 | return 0; |
| 404 | } |
| 405 | |
| 406 | static int spl_test_mmc(struct unit_test_state *uts, const char *test_name, |
| 407 | enum spl_test_image type) |
| 408 | { |
| 409 | spl_mmc_clear_cache(); |
| 410 | spl_fat_force_reregister(); |
| 411 | |
| 412 | if (type == LEGACY && |
| 413 | spl_test_mmc_fs(uts, test_name, type, create_ext2, false)) |
| 414 | return CMD_RET_FAILURE; |
| 415 | |
| 416 | if (type != IMX8 && |
| 417 | spl_test_mmc_fs(uts, test_name, type, create_fat, false)) |
| 418 | return CMD_RET_FAILURE; |
| 419 | |
| 420 | return do_spl_test_load(uts, test_name, type, |
| 421 | SPL_LOAD_IMAGE_GET(0, BOOT_DEVICE_MMC1, |
| 422 | spl_mmc_load_image), |
| 423 | spl_test_mmc_write_image); |
| 424 | } |
| 425 | SPL_IMG_TEST(spl_test_mmc, LEGACY, DM_FLAGS); |
| 426 | SPL_IMG_TEST(spl_test_mmc, IMX8, DM_FLAGS); |
| 427 | SPL_IMG_TEST(spl_test_mmc, FIT_EXTERNAL, DM_FLAGS); |
| 428 | SPL_IMG_TEST(spl_test_mmc, FIT_INTERNAL, DM_FLAGS); |