Author: fsu Date: Sun Jan 14 20:46:39 2018 New Revision: 327977 URL: https://svnweb.freebsd.org/changeset/base/327977
Log: Add metadata_csum feature support. Reviewed by: pfg (mentor) Approved by: pfg (mentor) MFC after: 6 months Differential Revision: https://reviews.freebsd.org/D13810 Modified: head/sys/fs/ext2fs/ext2_alloc.c head/sys/fs/ext2fs/ext2_csum.c head/sys/fs/ext2fs/ext2_dir.h head/sys/fs/ext2fs/ext2_extattr.c head/sys/fs/ext2fs/ext2_extattr.h head/sys/fs/ext2fs/ext2_extents.c head/sys/fs/ext2fs/ext2_extents.h head/sys/fs/ext2fs/ext2_extern.h head/sys/fs/ext2fs/ext2_inode_cnv.c head/sys/fs/ext2fs/ext2_lookup.c head/sys/fs/ext2fs/ext2_subr.c head/sys/fs/ext2fs/ext2_vfsops.c head/sys/fs/ext2fs/ext2_vnops.c head/sys/fs/ext2fs/ext2fs.h head/sys/fs/ext2fs/htree.h Modified: head/sys/fs/ext2fs/ext2_alloc.c ============================================================================== --- head/sys/fs/ext2fs/ext2_alloc.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_alloc.c Sun Jan 14 20:46:39 2018 (r327977) @@ -898,14 +898,22 @@ ext2_alloccg(struct inode *ip, int cg, daddr_t bpref, EXT2_LOCK(ump); return (0); } - if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) { + if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || + EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { error = ext2_cg_block_bitmap_init(fs, cg, bp); if (error) { brelse(bp); EXT2_LOCK(ump); return (0); } + ext2_gd_b_bitmap_csum_set(fs, cg, bp); } + error = ext2_gd_b_bitmap_csum_verify(fs, cg, bp); + if (error) { + brelse(bp); + EXT2_LOCK(ump); + return (0); + } if (e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) == 0) { /* * Another thread allocated the last block in this @@ -1008,6 +1016,7 @@ gotit: e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) - 1); fs->e2fs_fmod = 1; EXT2_UNLOCK(ump); + ext2_gd_b_bitmap_csum_set(fs, cg, bp); bdwrite(bp); return (((uint64_t)cg) * fs->e2fs->e2fs_fpg + fs->e2fs->e2fs_first_dblock + bno); } @@ -1187,11 +1196,13 @@ ext2_nodealloccg(struct inode *ip, int cg, daddr_t ipr EXT2_LOCK(ump); return (0); } - if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) { + if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || + EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { if (fs->e2fs_gd[cg].ext4bgd_flags & EXT2_BG_INODE_UNINIT) { memset(bp->b_data, 0, fs->e2fs_bsize); fs->e2fs_gd[cg].ext4bgd_flags &= ~EXT2_BG_INODE_UNINIT; } + ext2_gd_i_bitmap_csum_set(fs, cg, bp); error = ext2_zero_inode_table(ip, cg); if (error) { brelse(bp); @@ -1199,6 +1210,12 @@ ext2_nodealloccg(struct inode *ip, int cg, daddr_t ipr return (0); } } + error = ext2_gd_i_bitmap_csum_verify(fs, cg, bp); + if (error) { + brelse(bp); + EXT2_LOCK(ump); + return (0); + } if (e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) == 0) { /* * Another thread allocated the last i-node in this @@ -1234,7 +1251,8 @@ gotit: EXT2_LOCK(ump); e2fs_gd_set_nifree(&fs->e2fs_gd[cg], e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) - 1); - if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) + if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || + EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) e2fs_gd_set_i_unused(&fs->e2fs_gd[cg], e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]) - 1); fs->e2fs->e2fs_ficount--; @@ -1245,6 +1263,7 @@ gotit: fs->e2fs_total_dir++; } EXT2_UNLOCK(ump); + ext2_gd_i_bitmap_csum_set(fs, cg, bp); bdwrite(bp); return ((uint64_t)cg * fs->e2fs_ipg + ipref + 1); } @@ -1293,6 +1312,7 @@ ext2_blkfree(struct inode *ip, e4fs_daddr_t bno, long e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) + 1); fs->e2fs_fmod = 1; EXT2_UNLOCK(ump); + ext2_gd_b_bitmap_csum_set(fs, cg, bp); bdwrite(bp); } @@ -1338,7 +1358,8 @@ ext2_vfree(struct vnode *pvp, ino_t ino, int mode) fs->e2fs->e2fs_ficount++; e2fs_gd_set_nifree(&fs->e2fs_gd[cg], e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) + 1); - if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) + if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) || + EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) e2fs_gd_set_i_unused(&fs->e2fs_gd[cg], e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]) + 1); if ((mode & IFMT) == IFDIR) { @@ -1348,6 +1369,7 @@ ext2_vfree(struct vnode *pvp, ino_t ino, int mode) } fs->e2fs_fmod = 1; EXT2_UNLOCK(ump); + ext2_gd_i_bitmap_csum_set(fs, cg, bp); bdwrite(bp); return (0); } Modified: head/sys/fs/ext2fs/ext2_csum.c ============================================================================== --- head/sys/fs/ext2fs/ext2_csum.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_csum.c Sun Jan 14 20:46:39 2018 (r327977) @@ -43,9 +43,576 @@ #include <fs/ext2fs/fs.h> #include <fs/ext2fs/ext2fs.h> +#include <fs/ext2fs/ext2_dinode.h> #include <fs/ext2fs/inode.h> +#include <fs/ext2fs/ext2_dir.h> +#include <fs/ext2fs/htree.h> +#include <fs/ext2fs/ext2_extattr.h> #include <fs/ext2fs/ext2_extern.h> +#define EXT2_BG_INODE_BITMAP_CSUM_HI_END \ + (offsetof(struct ext2_gd, ext4bgd_i_bmap_csum_hi) + \ + sizeof(uint16_t)) + +#define EXT2_INODE_CSUM_HI_EXTRA_END \ + (offsetof(struct ext2fs_dinode, e2di_chksum_hi) + sizeof(uint16_t) - \ + E2FS_REV0_INODE_SIZE) + +#define EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION \ + (offsetof(struct ext2_gd, ext4bgd_b_bmap_csum_hi) + \ + sizeof(uint16_t)) + +void +ext2_sb_csum_set_seed(struct m_ext2fs *fs) +{ + + if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_CSUM_SEED)) + fs->e2fs_csum_seed = fs->e2fs->e4fs_chksum_seed; + else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { + fs->e2fs_csum_seed = calculate_crc32c(~0, fs->e2fs->e2fs_uuid, + sizeof(fs->e2fs->e2fs_uuid)); + } + else + fs->e2fs_csum_seed = 0; +} + +int +ext2_sb_csum_verify(struct m_ext2fs *fs) +{ + + if (fs->e2fs->e4fs_chksum_type != EXT4_CRC32C_CHKSUM) { + printf( +"WARNING: mount of %s denied due bad sb csum type\n", fs->e2fs_fsmnt); + return (EINVAL); + } + if (fs->e2fs->e4fs_sbchksum != + calculate_crc32c(~0, (const char *)fs->e2fs, + offsetof(struct ext2fs, e4fs_sbchksum))) { + printf( +"WARNING: mount of %s denied due bad sb csum=0x%x, expected=0x%x - run fsck\n", + fs->e2fs_fsmnt, fs->e2fs->e4fs_sbchksum, calculate_crc32c(~0, + (const char *)fs->e2fs, offsetof(struct ext2fs, e4fs_sbchksum))); + return (EINVAL); + } + + return (0); +} + +void +ext2_sb_csum_set(struct m_ext2fs *fs) +{ + + fs->e2fs->e4fs_sbchksum = calculate_crc32c(~0, (const char *)fs->e2fs, + offsetof(struct ext2fs, e4fs_sbchksum)); +} + +static uint32_t +ext2_extattr_blk_csum(struct inode *ip, uint64_t facl, + struct ext2fs_extattr_header *header) +{ + struct m_ext2fs *fs; + uint32_t crc, old_crc; + + fs = ip->i_e2fs; + + old_crc = header->h_checksum; + + header->h_checksum = 0; + crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&facl, sizeof(facl)); + crc = calculate_crc32c(crc, (uint8_t *)header, fs->e2fs_bsize); + header->h_checksum = old_crc; + + return (crc); +} + +int +ext2_extattr_blk_csum_verify(struct inode *ip, struct buf *bp) +{ + struct ext2fs_extattr_header *header; + + header = (struct ext2fs_extattr_header *)bp->b_data; + + if (EXT2_HAS_RO_COMPAT_FEATURE(ip->i_e2fs, EXT2F_ROCOMPAT_METADATA_CKSUM) && + (header->h_checksum != ext2_extattr_blk_csum(ip, ip->i_facl, header))) { + printf("WARNING: bad extattr csum detected, ip=%lu - run fsck\n", + (unsigned long)ip->i_number); + return (EIO); + } + + return (0); +} + +void +ext2_extattr_blk_csum_set(struct inode *ip, struct buf *bp) +{ + struct ext2fs_extattr_header *header; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(ip->i_e2fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + header = (struct ext2fs_extattr_header *)bp->b_data; + header->h_checksum = ext2_extattr_blk_csum(ip, ip->i_facl, header); +} + +static struct ext2fs_direct_tail * +ext2_get_dirent_tail(struct inode *ip, struct ext2fs_direct_2 *ep) +{ + struct ext2fs_direct_tail *tp; + + tp = EXT2_DIRENT_TAIL(ep, ip->i_e2fs->e2fs_bsize); + if (tp->e2dt_reserved_zero1 || + tp->e2dt_rec_len != sizeof(struct ext2fs_direct_tail) || + tp->e2dt_reserved_zero2 || + tp->e2dt_reserved_ft != EXT2_FT_DIR_CSUM) + return (NULL); + + return (tp); +} + +static uint32_t +ext2_dirent_csum(struct inode *ip, struct ext2fs_direct_2 *ep, int size) +{ + struct m_ext2fs *fs; + char *buf; + uint32_t inum, gen, crc; + + fs = ip->i_e2fs; + + buf = (char *)ep; + + inum = ip->i_number; + gen = ip->i_gen; + crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum)); + crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen)); + crc = calculate_crc32c(crc, (uint8_t *)buf, size); + + return (crc); +} + +static int +ext2_dirent_csum_verify(struct inode *ip, struct ext2fs_direct_2 *ep) +{ + uint32_t calculated; + struct ext2fs_direct_tail *tp; + + tp = ext2_get_dirent_tail(ip, ep); + if (tp == NULL) + return (0); + + calculated = ext2_dirent_csum(ip, ep, (char *)tp - (char *)ep); + if (calculated != tp->e2dt_checksum) + return (EIO); + + return (0); +} + +static struct ext2fs_htree_count * +ext2_get_dx_count(struct inode *ip, struct ext2fs_direct_2 *ep, int *offset) +{ + struct ext2fs_direct_2 *dp; + struct ext2fs_htree_root_info *root; + int count_offset; + + if (ep->e2d_reclen == EXT2_BLOCK_SIZE(ip->i_e2fs)) + count_offset = 8; + else if (ep->e2d_reclen == 12) { + dp = (struct ext2fs_direct_2 *)(((char *)ep) + 12); + if (dp->e2d_reclen != EXT2_BLOCK_SIZE(ip->i_e2fs) - 12) + return (NULL); + + root = (struct ext2fs_htree_root_info *)(((char *)dp + 12)); + if (root->h_reserved1 || + root->h_info_len != sizeof(struct ext2fs_htree_root_info)) + return (NULL); + + count_offset = 32; + } else + return (NULL); + + if (offset) + *offset = count_offset; + + return ((struct ext2fs_htree_count *)(((char *)ep) + count_offset)); +} + +static uint32_t +ext2_dx_csum(struct inode *ip, struct ext2fs_direct_2 *ep, int count_offset, + int count, struct ext2fs_htree_tail *tp) +{ + struct m_ext2fs *fs; + char *buf; + int size; + uint32_t inum, old_csum, gen, crc; + + fs = ip->i_e2fs; + + buf = (char *)ep; + + size = count_offset + (count * sizeof(struct ext2fs_htree_entry)); + old_csum = tp->ht_checksum; + tp->ht_checksum = 0; + + inum = ip->i_number; + gen = ip->i_gen; + crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum)); + crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen)); + crc = calculate_crc32c(crc, (uint8_t *)buf, size); + crc = calculate_crc32c(crc, (uint8_t *)tp, sizeof(struct ext2fs_htree_tail)); + tp->ht_checksum = old_csum; + + return (crc); +} + +static int +ext2_dx_csum_verify(struct inode *ip, struct ext2fs_direct_2 *ep) +{ + uint32_t calculated; + struct ext2fs_htree_count *cp; + struct ext2fs_htree_tail *tp; + int count_offset, limit, count; + + cp = ext2_get_dx_count(ip, ep, &count_offset); + if (cp == NULL) + return (0); + + limit = cp->h_entries_max; + count = cp->h_entries_num; + if (count_offset + (limit * sizeof(struct ext2fs_htree_entry)) > + ip->i_e2fs->e2fs_bsize - sizeof(struct ext2fs_htree_tail)) + return (EIO); + + tp = (struct ext2fs_htree_tail *)(((struct ext2fs_htree_entry *)cp) + limit); + calculated = ext2_dx_csum(ip, ep, count_offset, count, tp); + + if (tp->ht_checksum != calculated) + return (EIO); + + return (0); +} + +int +ext2_dir_blk_csum_verify(struct inode *ip, struct buf *bp) +{ + struct m_ext2fs *fs; + struct ext2fs_direct_2 *ep; + int error = 0; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return (error); + + ep = (struct ext2fs_direct_2 *)bp->b_data; + + if (ext2_get_dirent_tail(ip, ep) != NULL) + error = ext2_dirent_csum_verify(ip, ep); + else if (ext2_get_dx_count(ip, ep, NULL) != NULL) + error = ext2_dx_csum_verify(ip, ep); + + if (error) + printf("WARNING: bad directory csum detected, ip=%lu" + " - run fsck\n", (unsigned long)ip->i_number); + + return (error); +} + +static void +ext2_dirent_csum_set(struct inode *ip, struct ext2fs_direct_2 *ep) +{ + struct ext2fs_direct_tail *tp; + + tp = ext2_get_dirent_tail(ip, ep); + if (tp == NULL) + return; + + tp->e2dt_checksum = + ext2_dirent_csum(ip, ep, (char *)tp - (char *)ep); +} + +static void +ext2_dx_csum_set(struct inode *ip, struct ext2fs_direct_2 *ep) +{ + struct ext2fs_htree_count *cp; + struct ext2fs_htree_tail *tp; + int count_offset, limit, count; + + cp = ext2_get_dx_count(ip, ep, &count_offset); + if (cp == NULL) + return; + + limit = cp->h_entries_max; + count = cp->h_entries_num; + if (count_offset + (limit * sizeof(struct ext2fs_htree_entry)) > + ip->i_e2fs->e2fs_bsize - sizeof(struct ext2fs_htree_tail)) + return; + + tp = (struct ext2fs_htree_tail *)(((struct ext2fs_htree_entry *)cp) + limit); + tp->ht_checksum = ext2_dx_csum(ip, ep, count_offset, count, tp); +} + +void +ext2_dir_blk_csum_set_mem(struct inode *ip, char *buf, int size) +{ + struct m_ext2fs *fs; + struct ext2fs_direct_2 *ep; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + ep = (struct ext2fs_direct_2 *)buf; + + if (ext2_htree_has_idx(ip)) { + if (ext2_get_dx_count(ip, ep, NULL) != NULL) + ext2_dx_csum_set(ip, ep); + } else { + if (ext2_get_dirent_tail(ip, ep) != NULL) + ext2_dirent_csum_set(ip, ep); + } +} + +void +ext2_dir_blk_csum_set(struct inode *ip, struct buf *bp) +{ + + ext2_dir_blk_csum_set_mem(ip, bp->b_data, bp->b_bufsize); +} + +static uint32_t +ext2_extent_blk_csum(struct inode *ip, struct ext4_extent_header *ehp) +{ + struct m_ext2fs *fs; + size_t size; + uint32_t inum, gen, crc; + + fs = ip->i_e2fs; + + size = EXT4_EXTENT_TAIL_OFFSET(ehp) + + offsetof(struct ext4_extent_tail, et_checksum); + + inum = ip->i_number; + gen = ip->i_gen; + crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum)); + crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen)); + crc = calculate_crc32c(crc, (uint8_t *)ehp, size); + + return (crc); +} + +int +ext2_extent_blk_csum_verify(struct inode *ip, void *data) +{ + struct m_ext2fs *fs; + struct ext4_extent_header *ehp; + struct ext4_extent_tail *etp; + uint32_t provided, calculated; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return (0); + + ehp = (struct ext4_extent_header *)data; + etp = (struct ext4_extent_tail *)(((char *)ehp) + + EXT4_EXTENT_TAIL_OFFSET(ehp)); + + provided = etp->et_checksum; + calculated = ext2_extent_blk_csum(ip, ehp); + + if (provided != calculated) { + printf("WARNING: bad extent csum detected, ip=%lu - run fsck\n", + (unsigned long)ip->i_number); + return (EIO); + } + + return (0); +} + +void +ext2_extent_blk_csum_set(struct inode *ip, void *data) +{ + struct m_ext2fs *fs; + struct ext4_extent_header *ehp; + struct ext4_extent_tail *etp; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + ehp = (struct ext4_extent_header *)data; + etp = (struct ext4_extent_tail *)(((char *)data) + + EXT4_EXTENT_TAIL_OFFSET(ehp)); + + etp->et_checksum = ext2_extent_blk_csum(ip, + (struct ext4_extent_header *)data); +} + +int +ext2_gd_i_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp) +{ + uint32_t hi, provided, calculated; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return (0); + + provided = fs->e2fs_gd[cg].ext4bgd_i_bmap_csum; + calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, + fs->e2fs->e2fs_ipg / 8); + if (fs->e2fs->e3fs_desc_size >= EXT2_BG_INODE_BITMAP_CSUM_HI_END) { + hi = fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi; + provided |= (hi << 16); + } else + calculated &= 0xFFFF; + + if (provided != calculated) { + printf("WARNING: bad inode bitmap csum detected, " + "cg=%d - run fsck\n", cg); + return (EIO); + } + + return (0); +} + +void +ext2_gd_i_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp) +{ + uint32_t csum; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, + fs->e2fs->e2fs_ipg / 8); + fs->e2fs_gd[cg].ext4bgd_i_bmap_csum = csum & 0xFFFF; + if (fs->e2fs->e3fs_desc_size >= EXT2_BG_INODE_BITMAP_CSUM_HI_END) + fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi = csum >> 16; +} + +int +ext2_gd_b_bitmap_csum_verify(struct m_ext2fs *fs, int cg, struct buf *bp) +{ + uint32_t hi, provided, calculated, size; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return (0); + + size = fs->e2fs_fpg / 8; + provided = fs->e2fs_gd[cg].ext4bgd_b_bmap_csum; + calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size); + if (fs->e2fs->e3fs_desc_size >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION) { + hi = fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi; + provided |= (hi << 16); + } else + calculated &= 0xFFFF; + + if (provided != calculated) { + printf("WARNING: bad block bitmap csum detected, " + "cg=%d - run fsck\n", cg); + return (EIO); + } + + return (0); +} + +void +ext2_gd_b_bitmap_csum_set(struct m_ext2fs *fs, int cg, struct buf *bp) +{ + uint32_t csum, size; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + size = fs->e2fs_fpg / 8; + csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size); + fs->e2fs_gd[cg].ext4bgd_b_bmap_csum = csum & 0xFFFF; + if (fs->e2fs->e3fs_desc_size >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION) + fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi = csum >> 16; +} + +static uint32_t +ext2_ei_csum(struct inode *ip, struct ext2fs_dinode *ei) +{ + struct m_ext2fs *fs; + uint16_t old_lo, old_hi; + uint32_t inum, gen, crc; + + fs = ip->i_e2fs; + + old_lo = ei->e2di_chksum_lo; + ei->e2di_chksum_lo = 0; + if ((EXT2_INODE_SIZE(ip->i_e2fs) > E2FS_REV0_INODE_SIZE && + ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) { + old_hi = ei->e2di_chksum_hi; + ei->e2di_chksum_hi = 0; + } + + inum = ip->i_number; + gen = ip->i_gen; + + crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum)); + crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen)); + crc = calculate_crc32c(crc, (uint8_t *)ei, fs->e2fs->e2fs_inode_size); + + if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE && + ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) + ei->e2di_chksum_hi = old_hi; + + return (crc); +} + +int +ext2_ei_csum_verify(struct inode *ip, struct ext2fs_dinode *ei) +{ + struct m_ext2fs *fs; + const static struct ext2fs_dinode ei_zero; + uint32_t hi, provided, calculated; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return (0); + + /* Check case, when dinode was not initialized */ + if (!memcmp(ei, &ei_zero, sizeof(struct ext2fs_dinode))) + return (0); + + provided = ei->e2di_chksum_lo; + calculated = ext2_ei_csum(ip, ei); + + if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE && + ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) { + hi = ei->e2di_chksum_hi; + provided |= hi << 16; + } else + calculated &= 0xFFFF; + + if (provided != calculated) + return (EIO); + + return (0); +} + +void +ext2_ei_csum_set(struct inode *ip, struct ext2fs_dinode *ei) +{ + struct m_ext2fs *fs; + uint32_t crc; + + fs = ip->i_e2fs; + + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) + return; + + crc = ext2_ei_csum(ip, ei); + + ei->e2di_chksum_lo = crc & 0xFFFF; + if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE && + ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) + ei->e2di_chksum_hi = crc >> 16; +} + static uint16_t ext2_crc16(uint16_t crc, const void *buffer, unsigned int len) { @@ -96,11 +663,26 @@ static uint16_t ext2_gd_csum(struct m_ext2fs *fs, uint32_t block_group, struct ext2_gd *gd) { size_t offset; - uint16_t crc; + uint32_t csum32; + uint16_t crc, dummy_csum; offset = offsetof(struct ext2_gd, ext4bgd_csum); - if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) { + if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) { + csum32 = calculate_crc32c(fs->e2fs_csum_seed, + (uint8_t *)&block_group, sizeof(block_group)); + csum32 = calculate_crc32c(csum32, (uint8_t *)gd, offset); + dummy_csum = 0; + csum32 = calculate_crc32c(csum32, (uint8_t *)&dummy_csum, + sizeof(dummy_csum)); + offset += sizeof(dummy_csum); + if (offset < fs->e2fs->e3fs_desc_size) + csum32 = calculate_crc32c(csum32, (uint8_t *)gd + offset, + fs->e2fs->e3fs_desc_size - offset); + + crc = csum32 & 0xFFFF; + return (crc); + } else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) { crc = ext2_crc16(~0, fs->e2fs->e2fs_uuid, sizeof(fs->e2fs->e2fs_uuid)); crc = ext2_crc16(crc, (uint8_t *)&block_group, @@ -130,7 +712,7 @@ ext2_gd_csum_verify(struct m_ext2fs *fs, struct cdev * "WARNING: mount of %s denied due bad gd=%d csum=0x%x, expected=0x%x - run fsck\n", devtoname(dev), i, fs->e2fs_gd[i].ext4bgd_csum, ext2_gd_csum(fs, i, &fs->e2fs_gd[i])); - error = EINVAL; + error = EIO; break; } } Modified: head/sys/fs/ext2fs/ext2_dir.h ============================================================================== --- head/sys/fs/ext2fs/ext2_dir.h Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_dir.h Sun Jan 14 20:46:39 2018 (r327977) @@ -72,6 +72,20 @@ struct ext2fs_direct_2 { * length<=EXT2FS_MAXNAMLEN */ }; +struct ext2fs_direct_tail { + uint32_t e2dt_reserved_zero1; /* pretend to be unused */ + uint16_t e2dt_rec_len; /* 12 */ + uint8_t e2dt_reserved_zero2; /* zero name length */ + uint8_t e2dt_reserved_ft; /* 0xDE, fake file type */ + uint32_t e2dt_checksum; /* crc32c(uuid+inum+dirblock) */ +}; + +#define EXT2_FT_DIR_CSUM 0xDE + +#define EXT2_DIRENT_TAIL(data, blocksize) \ + ((struct ext2fs_direct_tail *)(((char *)(data)) + \ + (blocksize) - sizeof(struct ext2fs_direct_tail))) + /* * Maximal count of links to a file */ Modified: head/sys/fs/ext2fs/ext2_extattr.c ============================================================================== --- head/sys/fs/ext2fs/ext2_extattr.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_extattr.c Sun Jan 14 20:46:39 2018 (r327977) @@ -165,6 +165,22 @@ ext2_extattr_check(struct ext2fs_extattr_entry *entry, return (0); } +static int +ext2_extattr_block_check(struct inode *ip, struct buf *bp) +{ + struct ext2fs_extattr_header *header; + int error; + + header = (struct ext2fs_extattr_header *)bp->b_data; + + error = ext2_extattr_check(EXT2_IFIRST(header), + bp->b_data + bp->b_bufsize); + if (error) + return (error); + + return (ext2_extattr_blk_csum_verify(ip, bp)); +} + int ext2_extattr_inode_list(struct inode *ip, int attrnamespace, struct uio *uio, size_t *size) @@ -267,7 +283,7 @@ ext2_extattr_block_list(struct inode *ip, int attrname return (EINVAL); } - error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + error = ext2_extattr_block_check(ip, bp); if (error) { brelse(bp); return (error); @@ -408,7 +424,7 @@ ext2_extattr_block_get(struct inode *ip, int attrnames return (EINVAL); } - error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + error = ext2_extattr_block_check(ip, bp); if (error) { brelse(bp); return (error); @@ -668,7 +684,7 @@ ext2_extattr_block_delete(struct inode *ip, int attrna return (EINVAL); } - error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + error = ext2_extattr_block_check(ip, bp); if (error) { brelse(bp); return (error); @@ -1061,8 +1077,7 @@ ext2_extattr_block_set(struct inode *ip, int attrnames return (EINVAL); } - error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), - bp->b_data + bp->b_bufsize); + error = ext2_extattr_block_check(ip, bp); if (error) { brelse(bp); return (error); @@ -1130,6 +1145,7 @@ ext2_extattr_block_set(struct inode *ip, int attrnames } ext2_extattr_rehash(header, entry); + ext2_extattr_blk_csum_set(ip, bp); return (bwrite(bp)); } @@ -1177,6 +1193,7 @@ ext2_extattr_block_set(struct inode *ip, int attrnames } ext2_extattr_rehash(header, entry); + ext2_extattr_blk_csum_set(ip, bp); return (bwrite(bp)); } @@ -1207,7 +1224,8 @@ int ext2_extattr_free(struct inode *ip) return (EINVAL); } - error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); + error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), + bp->b_data + bp->b_bufsize); if (error) { brelse(bp); return (error); Modified: head/sys/fs/ext2fs/ext2_extattr.h ============================================================================== --- head/sys/fs/ext2fs/ext2_extattr.h Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_extattr.h Sun Jan 14 20:46:39 2018 (r327977) @@ -59,7 +59,9 @@ struct ext2fs_extattr_header { int32_t h_refcount; /* reference count */ int32_t h_blocks; /* number of disk blocks used */ int32_t h_hash; /* hash value of all attributes */ - uint32_t h_reserved[4]; /* zero right now */ + int32_t h_checksum; /* crc32c(uuid+id+xattrblock) */ + /* id = inum if refcount=1, blknum otherwise */ + uint32_t h_reserved[3]; /* zero right now */ }; struct ext2fs_extattr_dinode_header { Modified: head/sys/fs/ext2fs/ext2_extents.c ============================================================================== --- head/sys/fs/ext2fs/ext2_extents.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_extents.c Sun Jan 14 20:46:39 2018 (r327977) @@ -425,9 +425,11 @@ ext4_ext_find_extent(struct inode *ip, daddr_t block, bqrelse(bp); eh = ext4_ext_block_header(path[ppos].ep_data); - error = ext4_ext_check_header(ip, eh); - if (error) + if (ext4_ext_check_header(ip, eh) || + ext2_extent_blk_csum_verify(ip, path[ppos].ep_data)) { + error = EIO; goto error; + } path[ppos].ep_header = eh; @@ -622,6 +624,7 @@ ext4_ext_dirty(struct inode *ip, struct ext4_extent_pa if (!bp) return (EIO); ext4_ext_fill_path_buf(path, bp); + ext2_extent_blk_csum_set(ip, bp->b_data); error = bwrite(bp); } else { ip->i_flag |= IN_CHANGE | IN_UPDATE; @@ -791,6 +794,7 @@ ext4_ext_split(struct inode *ip, struct ext4_extent_pa neh->eh_ecount = neh->eh_ecount + m; } + ext2_extent_blk_csum_set(ip, bp->b_data); bwrite(bp); bp = NULL; @@ -838,6 +842,7 @@ ext4_ext_split(struct inode *ip, struct ext4_extent_pa neh->eh_ecount = neh->eh_ecount + m; } + ext2_extent_blk_csum_set(ip, bp->b_data); bwrite(bp); bp = NULL; @@ -905,6 +910,7 @@ ext4_ext_grow_indepth(struct inode *ip, struct ext4_ex else neh->eh_max = ext4_ext_space_block(ip); + ext2_extent_blk_csum_set(ip, bp->b_data); error = bwrite(bp); if (error) goto out; Modified: head/sys/fs/ext2fs/ext2_extents.h ============================================================================== --- head/sys/fs/ext2fs/ext2_extents.h Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_extents.h Sun Jan 14 20:46:39 2018 (r327977) @@ -43,6 +43,13 @@ #define EXT4_EXT_CACHE_IN 2 /* + * Ext4 extent tail with csum + */ +struct ext4_extent_tail { + uint32_t et_checksum; /* crc32c(uuid+inum+extent_block) */ +}; + +/* * Ext4 file system extent on disk. */ struct ext4_extent { Modified: head/sys/fs/ext2fs/ext2_extern.h ============================================================================== --- head/sys/fs/ext2fs/ext2_extern.h Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_extern.h Sun Jan 14 20:46:39 2018 (r327977) @@ -66,7 +66,7 @@ int ext4_bmapext(struct vnode *, int32_t, int64_t *, i void ext2_clusteracct(struct m_ext2fs *, char *, int, e4fs_daddr_t, int); void ext2_dirbad(struct inode *ip, doff_t offset, char *how); void ext2_fserr(struct m_ext2fs *, uid_t, char *); -void ext2_ei2i(struct ext2fs_dinode *, struct inode *); +int ext2_ei2i(struct ext2fs_dinode *, struct inode *); int ext2_getlbns(struct vnode *, daddr_t, struct indir *, int *); int ext2_i2ei(struct inode *, struct ext2fs_dinode *); void ext2_itimes(struct vnode *vp); @@ -103,9 +103,25 @@ int ext2_htree_lookup(struct inode *, const char *, in int ext2_search_dirblock(struct inode *, void *, int *, const char *, int, int *, doff_t *, doff_t *, doff_t *, struct ext2fs_searchslot *); uint32_t e2fs_gd_get_ndirs(struct ext2_gd *gd); -uint64_t e2fs_gd_get_i_tables(struct ext2_gd *gd); -int ext2_gd_csum_verify(struct m_ext2fs *fs, struct cdev *dev); -void ext2_gd_csum_set(struct m_ext2fs *fs); +uint64_t e2fs_gd_get_i_tables(struct ext2_gd *); +void ext2_sb_csum_set_seed(struct m_ext2fs *); +int ext2_sb_csum_verify(struct m_ext2fs *); +void ext2_sb_csum_set(struct m_ext2fs *); +int ext2_extattr_blk_csum_verify(struct inode *, struct buf *); +void ext2_extattr_blk_csum_set(struct inode *, struct buf *); +int ext2_dir_blk_csum_verify(struct inode *, struct buf *); +void ext2_dir_blk_csum_set(struct inode *, struct buf *); +void ext2_dir_blk_csum_set_mem(struct inode *, char *, int); +int ext2_extent_blk_csum_verify(struct inode *, void *); +void ext2_extent_blk_csum_set(struct inode *, void *); +int ext2_gd_i_bitmap_csum_verify(struct m_ext2fs *, int, struct buf *); +void ext2_gd_i_bitmap_csum_set(struct m_ext2fs *, int, struct buf *); +int ext2_gd_b_bitmap_csum_verify(struct m_ext2fs *, int, struct buf *); +void ext2_gd_b_bitmap_csum_set(struct m_ext2fs *, int, struct buf *); +int ext2_ei_csum_verify(struct inode *, struct ext2fs_dinode *); +void ext2_ei_csum_set(struct inode *, struct ext2fs_dinode *); +int ext2_gd_csum_verify(struct m_ext2fs *, struct cdev *); +void ext2_gd_csum_set(struct m_ext2fs *); /* Flags to low-level allocation routines. Modified: head/sys/fs/ext2fs/ext2_inode_cnv.c ============================================================================== --- head/sys/fs/ext2fs/ext2_inode_cnv.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_inode_cnv.c Sun Jan 14 20:46:39 2018 (r327977) @@ -34,6 +34,7 @@ #include <sys/stat.h> #include <sys/vnode.h> +#include <fs/ext2fs/ext2fs.h> #include <fs/ext2fs/fs.h> #include <fs/ext2fs/inode.h> #include <fs/ext2fs/ext2fs.h> @@ -86,9 +87,11 @@ ext2_print_inode(struct inode *in) /* * raw ext2 inode to inode */ -void +int ext2_ei2i(struct ext2fs_dinode *ei, struct inode *ip) { + const static struct ext2fs_dinode ei_zero; + ip->i_nlink = ei->e2di_nlink; /* * Godmar thinks - if the link count is zero, then the inode is @@ -131,6 +134,11 @@ ext2_ei2i(struct ext2fs_dinode *ei, struct inode *ip) ip->i_gid |= (uint32_t)ei->e2di_gid_high << 16; memcpy(ip->i_data, ei->e2di_blocks, sizeof(ei->e2di_blocks)); + + if (memcmp(ei, &ei_zero, sizeof(struct ext2fs_dinode))) + return (ext2_ei_csum_verify(ip, ei)); + + return (0); } /* @@ -190,6 +198,9 @@ ext2_i2ei(struct inode *ip, struct ext2fs_dinode *ei) ei->e2di_gid_high = ip->i_gid >> 16 & 0xffff; memcpy(ei->e2di_blocks, ip->i_data, sizeof(ei->e2di_blocks)); + + /* Set inode csum */ + ext2_ei_csum_set(ip, ei); return (0); } Modified: head/sys/fs/ext2fs/ext2_lookup.c ============================================================================== --- head/sys/fs/ext2fs/ext2_lookup.c Sun Jan 14 20:36:21 2018 (r327976) +++ head/sys/fs/ext2fs/ext2_lookup.c Sun Jan 14 20:46:39 2018 (r327977) @@ -63,6 +63,7 @@ #include <fs/ext2fs/ext2_dinode.h> *** DIFF OUTPUT TRUNCATED AT 1000 LINES *** _______________________________________________ svn-src-all@freebsd.org mailing list https://lists.freebsd.org/mailman/listinfo/svn-src-all To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"
