Support crc32c checksums in ext4 filesystems with metadata_csum flag active. This includes superblock, inodes, inode and block group tables, directory blocks and journal.
Signed-off-by: Fredrik Hallenberg megahallon@gmail.com --- fs/ext4/Kconfig | 1 + fs/ext4/ext4_common.c | 91 ++++++++++------- fs/ext4/ext4_common.h | 7 +- fs/ext4/ext4_journal.c | 135 ++++++++++++++++++++----- fs/ext4/ext4_journal.h | 40 +++++++- fs/ext4/ext4_write.c | 162 ++++++++++++++++++++++++++++-- include/ext4fs.h | 7 ++ include/ext_common.h | 77 +++++++++++++- test/py/tests/test_env.py | 3 - test/py/tests/test_fs/conftest.py | 4 - 10 files changed, 441 insertions(+), 86 deletions(-)
diff --git a/fs/ext4/Kconfig b/fs/ext4/Kconfig index 1a913d2b6d..da033428b2 100644 --- a/fs/ext4/Kconfig +++ b/fs/ext4/Kconfig @@ -8,6 +8,7 @@ config FS_EXT4 config EXT4_WRITE bool "Enable ext4 filesystem write support" depends on FS_EXT4 + select CRC32C help This provides support for creating and writing new files to an existing ext4 filesystem partition. diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c index c52cc400e1..6e23e47c97 100644 --- a/fs/ext4/ext4_common.c +++ b/fs/ext4/ext4_common.c @@ -45,6 +45,8 @@ __le32 *ext4fs_indir3_block; int ext4fs_indir3_size; int ext4fs_indir3_blkno = -1; struct ext2_inode *g_parent_inode; +int g_parent_inode_no; + static int symlinknest;
#if defined(CONFIG_EXT4_WRITE) @@ -416,32 +418,6 @@ void ext4fs_reset_inode_bmap(int inode_no, unsigned char *buffer, int index) *ptr = *ptr & ~(operand); }
-uint16_t ext4fs_checksum_update(uint32_t i) -{ - struct ext2_block_group *desc; - struct ext_filesystem *fs = get_fs(); - uint16_t crc = 0; - __le32 le32_i = cpu_to_le32(i); - - desc = ext4fs_get_group_descriptor(fs, i); - if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { - int offset = offsetof(struct ext2_block_group, bg_checksum); - - crc = ext2fs_crc16(~0, fs->sb->unique_id, - sizeof(fs->sb->unique_id)); - crc = ext2fs_crc16(crc, &le32_i, sizeof(le32_i)); - crc = ext2fs_crc16(crc, desc, offset); - offset += sizeof(desc->bg_checksum); /* skip checksum */ - assert(offset == sizeof(*desc)); - if (offset < fs->gdsize) { - crc = ext2fs_crc16(crc, (__u8 *)desc + offset, - fs->gdsize - offset); - } - } - - return crc; -} - static int check_void_in_dentry(struct ext2_dirent *dir, char *filename) { int dentry_length; @@ -472,6 +448,33 @@ static int check_void_in_dentry(struct ext2_dirent *dir, char *filename) return 0; }
+static void ext4fs_set_dirent_tail_csum(struct ext_filesystem *fs, uint8_t *block) +{ + struct ext4_dir_entry_tail *tail; + uint32_t crc32; + uint32_t inode_seed; + __le32 inum = cpu_to_le32(g_parent_inode_no); + __le32 gen = g_parent_inode->generation; + int size; + + if (!(le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + tail = (struct ext4_dir_entry_tail *)(block + fs->blksz + - sizeof(struct ext4_dir_entry_tail)); + if (tail->det_reserved_ft != 0xde) { + printf("Bad dirent tail\n"); + return; + } + + inode_seed = ext4_csum(fs->csum_seed, (uint8_t *)&inum, sizeof(inum)); + inode_seed = ext4_csum(inode_seed, (uint8_t *)&gen, sizeof(gen)); + + size = (uint8_t *)tail - block; + crc32 = ext4_csum(inode_seed, block, size); + tail->det_checksum = cpu_to_le32(crc32); +} + int ext4fs_update_parent_dentry(char *filename, int file_type) { unsigned int *zero_buffer = NULL; @@ -492,6 +495,10 @@ int ext4fs_update_parent_dentry(char *filename, int file_type) uint32_t new_size; uint32_t new_blockcnt; uint32_t directory_blocks; + struct ext4_dir_entry_tail *tail; + int has_metadata_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM ? 1 : 0; + uint32_t max_size = fs->blksz;
zero_buffer = zalloc(fs->blksz); if (!zero_buffer) { @@ -529,12 +536,20 @@ restart_read: dir = (struct ext2_dirent *)root_first_block_buffer; totalbytes = 0;
+ if (has_metadata_chksum) { + tail = (struct ext4_dir_entry_tail *)(root_first_block_buffer + fs->blksz + - sizeof(struct ext4_dir_entry_tail)); + if (tail->det_reserved_ft != 0xde) + printf("Bad dirent tail\n"); + max_size -= sizeof(struct ext4_dir_entry_tail); + } + while (le16_to_cpu(dir->direntlen) > 0) { unsigned short used_len = ROUND(dir->namelen + sizeof(struct ext2_dirent), 4);
/* last entry of block */ - if (fs->blksz - totalbytes == le16_to_cpu(dir->direntlen)) { + if (max_size - totalbytes == le16_to_cpu(dir->direntlen)) {
/* check if new entry fits */ if ((used_len + new_entry_byte_reqd) <= @@ -608,7 +623,7 @@ restart_read: if (sizeof_void_space) dir->direntlen = cpu_to_le16(sizeof_void_space); else - dir->direntlen = cpu_to_le16(fs->blksz - totalbytes); + dir->direntlen = cpu_to_le16(max_size - totalbytes);
dir->namelen = strlen(filename); dir->filetype = file_type; @@ -616,7 +631,8 @@ restart_read: temp_dir = temp_dir + sizeof(struct ext2_dirent); memcpy(temp_dir, filename, strlen(filename));
- /* update or write the 1st block of root inode */ + /* update or write the 1st block of root inode */ + ext4fs_set_dirent_tail_csum(fs, (uint8_t *)root_first_block_buffer); if (ext4fs_put_metadata(root_first_block_buffer, first_block_no_of_root)) goto fail; @@ -925,6 +941,7 @@ static int unlink_filename(char *filename, unsigned int blknr) /* invalidate dir entry */ dir->inode = 0; } + ext4fs_set_dirent_tail_csum(fs, (uint8_t *)block_buffer); if (ext4fs_put_metadata(block_buffer, blknr)) goto fail; ret = inodeno; @@ -1101,6 +1118,8 @@ int ext4fs_get_new_inode_no(void) goto fail; int has_gdt_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM ? 1 : 0; + int has_metadata_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM ? 1 : 0;
if (fs->first_pass_ibmap == 0) { for (i = 0; i < fs->no_blkgrp; i++) { @@ -1112,7 +1131,7 @@ int ext4fs_get_new_inode_no(void) uint16_t bg_flags = ext4fs_bg_get_flags(bgd); uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) bgd->bg_itable_unused = free_inodes; if (bg_flags & EXT4_BG_INODE_UNINIT) { put_ext4(i_bitmap_blk * fs->blksz, @@ -1131,7 +1150,7 @@ int ext4fs_get_new_inode_no(void) (i * inodes_per_grp); fs->first_pass_ibmap++; ext4fs_bg_free_inodes_dec(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) ext4fs_bg_itable_unused_dec(bgd, fs); ext4fs_sb_free_inodes_dec(fs->sb); status = ext4fs_devread(i_bitmap_blk * @@ -1187,7 +1206,7 @@ restart: prev_inode_bitmap_index = ibmap_idx; } ext4fs_bg_free_inodes_dec(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) bgd->bg_itable_unused = bgd->free_inodes; ext4fs_sb_free_inodes_dec(fs->sb); goto success; @@ -1598,7 +1617,7 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode) struct ext2_sblock *sblock = &data->sblock; struct ext_filesystem *fs = get_fs(); int log2blksz = get_fs()->dev_desc->log2blksz; - int inodes_per_block, status; + int inodes_per_block, status, size; long int blkno; unsigned int blkoff;
@@ -1633,9 +1652,9 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode) free(blkgrp);
/* Read the inode. */ + size = min(sizeof(struct ext2_inode), fs->inodesz); status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) - - log2blksz), blkoff, - sizeof(struct ext2_inode), (char *)inode); + log2blksz), blkoff, size, (char *)inode); if (status == 0) return 0;
@@ -2368,7 +2387,7 @@ int ext4fs_mount(unsigned part_length) struct ext2_data *data; int status; struct ext_filesystem *fs = get_fs(); - data = zalloc(SUPERBLOCK_SIZE); + data = zalloc(sizeof(struct ext2_data)); if (!data) return 0;
diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h index beaee9c80b..afcd9a072d 100644 --- a/fs/ext4/ext4_common.h +++ b/fs/ext4/ext4_common.h @@ -41,6 +41,8 @@ #define SUPERBLOCK_SIZE 1024 #define F_FILE 1
+#define EXT4_OLD_INODE_SIZE 128 + static inline void *zalloc(size_t size) { void *p = memalign(ARCH_DMA_MINALIGN, size); @@ -59,7 +61,6 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
#if defined(CONFIG_EXT4_WRITE) uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n); -uint16_t ext4fs_checksum_update(unsigned int i); int ext4fs_get_parent_inode_num(const char *dirname, char *dname, int flags); int ext4fs_update_parent_dentry(char *filename, int file_type); uint32_t ext4fs_get_new_blk_no(void); @@ -86,5 +87,9 @@ uint64_t ext4fs_sb_get_free_blocks(const struct ext2_sblock *sb); void ext4fs_sb_set_free_blocks(struct ext2_sblock *sb, uint64_t free_blocks); uint32_t ext4fs_bg_get_free_blocks(const struct ext2_block_group *bg, const struct ext_filesystem *fs); +void ext4fs_set_superblock_csum(struct ext2_sblock *sb); +uint32_t ext4_csum(uint32_t crc, const uint8_t *data, unsigned int length); +void ext4fs_set_journal_superblock_csum(struct journal_superblock_t *sb); + #endif #endif diff --git a/fs/ext4/ext4_journal.c b/fs/ext4/ext4_journal.c index 1a340b4764..aace78a795 100644 --- a/fs/ext4/ext4_journal.c +++ b/fs/ext4/ext4_journal.c @@ -184,6 +184,7 @@ int ext4fs_log_journal(char *journal_buffer, uint32_t blknr) int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr) { struct ext_filesystem *fs = get_fs(); + if (!metadata_buffer) { printf("Invalid input arguments %s\n", __func__); return -EINVAL; @@ -336,6 +337,7 @@ void recover_transaction(int prev_desc_logical_no) int ofs, flags; int i; struct ext3_journal_block_tag *tag; + int tag_size = fs->journal_tag_size; char *temp_buff = zalloc(fs->blksz); char *metadata_buff = zalloc(fs->blksz); if (!temp_buff || !metadata_buff) @@ -353,12 +355,14 @@ void recover_transaction(int prev_desc_logical_no)
do { tag = (struct ext3_journal_block_tag *)(p_jdb + ofs); - ofs += sizeof(struct ext3_journal_block_tag); + ofs += tag_size;
if (ofs > fs->blksz) break;
- flags = be32_to_cpu(tag->flags); + flags = be16_to_cpu(tag->flags); + + /* skip uuid */ if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) ofs += 16;
@@ -388,6 +392,15 @@ void print_jrnl_status(int recovery_flag) printf("Journal Scan Completed\n"); }
+void ext4fs_set_journal_superblock_csum(struct journal_superblock_t *sb) +{ + uint32_t csum; + + sb->s_checksum = 0; + csum = ext4_csum(~0, (uint8_t *)sb, sizeof(struct journal_superblock_t)); + sb->s_checksum = cpu_to_be32(csum); +} + int ext4fs_check_journal_state(int recovery_flag) { int i; @@ -405,9 +418,7 @@ int ext4fs_check_journal_state(int recovery_flag) char *temp_buff = NULL; char *temp_buff1 = NULL; struct ext_filesystem *fs = get_fs(); - - if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) - return 0; + int tag_size = sizeof(struct ext3_journal_block_tag3);
temp_buff = zalloc(fs->blksz); if (!temp_buff) @@ -425,6 +436,11 @@ int ext4fs_check_journal_state(int recovery_flag) temp_buff); jsb = (struct journal_superblock_t *) temp_buff;
+ if (be32_to_cpu(jsb->s_header.h_magic) != EXT3_JOURNAL_MAGIC_NUMBER) { + printf("Bad ext4 journal magic number\n"); + return -ENODEV; + } + if (le32_to_cpu(fs->sb->feature_incompat) & EXT3_FEATURE_INCOMPAT_RECOVER) { if (recovery_flag == RECOVER) printf("Recovery required\n"); @@ -437,10 +453,23 @@ int ext4fs_check_journal_state(int recovery_flag) if (be32_to_cpu(jsb->s_start) == 0) goto end;
- if (!(jsb->s_feature_compat & - cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM))) - jsb->s_feature_compat |= - cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); + fs->journal_csum_seed = ext4_csum(~0, jsb->s_uuid, sizeof(jsb->s_uuid)); + + if (be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_CSUM_V3) { + fs->journal_tag_size = sizeof(struct ext3_journal_block_tag3); + fs->journal_csum_version = 3; + } else { + fs->journal_tag_size = sizeof(struct ext3_journal_block_tag); + fs->journal_csum_version = 0; + if (be32_to_cpu(jsb->s_feature_compat) & JBD2_FEATURE_COMPAT_CHECKSUM) + fs->journal_csum_version = 1; + if (be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_CSUM_V2) { + fs->journal_tag_size += sizeof(uint16_t); + fs->journal_csum_version = 2; + } + if (!(be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_64BIT)) + fs->journal_tag_size -= sizeof(uint32_t); + }
i = be32_to_cpu(jsb->s_first); while (1) { @@ -468,10 +497,11 @@ int ext4fs_check_journal_state(int recovery_flag) do { tag = (struct ext3_journal_block_tag *) (p_jdb + ofs); - ofs += sizeof(struct ext3_journal_block_tag); + ofs += tag_size; if (ofs > fs->blksz) break; - flags = be32_to_cpu(tag->flags); + flags = be16_to_cpu(tag->flags); + /* skip uuid */ if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) ofs += 16; i++; @@ -532,16 +562,15 @@ end: fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
/* Update the super block */ - put_ext4((uint64_t) (SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, - (uint32_t) SUPERBLOCK_SIZE); + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); ext4_read_superblock((char *)fs->sb);
blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK, NULL); + ext4fs_set_journal_superblock_csum(jsb); put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), - (struct journal_superblock_t *)temp_buff, - (uint32_t) fs->blksz); + jsb, (uint32_t)fs->blksz); ext4fs_free_revoke_blks(); } free(temp_buff); @@ -550,18 +579,58 @@ end: return 0; }
+static void descriptor_block_csum_set(const uint8_t *block) +{ + struct ext_filesystem *fs = get_fs(); + struct ext3_journal_block_tail *tail; + __u32 csum; + + if (fs->journal_csum_version < 2) + return; + + tail = (struct ext3_journal_block_tail *)(block + fs->blksz - + sizeof(struct ext3_journal_block_tail)); + tail->t_checksum = 0; + csum = ext4_csum(fs->journal_csum_seed, block, fs->blksz); + tail->t_checksum = cpu_to_be32(csum); +} + +static void block_tag_csum_set(struct ext3_journal_block_tag3 *tag, const uint8_t *data, + uint32_t sequence) +{ + struct ext_filesystem *fs = get_fs(); + struct ext3_journal_block_tag *tag2 = (struct ext3_journal_block_tag *)tag; + uint32_t crc32; + __be32 seq; + + if (fs->journal_csum_version < 2) + return; + + seq = cpu_to_be32(sequence); + crc32 = ext4_csum(fs->journal_csum_seed, (uint8_t *)&seq, sizeof(seq)); + crc32 = ext4_csum(crc32, data, fs->blksz); + + if (fs->journal_csum_version == 3) + tag->checksum = cpu_to_be32(crc32); + else + tag2->checksum = cpu_to_be16(crc32 & 0xffff); +} + static void update_descriptor_block(long int blknr) { int i; long int jsb_blknr; struct journal_header_t jdb; - struct ext3_journal_block_tag tag; + struct ext3_journal_block_tag3 tag; struct ext2_inode inode_journal; struct journal_superblock_t *jsb = NULL; char *buf = NULL; char *temp = NULL; struct ext_filesystem *fs = get_fs(); char *temp_buff = zalloc(fs->blksz); + int tag_size = fs->journal_tag_size; + uint32_t sequence; + if (!temp_buff) return;
@@ -575,6 +644,9 @@ static void update_descriptor_block(long int blknr) jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_DESCRIPTOR_BLOCK); jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER); jdb.h_sequence = jsb->s_sequence; + + sequence = be32_to_cpu(jsb->s_sequence); + buf = zalloc(fs->blksz); if (!buf) { free(temp_buff); @@ -589,16 +661,19 @@ static void update_descriptor_block(long int blknr) break;
tag.block = cpu_to_be32(journal_ptr[i]->blknr); - tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_SAME_UUID); - memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag)); - temp = temp + sizeof(struct ext3_journal_block_tag); + tag.flags = cpu_to_be16(EXT3_JOURNAL_FLAG_SAME_UUID); + block_tag_csum_set(&tag, (uint8_t *)journal_ptr[i]->buf, sequence); + memcpy(temp, &tag, tag_size); + temp = temp + tag_size; }
tag.block = cpu_to_be32(journal_ptr[--i]->blknr); - tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_LAST_TAG); - memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag, - sizeof(struct ext3_journal_block_tag)); - put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz); + tag.flags = cpu_to_be16(EXT3_JOURNAL_FLAG_LAST_TAG); + block_tag_csum_set(&tag, (uint8_t *)journal_ptr[i]->buf, sequence); + memcpy(temp - tag_size, &tag, tag_size); + + descriptor_block_csum_set((uint8_t *)buf); + put_ext4((uint64_t)((uint64_t)blknr * (uint64_t)fs->blksz), buf, fs->blksz);
free(temp_buff); free(buf); @@ -606,7 +681,7 @@ static void update_descriptor_block(long int blknr)
static void update_commit_block(long int blknr) { - struct journal_header_t jdb; + struct ext3_journal_commit_header jdb; struct ext_filesystem *fs = get_fs(); char *buf = NULL; struct ext2_inode inode_journal; @@ -632,7 +707,15 @@ static void update_commit_block(long int blknr) free(temp_buff); return; } - memcpy(buf, &jdb, sizeof(struct journal_header_t)); + + if (fs->journal_csum_version > 1) { + uint32_t csum = ext4_csum(fs->journal_csum_seed, (uint8_t *)temp_buff, fs->blksz); + + jdb.h_chksum[0] = cpu_to_be32(csum); + } + + memcpy(buf, &jdb, sizeof(struct ext3_journal_commit_header)); + put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz);
free(temp_buff); diff --git a/fs/ext4/ext4_journal.h b/fs/ext4/ext4_journal.h index 43fb8e7664..9bdbf66971 100644 --- a/fs/ext4/ext4_journal.h +++ b/fs/ext4/ext4_journal.h @@ -22,7 +22,6 @@ #define EXT2_JOURNAL_INO 8 /* Journal inode */ #define EXT2_JOURNAL_SUPERBLOCK 0 /* Journal Superblock number */
-#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 #define EXT3_JOURNAL_MAGIC_NUMBER 0xc03b3998U #define TRANSACTION_RUNNING 1 #define TRANSACTION_COMPLETE 0 @@ -37,6 +36,14 @@ #define EXT3_JOURNAL_FLAG_DELETED 4 #define EXT3_JOURNAL_FLAG_LAST_TAG 8
+#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 + +#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001 +#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002 +#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004 +#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008 +#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010 + /* Maximum entries in 1 journal transaction */ #define MAX_JOURNAL_ENTRIES 100 struct journal_log { @@ -90,16 +97,45 @@ struct journal_superblock_t { __be32 s_max_trans_data; /* Limit of data blocks per trans. */
/* 0x0050 */ - __be32 s_padding[44]; + __u8 s_checksum_type; /* checksum type */ + __u8 s_padding2[3]; + __u32 s_padding[42]; + __be32 s_checksum; /* crc32c(superblock) */
/* 0x0100 */ __u8 s_users[16 * 48]; /* ids of all fs'es sharing the log */ /* 0x0400 */ } ;
+struct ext3_journal_commit_header { + __be32 h_magic; + __be32 h_blocktype; + __be32 h_sequence; + unsigned char h_chksum_type; + unsigned char h_chksum_size; + unsigned char h_padding[2]; + __be32 h_chksum[8]; + __be64 h_commit_sec; + __be32 h_commit_nsec; +}; + struct ext3_journal_block_tag { + __be32 block; + __be16 checksum; /* truncated crc32c(uuid+seq+block) */ + __be16 flags; + __be32 blocknr_high; /* only used when INCOMPAT_64BIT is set */ +}; + +/* Use if FEATURE_INCOMPAT_CSUM_V3 is set */ +struct ext3_journal_block_tag3 { __be32 block; __be32 flags; + __be32 blocknr_high; + __be32 checksum; /* crc32c(uuid+seq+block) */ +}; + +struct ext3_journal_block_tail { + __be32 t_checksum; /* crc32c(uuid+descr_block) */ };
struct journal_revoke_header_t { diff --git a/fs/ext4/ext4_write.c b/fs/ext4/ext4_write.c index f22af45d1b..fc248c0bc2 100644 --- a/fs/ext4/ext4_write.c +++ b/fs/ext4/ext4_write.c @@ -30,6 +30,7 @@ #include <linux/stat.h> #include <div64.h> #include "ext4_common.h" +#include <u-boot/crc.h>
static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb) { @@ -67,6 +68,139 @@ static inline void ext4fs_bg_free_blocks_inc bg->free_blocks_high = cpu_to_le16(free_blocks >> 16); }
+uint32_t ext4_csum(uint32_t crc, const uint8_t *data, unsigned int length) +{ + static uint32_t table[256]; + static int init; + + if (!init) { + crc32c_init(table, 0x82f63b78); + init = 1; + } + + return crc32c_cal(crc, (const char *)data, length, table); +} + +void ext4fs_set_superblock_csum(struct ext2_sblock *sb) +{ + int offset; + + if (!(le32_to_cpu(sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + offset = offsetof(struct ext2_sblock, checksum); + sb->checksum = cpu_to_le32(ext4_csum(~0, (uint8_t *)sb, offset)); +} + +static uint32_t ext4_inode_csum(struct ext2_inode *inode, unsigned int inode_no) +{ + struct ext_filesystem *fs = get_fs(); + uint32_t crc32; + uint16_t dummy_csum = 0; + unsigned int dummy_size = sizeof(dummy_csum); + int offset = offsetof(struct ext2_inode, checksum_lo); + __le32 inum = cpu_to_le32(inode_no); + __le32 gen = inode->generation; + uint32_t inode_seed; + + inode_seed = ext4_csum(fs->csum_seed, (uint8_t *)&inum, sizeof(inum)); + inode_seed = ext4_csum(inode_seed, (uint8_t *)&gen, sizeof(gen)); + + crc32 = ext4_csum(inode_seed, (uint8_t *)inode, offset); + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, dummy_size); + offset += dummy_size; + crc32 = ext4_csum(crc32, (uint8_t *)inode + offset, EXT4_OLD_INODE_SIZE - offset); + + if (fs->inodesz > EXT4_OLD_INODE_SIZE) { + uint16_t extra_size; + + offset = offsetof(struct ext2_inode, checksum_hi); + crc32 = ext4_csum(crc32, (uint8_t *)inode + EXT4_OLD_INODE_SIZE, + offset - EXT4_OLD_INODE_SIZE); + extra_size = le16_to_cpu(inode->extra_isize); + if (extra_size + EXT4_OLD_INODE_SIZE >= + offsetof(struct ext2_inode, checksum_hi) + sizeof(inode->checksum_hi)) { + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, dummy_size); + offset += dummy_size; + } + crc32 = ext4_csum(crc32, (uint8_t *)inode + offset, fs->inodesz - offset); + } + + return crc32; +} + +static void ext4fs_set_inode_csum(struct ext2_inode *inode, unsigned int inode_no) + +{ + struct ext_filesystem *fs = get_fs(); + uint32_t crc32; + + if (!(le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + crc32 = ext4_inode_csum(inode, inode_no); + inode->checksum_lo = cpu_to_le16(crc32 & 0xffff); + + if (fs->inodesz > EXT4_OLD_INODE_SIZE) { + uint16_t extra_size = le16_to_cpu(inode->extra_isize); + + if (extra_size + EXT4_OLD_INODE_SIZE >= + offsetof(struct ext2_inode, checksum_hi) + sizeof(inode->checksum_hi)) + inode->checksum_hi = cpu_to_le16(crc32 >> 16); + } +} + +static void ext4fs_set_group_descriptor_csum(uint32_t i) +{ + struct ext_filesystem *fs = get_fs(); + struct ext2_block_group *desc = ext4fs_get_group_descriptor(fs, i); + __le32 le32_i = cpu_to_le32(i); + int offset = offsetof(struct ext2_block_group, bg_checksum); + uint16_t crc = 0; + + if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { + uint32_t crc32; + uint16_t dummy_csum = 0; + int sz; + + /* inode bitmap */ + sz = fs->sb->inodes_per_group / 8; + crc32 = ext4_csum(fs->csum_seed, fs->inode_bmaps[i], sz); + desc->bg_inode_id_csum = cpu_to_le16(crc32 & 0xFFFF); + if (fs->gdsize >= EXT4_BG_INODE_BITMAP_CSUM_HI_END) + desc->bg_inode_id_csum_high = cpu_to_le16(crc32 >> 16); + + /* block bitmap */ + sz = fs->sb->fragments_per_group / 8; + crc32 = ext4_csum(fs->csum_seed, fs->blk_bmaps[i], sz); + desc->bg_block_id_csum = cpu_to_le16(crc32 & 0xFFFF); + if (fs->gdsize >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_END) + desc->bg_block_id_csum_high = cpu_to_le16(crc32 >> 16); + + crc32 = ext4_csum(fs->csum_seed, (uint8_t *)&le32_i, sizeof(le32_i)); + crc32 = ext4_csum(crc32, (uint8_t *)desc, offset); + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, sizeof(dummy_csum)); + offset += sizeof(dummy_csum); + if (offset < fs->gdsize) { + crc32 = ext4_csum(crc32, (uint8_t *)desc + offset, + fs->gdsize - offset); + } + crc = crc32 & 0xffff; + } else if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + crc = ext2fs_crc16(~0, fs->sb->unique_id, + sizeof(fs->sb->unique_id)); + crc = ext2fs_crc16(crc, &le32_i, sizeof(le32_i)); + crc = ext2fs_crc16(crc, desc, offset); + offset += sizeof(desc->bg_checksum); /* skip checksum */ + assert(offset == sizeof(*desc)); + if (offset < fs->gdsize) { + crc = ext2fs_crc16(crc, (__u8 *)desc + offset, + fs->gdsize - offset); + } + } + desc->bg_checksum = cpu_to_le16(crc); +} + static void ext4fs_update(void) { short i; @@ -74,14 +208,14 @@ static void ext4fs_update(void) struct ext_filesystem *fs = get_fs(); struct ext2_block_group *bgd = NULL;
- /* update super block */ - put_ext4((uint64_t)(SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); + /* update super block */ + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE);
/* update block bitmaps */ for (i = 0; i < fs->no_blkgrp; i++) { bgd = ext4fs_get_group_descriptor(fs, i); - bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i)); + ext4fs_set_group_descriptor_csum(i); uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); put_ext4(b_bitmap_blk * fs->blksz, fs->blk_bmaps[i], fs->blksz); @@ -613,6 +747,11 @@ int ext4fs_init(void) if (!ext4_read_superblock((char *)fs->sb)) goto fail;
+ if (le32_to_cpu(fs->sb->feature_incompat) & EXT4_FEATURE_INCOMPAT_CSUM_SEED) + fs->csum_seed = le32_to_cpu(fs->sb->checksum_seed); + else if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) + fs->csum_seed = ext4_csum(~0, fs->sb->unique_id, sizeof(fs->sb->unique_id)); + /* init journal */ if (ext4fs_init_journal()) goto fail; @@ -713,6 +852,7 @@ void ext4fs_deinit(void) temp_buff); jsb = (struct journal_superblock_t *)temp_buff; jsb->s_start = 0; + ext4fs_set_journal_superblock_csum(jsb); put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), (struct journal_superblock_t *)temp_buff, fs->blksz); free(temp_buff); @@ -724,8 +864,8 @@ void ext4fs_deinit(void) new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); - put_ext4((uint64_t)(SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); free(fs->sb); fs->sb = NULL;
@@ -881,17 +1021,15 @@ int ext4fs_write(const char *fname, const char *buffer, return -1; }
- if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { - printf("Unsupported feature metadata_csum found, not writing.\n"); - return -1; - } - inodes_per_block = fs->blksz / fs->inodesz; parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE); if (parent_inodeno == -1) goto fail; if (ext4fs_iget(parent_inodeno, g_parent_inode)) goto fail; + + g_parent_inode_no = parent_inodeno; + /* do not mess up a directory using hash trees */ if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) { printf("hash tree directory\n"); @@ -963,6 +1101,8 @@ int ext4fs_write(const char *fname, const char *buffer, file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >> LOG2_SECTOR_SIZE);
+ ext4fs_set_inode_csum(file_inode, inodeno); + temp_ptr = zalloc(fs->blksz); if (!temp_ptr) goto fail; diff --git a/include/ext4fs.h b/include/ext4fs.h index cb5d9cc0a5..5485388166 100644 --- a/include/ext4fs.h +++ b/include/ext4fs.h @@ -37,6 +37,7 @@ struct disk_partition; #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 #define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 +#define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000 #define EXT4_INDIRECT_BLOCKS 12
#define EXT4_BG_INODE_UNINIT 0x0001 @@ -117,6 +118,11 @@ struct ext_filesystem {
/* Block Device Descriptor */ struct blk_desc *dev_desc; + + uint32_t csum_seed; + uint32_t journal_csum_seed; + uint32_t journal_tag_size; + int journal_csum_version; };
struct ext_block_cache { @@ -130,6 +136,7 @@ extern struct ext2fs_node *ext4fs_file;
#if defined(CONFIG_EXT4_WRITE) extern struct ext2_inode *g_parent_inode; +extern int g_parent_inode_no; extern int gd_index; extern int gindex;
diff --git a/include/ext_common.h b/include/ext_common.h index bc3324172a..c024b33e56 100644 --- a/include/ext_common.h +++ b/include/ext_common.h @@ -97,7 +97,7 @@ struct ext2_sblock { __le32 feature_compatibility; __le32 feature_incompat; __le32 feature_ro_compat; - __le32 unique_id[4]; + uint8_t unique_id[16]; char volume_name[16]; char last_mounted_on[64]; __le32 compression_info; @@ -116,6 +116,8 @@ struct ext2_sblock { __le32 first_meta_block_group; __le32 mkfs_time; __le32 journal_blocks[17]; + + /* 64 bit support */ __le32 total_blocks_high; __le32 reserved_blocks_high; __le32 free_blocks_high; @@ -128,6 +130,43 @@ struct ext2_sblock { __le32 raid_stripe_width; uint8_t log2_groups_per_flex; uint8_t checksum_type; + uint8_t encryption_level; + uint8_t reserved_pad; + __le64 kbytes_written; + __le32 snapshot_inum; + __le32 snapshot_id; + __le64 snapshot_r_blocks_count; + __le32 snapshot_list; + __le32 error_count; + __le32 first_error_time; + __le32 first_error_ino; + __le64 first_error_block; + uint8_t first_error_func[32]; + __le32 first_error_line; + __le32 last_error_time; + __le32 last_error_ino; + __le32 last_error_line; + __le64 last_error_block; + uint8_t last_error_func[32]; + uint8_t mount_opts[64]; + __le32 usr_quota_inum; + __le32 grp_quota_inum; + __le32 overhead_clusters; + __le32 backup_bgs[2]; + uint8_t encrypt_algos[4]; + uint8_t encrypt_pw_salt[16]; + __le32 lpf_ino; + __le32 prj_quota_inum; + __le32 checksum_seed; + uint8_t wtime_hi; + uint8_t mtime_hi; + uint8_t mkfs_time_hi; + uint8_t lastcheck_hi; + uint8_t first_error_time_hi; + uint8_t last_error_time_hi; + uint8_t pad[2]; + __le32 reserved[96]; + __le32 checksum; };
struct ext2_block_group { @@ -157,6 +196,13 @@ struct ext2_block_group { __le32 bg_reserved; };
+#define EXT4_BG_INODE_BITMAP_CSUM_HI_END \ + (offsetof(struct ext2_block_group, bg_inode_id_csum_high) + \ + sizeof(__le16)) +#define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END \ + (offsetof(struct ext2_block_group, bg_block_id_csum_high) + \ + sizeof(__le16)) + /* The ext2 inode. */ struct ext2_inode { __le16 mode; @@ -181,11 +227,28 @@ struct ext2_inode { char symlink[60]; char inline_data[60]; } b; - __le32 version; + __le32 generation; __le32 acl; __le32 size_high; /* previously dir_acl, but never used */ __le32 fragment_addr; - __le32 osd2[3]; + + __le16 blocks_high; /* were l_i_reserved1 */ + __le16 file_acl_high; + __le16 uid_high; + __le16 gid_high; + __le16 checksum_lo; /* crc32c(uuid+inum+inode) LE */ + __le16 reserved; + + /* optional part */ + __le16 extra_isize; + __le16 checksum_hi; /* crc32c(uuid+inum+inode) BE */ + __le32 ctime_extra; + __le32 mtime_extra; + __le32 atime_extra; + __le32 crtime; + __le32 crtime_extra; + __le32 version_hi; + __le32 projid; };
/* The header of an ext2 directory entry. */ @@ -196,6 +259,14 @@ struct ext2_dirent { __u8 filetype; };
+struct ext4_dir_entry_tail { + __le32 det_reserved_zero1; /* Pretend to be unused */ + __le16 det_rec_len; /* 12 */ + __u8 det_reserved_zero2; /* Zero name length */ + __u8 det_reserved_ft; /* 0xDE, fake file type */ + __le32 det_checksum; /* crc32c(uuid+inum+dirblock) */ +}; + struct ext2fs_node { struct ext2_data *data; struct ext2_inode inode; diff --git a/test/py/tests/test_env.py b/test/py/tests/test_env.py index 940279651d..847b4fbcdd 100644 --- a/test/py/tests/test_env.py +++ b/test/py/tests/test_env.py @@ -417,9 +417,6 @@ def mk_env_ext4(state_test_env): try: u_boot_utils.run_and_log(c, 'dd if=/dev/zero of=%s bs=1M count=16' % persistent) u_boot_utils.run_and_log(c, 'mkfs.ext4 %s' % persistent) - sb_content = u_boot_utils.run_and_log(c, 'tune2fs -l %s' % persistent) - if 'metadata_csum' in sb_content: - u_boot_utils.run_and_log(c, 'tune2fs -O ^metadata_csum %s' % persistent) except CalledProcessError: call('rm -f %s' % persistent, shell=True) raise diff --git a/test/py/tests/test_fs/conftest.py b/test/py/tests/test_fs/conftest.py index ec70e8c4ef..272cbb639c 100644 --- a/test/py/tests/test_fs/conftest.py +++ b/test/py/tests/test_fs/conftest.py @@ -165,10 +165,6 @@ def mk_fs(config, fs_type, size, id): % (fs_img, count), shell=True) check_call('mkfs.%s %s %s' % (fs_lnxtype, mkfs_opt, fs_img), shell=True) - if fs_type == 'ext4': - sb_content = check_output('tune2fs -l %s' % fs_img, shell=True).decode() - if 'metadata_csum' in sb_content: - check_call('tune2fs -O ^metadata_csum %s' % fs_img, shell=True) return fs_img except CalledProcessError: call('rm -f %s' % fs_img, shell=True)