xfs: fix [f]inobt magic value verification
cover xfs: fix [f]inobt magic value verification
Hi all,
Here's a first non-rfc version of the finobt magic fixup. There is still a bit of trepidation over this approach based on the rfcv2 feedback, but I've not seen a good enough (IMO) alternative that justifies reworking what I've tested so far. I'm posting this v1 with the caveat that only the first two patches are required to implement the desired per-inobt magic value verification logic.
Patches 3-4 include optional conversions of other verifiers and patch 5 is just a typo fixup (which could be folded into any other otherwise acceptable patch). I separated out patch 3 as an independent patch because I thought there was more value in the code cleanup (eliminating ~50 lines of cruft) than for the remaining verifiers. I skipped a few others where the lower level verification seemed a bit more logically removed from the buffer verifier itself (i.e., dquot, inode).
Note again that this depends on Darrick's scrub ->b_ops fixup [1].
Brian
[1] https://marc.info/?l=linux-xfs&m=154861208322420&w=2
v1:
- Remove endian conversion from helper.
- Drop finobt bad magic mitigation patch.
- Additional verifier magic fixups.
- Add verifier name typo fixup.
rfcv2: https://marc.info/?l=linux-xfs&m=154868884311668&w=2
- Split off finobt verifier into separate patch, assign it appropriately.
- Created helpers for xfs_buf_ops magic value verification.
- Added error mitigation patch for problematic finobt blocks.
rfcv1: https://marc.info/?l=linux-xfs&m=154834528212262&w=2
Brian Foster (5):
xfs: create a separate finobt verifier
xfs: distinguish between inobt and finobt magic values
xfs: use verifier magic field in dir2 leaf verifiers
xfs: miscellaneous verifier magic value fixups
xfs: fix typo in xfs_inode_buf_ra_ops verifier name
fs/xfs/libxfs/xfs_ag.c | 2 +- fs/xfs/libxfs/xfs_alloc.c | 12 +++-- fs/xfs/libxfs/xfs_attr_leaf.c | 10 ++-- fs/xfs/libxfs/xfs_attr_remote.c | 8 +-- fs/xfs/libxfs/xfs_bmap_btree.c | 12 ++--- fs/xfs/libxfs/xfs_da_btree.c | 10 ++-- fs/xfs/libxfs/xfs_dir2_block.c | 9 ++-- fs/xfs/libxfs/xfs_dir2_data.c | 9 ++-- fs/xfs/libxfs/xfs_dir2_leaf.c | 86 +++++++----------------------- fs/xfs/libxfs/xfs_dir2_node.c | 10 ++-- fs/xfs/libxfs/xfs_ialloc.c | 3 +- fs/xfs/libxfs/xfs_ialloc_btree.c | 24 +++++---- fs/xfs/libxfs/xfs_inode_buf.c | 2 +- fs/xfs/libxfs/xfs_refcount_btree.c | 3 +- fs/xfs/libxfs/xfs_rmap_btree.c | 3 +- fs/xfs/libxfs/xfs_sb.c | 4 +- fs/xfs/libxfs/xfs_shared.h | 1 + fs/xfs/libxfs/xfs_symlink_remote.c | 3 +- fs/xfs/scrub/agheader_repair.c | 2 +- fs/xfs/xfs_buf.h | 20 +++++++ fs/xfs/xfs_log_recover.c | 6 ++- 21 files changed, 110 insertions(+), 129 deletions(-)
Signature · 1 line
2.17.2
PATCH 1/5 xfs: create a separate finobt verifier
The inobt verifier is reused for the inobt and finobt, which prevents the ability to distinguish between magic values on a per-tree basis. Create a separate finobt structure in preparation for changes to enforce the appropriate magic value for the associated tree. This patch has no functional change.
--- fs/xfs/libxfs/xfs_ag.c | 2 +- fs/xfs/libxfs/xfs_ialloc_btree.c | 9 ++++++++- fs/xfs/libxfs/xfs_shared.h | 1 + fs/xfs/scrub/agheader_repair.c | 2 +- fs/xfs/xfs_log_recover.c | 6 ++++-- 5 files changed, 15 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_ag.c +1 -1
@@ -361,7 +361,7 @@ xfs_ag_init_headers( {/* FINO root block */ .daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_FIBT_BLOCK(mp)), .numblks = BTOBB(mp->m_sb.sb_blocksize), - .ops = &xfs_inobt_buf_ops, + .ops = &xfs_finobt_buf_ops, .work = &xfs_btroot_init, .type =XFS_BTNUM_FINO , .need_init = xfs_sb_version_hasfinobt(&mp->m_sb)
fs/xfs/libxfs/xfs_ialloc_btree.c +8 -1
@@ -333,6 +333,13 @@ const struct xfs_buf_ops xfs_inobt_buf_ops = { .verify_struct = xfs_inobt_verify, }; +const struct xfs_buf_ops xfs_finobt_buf_ops = { + .name ="xfs_finobt" , + .verify_read = xfs_inobt_read_verify, + .verify_write = xfs_inobt_write_verify, + .verify_struct = xfs_inobt_verify, +}; + STATIC int xfs_inobt_keys_inorder( struct xfs_btree_cur *cur,
@@ -389,7 +396,7 @@ static const struct xfs_btree_ops xfs_finobt_ops = { .init_rec_from_cur = xfs_inobt_init_rec_from_cur, .init_ptr_from_cur = xfs_finobt_init_ptr_from_cur, .key_diff = xfs_inobt_key_diff, - .buf_ops = &xfs_inobt_buf_ops, + .buf_ops = &xfs_finobt_buf_ops, .diff_two_keys = xfs_inobt_diff_two_keys, .keys_inorder = xfs_inobt_keys_inorder, .recs_inorder = xfs_inobt_recs_inorder,
fs/xfs/libxfs/xfs_shared.h +1 -0
@@ -36,6 +36,7 @@ extern const struct xfs_buf_ops xfs_dquot_buf_ops;extern const struct xfs_buf_ops xfs_symlink_buf_ops;extern const struct xfs_buf_ops xfs_agi_buf_ops;extern const struct xfs_buf_ops xfs_inobt_buf_ops; +extern const struct xfs_buf_ops xfs_finobt_buf_ops;extern const struct xfs_buf_ops xfs_inode_buf_ops;extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;extern const struct xfs_buf_ops xfs_dquot_buf_ops;
fs/xfs/scrub/agheader_repair.c +1 -1
@@ -879,7 +879,7 @@ xrep_agi( }, [XREP_AGI_FINOBT] = { .rmap_owner = XFS_RMAP_OWN_INOBT, - .buf_ops = &xfs_inobt_buf_ops, + .buf_ops = &xfs_finobt_buf_ops, .magic = XFS_FIBT_CRC_MAGIC, }, [XREP_AGI_END] = {
fs/xfs/xfs_log_recover.c +4 -2
@@ -2445,11 +2445,13 @@ xlog_recover_validate_buf_type( bp->b_ops = &xfs_allocbt_buf_ops;break ;case XFS_IBT_CRC_MAGIC : -case XFS_FIBT_CRC_MAGIC :case XFS_IBT_MAGIC : -case XFS_FIBT_MAGIC : bp->b_ops = &xfs_inobt_buf_ops;break ; +case XFS_FIBT_CRC_MAGIC : +case XFS_FIBT_MAGIC : + bp->b_ops = &xfs_finobt_buf_ops; +break ;case XFS_BMAP_CRC_MAGIC :case XFS_BMAP_MAGIC : bp->b_ops = &xfs_bmbt_buf_ops;
Signature · 1 line
2.17.2
PATCH 2/5 xfs: distinguish between inobt and finobt magic values
In reply to Brian FosterThe inode btree verifier code is shared between the inode btree and free inode btree because the underlying metadata formats are essentially equivalent. A side effect of this is that the verifier cannot determine whether a particular btree block should have an inobt or finobt magic value.
This logic allows an unfortunate xfs_repair bug to escape detection where certain level > 0 nodes of the finobt are stamped with inobt magic by xfs_repair finobt reconstruction. This is fortunately not a severe problem since the inode btree magic values do not contribute to any changes in kernel behavior, but we do need a means to detect and prevent this problem in the future.
Add a field to xfs_buf_ops to store the v4 and v5 superblock magic values expected by a particular verifier. Add a helper to check an on-disk magic value against the value expected by the verifier. Call the helper from the shared [f]inobt verifier code for magic value verification. This ensures that the inode btree blocks each have the appropriate magic value based on specific tree type and superblock version.
--- fs/xfs/libxfs/xfs_ialloc_btree.c | 15 ++++++--------- fs/xfs/xfs_buf.h | 20 ++++++++++++++++++++ 2 files changed, 26 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_ialloc_btree.c +6 -9
@@ -260,6 +260,9 @@ xfs_inobt_verify(xfs_failaddr_t fa;unsigned int level; +if (!xfs_verify_magic (bp,be32_to_cpu (block->bb_magic))) +return __this_address; +/* * During growfs operations, we can't verify the exact owner as the * perag is not fully initialised and hence not attached to the buffer.
@@ -270,18 +273,10 @@ xfs_inobt_verify(* but beware of the landmine (i.e. need to check pag->pagi_init) if we * ever do. */ -switch (block->bb_magic) { -case cpu_to_be32 (XFS_IBT_CRC_MAGIC ): -case cpu_to_be32 (XFS_FIBT_CRC_MAGIC ): +if (xfs_sb_version_hascrc (&mp->m_sb)) { fa =xfs_btree_sblock_v5hdr_verify (bp);if (fa)return fa; -/* fall through */ -case cpu_to_be32 (XFS_IBT_MAGIC ): -case cpu_to_be32 (XFS_FIBT_MAGIC ): -break ; -default : -return __this_address; }/* level verification */
@@ -328,6 +323,7 @@ xfs_inobt_write_verify(const struct xfs_buf_ops xfs_inobt_buf_ops = { .name ="xfs_inobt" , + .magic = {XFS_IBT_MAGIC ,XFS_IBT_CRC_MAGIC }, .verify_read = xfs_inobt_read_verify, .verify_write = xfs_inobt_write_verify, .verify_struct = xfs_inobt_verify,
@@ -335,6 +331,7 @@ const struct xfs_buf_ops xfs_inobt_buf_ops = {const struct xfs_buf_ops xfs_finobt_buf_ops = { .name ="xfs_finobt" , + .magic = {XFS_FIBT_MAGIC ,XFS_FIBT_CRC_MAGIC }, .verify_read = xfs_inobt_read_verify, .verify_write = xfs_inobt_write_verify, .verify_struct = xfs_inobt_verify,
fs/xfs/xfs_buf.h +20 -0
@@ -125,6 +125,7 @@ struct xfs_buf_map {struct xfs_buf_ops {char *name; +uint32_t magic[2 ];void (*verify_read)(struct xfs_buf *);void (*verify_write)(struct xfs_buf *);xfs_failaddr_t (*verify_struct)(struct xfs_buf *bp);
@@ -387,4 +388,23 @@ extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int);int xfs_buf_ensure_ops (struct xfs_buf *bp,const struct xfs_buf_ops *ops); +/* +* Verify an on-disk magic value against the magic value specified in the +* verifier structure. The verifier magic is in CPU byte order. The disk magic +* must be converted by the caller. +*/ +static inline bool +xfs_buf_ops_verify_magic ( +struct xfs_buf *bp, +uint32_t dmagic, +bool crc) +{ +if (unlikely (WARN_ON (!bp->b_ops || !bp->b_ops->magic[crc]))) +return false; +return dmagic == bp->b_ops->magic[crc]; +} +#define xfs_verify_magic (bp, dmagic) \ + xfs_buf_ops_verify_magic(bp, dmagic, \ + xfs_sb_version_hascrc(&bp->b_target->bt_mount->m_sb)) +#endif /* __XFS_BUF_H__ */
Signature · 1 line
2.17.2
PATCH 3/5 xfs: use verifier magic field in dir2 leaf verifiers
In reply to Brian FosterThe dir2 leaf verifiers share the same underlying structure verification code, but implement six accessor functions to multiplex the code across the two verifiers. Further, the magic value isn't sufficiently abstracted such that the common helper has to manually fix up the magic from the caller on v5 filesystems.
Use the magic field in the verifier structure to eliminate the duplicate code and clean this all up. No functional change.
--- fs/xfs/libxfs/xfs_dir2_leaf.c | 86 ++++++++--------------------------- 1 file changed, 18 insertions(+), 68 deletions(-)
fs/xfs/libxfs/xfs_dir2_leaf.c +18 -68
@@ -142,41 +142,32 @@ xfs_dir3_leaf_check_int(*/ static xfs_failaddr_t xfs_dir3_leaf_verify ( -struct xfs_buf *bp, -uint16_t magic) +struct xfs_buf *bp) {struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_dir2_leaf *leaf = bp->b_addr; -ASSERT (magic ==XFS_DIR2_LEAF1_MAGIC || magic ==XFS_DIR2_LEAFN_MAGIC ); +if (!xfs_verify_magic (bp,be16_to_cpu (leaf->hdr.info.magic))) +return __this_address;if (xfs_sb_version_hascrc (&mp->m_sb)) {struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr; -uint16_t magic3; - magic3 = (magic ==XFS_DIR2_LEAF1_MAGIC ) ?XFS_DIR3_LEAF1_MAGIC - :XFS_DIR3_LEAFN_MAGIC ; - -if (leaf3->info.hdr.magic !=cpu_to_be16 (magic3)) -return __this_address; +ASSERT (leaf3->info.hdr.magic == leaf->hdr.info.magic);if (!uuid_equal (&leaf3->info.uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (leaf3->info.blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (leaf3->info.lsn)))return __this_address; - }else { -if (leaf->hdr.info.magic !=cpu_to_be16 (magic)) -return __this_address; }return xfs_dir3_leaf_check_int (mp,NULL ,NULL , leaf); }static void -__read_verify ( -struct xfs_buf *bp, -uint16_t magic) +xfs_dir3_leaf_read_verify ( +struct xfs_buf *bp) {struct xfs_mount *mp = bp->b_target->bt_mount;xfs_failaddr_t fa;
@@ -185,23 +176,22 @@ __read_verify( !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF)) xfs_verifier_error(bp, -EFSBADCRC, __this_address); else { - fa =xfs_dir3_leaf_verify (bp, magic); + fa =xfs_dir3_leaf_verify (bp);if (fa)xfs_verifier_error (bp, -EFSCORRUPTED , fa); } }static void -__write_verify ( -struct xfs_buf *bp, -uint16_t magic) +xfs_dir3_leaf_write_verify ( +struct xfs_buf *bp) {struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_buf_log_item *bip = bp->b_log_item;struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;xfs_failaddr_t fa; - fa =xfs_dir3_leaf_verify (bp, magic); + fa =xfs_dir3_leaf_verify (bp);if (fa) {xfs_verifier_error (bp, -EFSCORRUPTED , fa);return ;
@@ -216,60 +206,20 @@ __write_verify(xfs_buf_update_cksum (bp,XFS_DIR3_LEAF_CRC_OFF ); } -static xfs_failaddr_t -xfs_dir3_leaf1_verify ( -struct xfs_buf *bp) -{ -return xfs_dir3_leaf_verify (bp,XFS_DIR2_LEAF1_MAGIC ); -} - -static void -xfs_dir3_leaf1_read_verify ( -struct xfs_buf *bp) -{ -__read_verify (bp,XFS_DIR2_LEAF1_MAGIC ); -} - -static void -xfs_dir3_leaf1_write_verify ( -struct xfs_buf *bp) -{ -__write_verify (bp,XFS_DIR2_LEAF1_MAGIC ); -} - -static xfs_failaddr_t -xfs_dir3_leafn_verify ( -struct xfs_buf *bp) -{ -return xfs_dir3_leaf_verify (bp,XFS_DIR2_LEAFN_MAGIC ); -} - -static void -xfs_dir3_leafn_read_verify ( -struct xfs_buf *bp) -{ -__read_verify (bp,XFS_DIR2_LEAFN_MAGIC ); -} - -static void -xfs_dir3_leafn_write_verify ( -struct xfs_buf *bp) -{ -__write_verify (bp,XFS_DIR2_LEAFN_MAGIC ); -} -const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops = { .name ="xfs_dir3_leaf1" , - .verify_read = xfs_dir3_leaf1_read_verify, - .verify_write = xfs_dir3_leaf1_write_verify, - .verify_struct = xfs_dir3_leaf1_verify, + .magic = {XFS_DIR2_LEAF1_MAGIC ,XFS_DIR3_LEAF1_MAGIC }, + .verify_read = xfs_dir3_leaf_read_verify, + .verify_write = xfs_dir3_leaf_write_verify, + .verify_struct = xfs_dir3_leaf_verify, };const struct xfs_buf_ops xfs_dir3_leafn_buf_ops = { .name ="xfs_dir3_leafn" , - .verify_read = xfs_dir3_leafn_read_verify, - .verify_write = xfs_dir3_leafn_write_verify, - .verify_struct = xfs_dir3_leafn_verify, + .magic = {XFS_DIR2_LEAFN_MAGIC ,XFS_DIR3_LEAFN_MAGIC }, + .verify_read = xfs_dir3_leaf_read_verify, + .verify_write = xfs_dir3_leaf_write_verify, + .verify_struct = xfs_dir3_leaf_verify, };int
Signature · 1 line
2.17.2
PATCH 4/5 xfs: miscellaneous verifier magic value fixups
In reply to Brian FosterMost buffer verifiers have hardcoded magic value checks conditionalized on the version of the filesystem. The magic value field of the verifier structure facilitates abstraction of some of this code. Populate the ->magic field of various verifiers to take advantage of this abstraction. No functional changes.
--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++---- fs/xfs/libxfs/xfs_attr_leaf.c | 10 ++++------ fs/xfs/libxfs/xfs_attr_remote.c | 8 +++++--- fs/xfs/libxfs/xfs_bmap_btree.c | 12 +++++------- fs/xfs/libxfs/xfs_da_btree.c | 10 ++++------ fs/xfs/libxfs/xfs_dir2_block.c | 9 ++++----- fs/xfs/libxfs/xfs_dir2_data.c | 9 ++++----- fs/xfs/libxfs/xfs_dir2_node.c | 10 +++++----- fs/xfs/libxfs/xfs_ialloc.c | 3 ++- fs/xfs/libxfs/xfs_refcount_btree.c | 3 ++- fs/xfs/libxfs/xfs_rmap_btree.c | 3 ++- fs/xfs/libxfs/xfs_sb.c | 4 +++- fs/xfs/libxfs/xfs_symlink_remote.c | 3 ++- 13 files changed, 50 insertions(+), 46 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +8 -4
@@ -568,9 +568,9 @@ xfs_agfl_verify(if (!xfs_sb_version_hascrc (&mp->m_sb))return NULL ; -if (!uuid_equal (&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid)) +if (!xfs_verify_magic (bp,be32_to_cpu (agfl->agfl_magicnum)))return __this_address; -if (be32_to_cpu (agfl->agfl_magicnum) !=XFS_AGFL_MAGIC ) +if (!uuid_equal (&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid))return __this_address;/* * during growfs operations, the perag is not fully initialised,
@@ -643,6 +643,7 @@ xfs_agfl_write_verify(const struct xfs_buf_ops xfs_agfl_buf_ops = { .name ="xfs_agfl" , + .magic = {XFS_AGFL_MAGIC ,XFS_AGFL_MAGIC }, .verify_read = xfs_agfl_read_verify, .verify_write = xfs_agfl_write_verify, .verify_struct = xfs_agfl_verify,
@@ -2587,8 +2588,10 @@ xfs_agf_verify(return __this_address; } - if (!(agf->agf_magicnum == cpu_to_be32(XFS_AGF_MAGIC) && - XFS_AGF_GOOD_VERSION(be32_to_cpu(agf->agf_versionnum)) && +if (!xfs_verify_magic (bp,be32_to_cpu (agf->agf_magicnum))) +return __this_address; + + if (!(XFS_AGF_GOOD_VERSION(be32_to_cpu(agf->agf_versionnum)) && be32_to_cpu(agf->agf_freeblks) <= be32_to_cpu(agf->agf_length) && be32_to_cpu(agf->agf_flfirst) < xfs_agfl_size(mp) && be32_to_cpu(agf->agf_fllast) < xfs_agfl_size(mp) &&
@@ -2670,6 +2673,7 @@ xfs_agf_write_verify(const struct xfs_buf_ops xfs_agf_buf_ops = { .name ="xfs_agf" , + .magic = {XFS_AGF_MAGIC ,XFS_AGF_MAGIC }, .verify_read = xfs_agf_read_verify, .verify_write = xfs_agf_write_verify, .verify_struct = xfs_agf_verify,
fs/xfs/libxfs/xfs_attr_leaf.c +4 -6
@@ -248,21 +248,18 @@ xfs_attr3_leaf_verify(xfs_attr3_leaf_hdr_from_disk (mp->m_attr_geo, &ichdr, leaf); +if (!xfs_verify_magic (bp, ichdr.magic)) +return __this_address; +if (xfs_sb_version_hascrc (&mp->m_sb)) {struct xfs_da3_node_hdr *hdr3 = bp->b_addr; -if (ichdr.magic !=XFS_ATTR3_LEAF_MAGIC ) -return __this_address; -if (!uuid_equal (&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (hdr3->info.blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr3->info.lsn)))return __this_address; - }else { -if (ichdr.magic !=XFS_ATTR_LEAF_MAGIC ) -return __this_address; }/* * In recovery there is a transient state where count == 0 is valid
@@ -369,6 +366,7 @@ xfs_attr3_leaf_read_verify(const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = { .name ="xfs_attr3_leaf" , + .magic = {XFS_ATTR_LEAF_MAGIC ,XFS_ATTR3_LEAF_MAGIC }, .verify_read = xfs_attr3_leaf_read_verify, .verify_write = xfs_attr3_leaf_write_verify, .verify_struct = xfs_attr3_leaf_verify,
fs/xfs/libxfs/xfs_attr_remote.c +5 -3
@@ -79,6 +79,7 @@ xfs_attr3_rmt_hdr_ok(static xfs_failaddr_t xfs_attr3_rmt_verify (struct xfs_mount *mp, +struct xfs_buf *bp,void *ptr,int fsbsize,xfs_daddr_t bno)
@@ -87,7 +88,7 @@ xfs_attr3_rmt_verify(if (!xfs_sb_version_hascrc (&mp->m_sb))return __this_address; -if (rmt->rm_magic !=cpu_to_be32 (XFS_ATTR3_RMT_MAGIC )) +if (!xfs_verify_magic (bp,be32_to_cpu (rmt->rm_magic)))return __this_address;if (!uuid_equal (&rmt->rm_uuid, &mp->m_sb.sb_meta_uuid))return __this_address;
@@ -131,7 +132,7 @@ __xfs_attr3_rmt_read_verify( *failaddr = __this_address;return -EFSBADCRC ; } - *failaddr =xfs_attr3_rmt_verify (mp, ptr, blksize, bno); + *failaddr =xfs_attr3_rmt_verify (mp, bp, ptr, blksize, bno);if (*failaddr)return -EFSCORRUPTED ; len -= blksize;
@@ -193,7 +194,7 @@ xfs_attr3_rmt_write_verify(while (len >0 ) {struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr; - fa =xfs_attr3_rmt_verify (mp, ptr, blksize, bno); + fa =xfs_attr3_rmt_verify (mp, bp, ptr, blksize, bno);if (fa) {xfs_verifier_error (bp, -EFSCORRUPTED , fa);return ;
@@ -220,6 +221,7 @@ xfs_attr3_rmt_write_verify(const struct xfs_buf_ops xfs_attr3_rmt_buf_ops = { .name ="xfs_attr3_rmt" , + .magic = {0 ,XFS_ATTR3_RMT_MAGIC }, .verify_read = xfs_attr3_rmt_read_verify, .verify_write = xfs_attr3_rmt_write_verify, .verify_struct = xfs_attr3_rmt_verify_struct,
fs/xfs/libxfs/xfs_bmap_btree.c +5 -7
@@ -416,8 +416,10 @@ xfs_bmbt_verify(xfs_failaddr_t fa;unsigned int level; -switch (block->bb_magic) { -case cpu_to_be32 (XFS_BMAP_CRC_MAGIC ): +if (!xfs_verify_magic (bp,be32_to_cpu (block->bb_magic))) +return __this_address; + +if (xfs_sb_version_hascrc (&mp->m_sb)) {/* * XXX: need a better way of verifying the owner here. Right now * just make sure there has been one set.
@@ -425,11 +427,6 @@ xfs_bmbt_verify( fa =xfs_btree_lblock_v5hdr_verify (bp,XFS_RMAP_OWN_UNKNOWN );if (fa)return fa; -/* fall through */ -case cpu_to_be32 (XFS_BMAP_MAGIC ): -break ; -default : -return __this_address; }/*
@@ -481,6 +478,7 @@ xfs_bmbt_write_verify(const struct xfs_buf_ops xfs_bmbt_buf_ops = { .name ="xfs_bmbt" , + .magic = {XFS_BMAP_MAGIC ,XFS_BMAP_CRC_MAGIC }, .verify_read = xfs_bmbt_read_verify, .verify_write = xfs_bmbt_write_verify, .verify_struct = xfs_bmbt_verify,
fs/xfs/libxfs/xfs_da_btree.c +4 -6
@@ -129,21 +129,18 @@ xfs_da3_node_verify( ops->node_hdr_from_disk (&ichdr, hdr); +if (!xfs_verify_magic (bp, ichdr.magic)) +return __this_address; +if (xfs_sb_version_hascrc (&mp->m_sb)) {struct xfs_da3_node_hdr *hdr3 = bp->b_addr; -if (ichdr.magic !=XFS_DA3_NODE_MAGIC ) -return __this_address; -if (!uuid_equal (&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (hdr3->info.blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr3->info.lsn)))return __this_address; - }else { -if (ichdr.magic !=XFS_DA_NODE_MAGIC ) -return __this_address; }if (ichdr.level ==0 )return __this_address;
@@ -257,6 +254,7 @@ xfs_da3_node_verify_struct(const struct xfs_buf_ops xfs_da3_node_buf_ops = { .name ="xfs_da3_node" , + .magic = {XFS_DA_NODE_MAGIC ,XFS_DA3_NODE_MAGIC }, .verify_read = xfs_da3_node_read_verify, .verify_write = xfs_da3_node_write_verify, .verify_struct = xfs_da3_node_verify_struct,
fs/xfs/libxfs/xfs_dir2_block.c +4 -5
@@ -53,18 +53,16 @@ xfs_dir3_block_verify(struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; +if (!xfs_verify_magic (bp,be32_to_cpu (hdr3->magic))) +return __this_address; +if (xfs_sb_version_hascrc (&mp->m_sb)) { -if (hdr3->magic !=cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC )) -return __this_address;if (!uuid_equal (&hdr3->uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (hdr3->blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr3->lsn)))return __this_address; - }else { -if (hdr3->magic !=cpu_to_be32 (XFS_DIR2_BLOCK_MAGIC )) -return __this_address; }return __xfs_dir3_data_check (NULL , bp); }
@@ -112,6 +110,7 @@ xfs_dir3_block_write_verify(const struct xfs_buf_ops xfs_dir3_block_buf_ops = { .name ="xfs_dir3_block" , + .magic = {XFS_DIR2_BLOCK_MAGIC ,XFS_DIR3_BLOCK_MAGIC }, .verify_read = xfs_dir3_block_read_verify, .verify_write = xfs_dir3_block_write_verify, .verify_struct = xfs_dir3_block_verify,
fs/xfs/libxfs/xfs_dir2_data.c +4 -5
@@ -252,18 +252,16 @@ xfs_dir3_data_verify(struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; +if (!xfs_verify_magic (bp,be32_to_cpu (hdr3->magic))) +return __this_address; +if (xfs_sb_version_hascrc (&mp->m_sb)) { -if (hdr3->magic !=cpu_to_be32 (XFS_DIR3_DATA_MAGIC )) -return __this_address;if (!uuid_equal (&hdr3->uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (hdr3->blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr3->lsn)))return __this_address; - }else { -if (hdr3->magic !=cpu_to_be32 (XFS_DIR2_DATA_MAGIC )) -return __this_address; }return __xfs_dir3_data_check (NULL , bp); }
@@ -339,6 +337,7 @@ xfs_dir3_data_write_verify(const struct xfs_buf_ops xfs_dir3_data_buf_ops = { .name ="xfs_dir3_data" , + .magic = {XFS_DIR2_DATA_MAGIC ,XFS_DIR3_DATA_MAGIC }, .verify_read = xfs_dir3_data_read_verify, .verify_write = xfs_dir3_data_write_verify, .verify_struct = xfs_dir3_data_verify,
fs/xfs/libxfs/xfs_dir2_node.c +5 -5
@@ -87,20 +87,19 @@ xfs_dir3_free_verify(struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_dir2_free_hdr *hdr = bp->b_addr; +if (!xfs_verify_magic (bp,be32_to_cpu (hdr->magic))) +return __this_address; +if (xfs_sb_version_hascrc (&mp->m_sb)) {struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; -if (hdr3->magic !=cpu_to_be32 (XFS_DIR3_FREE_MAGIC )) -return __this_address; +ASSERT (hdr3->magic == hdr->magic);if (!uuid_equal (&hdr3->uuid, &mp->m_sb.sb_meta_uuid))return __this_address;if (be64_to_cpu (hdr3->blkno) != bp->b_bn)return __this_address;if (!xfs_log_check_lsn (mp,be64_to_cpu (hdr3->lsn)))return __this_address; - }else { -if (hdr->magic !=cpu_to_be32 (XFS_DIR2_FREE_MAGIC )) -return __this_address; }/* XXX: should bounds check the xfs_dir3_icfree_hdr here */
@@ -151,6 +150,7 @@ xfs_dir3_free_write_verify(const struct xfs_buf_ops xfs_dir3_free_buf_ops = { .name ="xfs_dir3_free" , + .magic = {XFS_DIR2_FREE_MAGIC ,XFS_DIR3_FREE_MAGIC }, .verify_read = xfs_dir3_free_read_verify, .verify_write = xfs_dir3_free_write_verify, .verify_struct = xfs_dir3_free_verify,
fs/xfs/libxfs/xfs_ialloc.c +2 -1
@@ -2508,7 +2508,7 @@ xfs_agi_verify(/* * Validate the magic number of the agi block. */ -if (agi->agi_magicnum !=cpu_to_be32 (XFS_AGI_MAGIC )) +if (!xfs_verify_magic (bp,be32_to_cpu (agi->agi_magicnum)))return __this_address;if (!XFS_AGI_GOOD_VERSION (be32_to_cpu (agi->agi_versionnum)))return __this_address;
@@ -2582,6 +2582,7 @@ xfs_agi_write_verify(const struct xfs_buf_ops xfs_agi_buf_ops = { .name ="xfs_agi" , + .magic = {XFS_AGI_MAGIC ,XFS_AGI_MAGIC }, .verify_read = xfs_agi_read_verify, .verify_write = xfs_agi_write_verify, .verify_struct = xfs_agi_verify,
fs/xfs/libxfs/xfs_refcount_btree.c +2 -1
@@ -209,7 +209,7 @@ xfs_refcountbt_verify(xfs_failaddr_t fa;unsigned int level; -if (block->bb_magic !=cpu_to_be32 (XFS_REFC_CRC_MAGIC )) +if (!xfs_verify_magic (bp,be32_to_cpu (block->bb_magic)))return __this_address;if (!xfs_sb_version_hasreflink (&mp->m_sb))
@@ -264,6 +264,7 @@ xfs_refcountbt_write_verify(const struct xfs_buf_ops xfs_refcountbt_buf_ops = { .name ="xfs_refcountbt" , + .magic = {0 ,XFS_REFC_CRC_MAGIC }, .verify_read = xfs_refcountbt_read_verify, .verify_write = xfs_refcountbt_write_verify, .verify_struct = xfs_refcountbt_verify,
fs/xfs/libxfs/xfs_rmap_btree.c +2 -1
@@ -310,7 +310,7 @@ xfs_rmapbt_verify(* from the on disk AGF. Again, we can only check against maximum limits * in this case. */ -if (block->bb_magic !=cpu_to_be32 (XFS_RMAP_CRC_MAGIC )) +if (!xfs_verify_magic (bp,be32_to_cpu (block->bb_magic)))return __this_address;if (!xfs_sb_version_hasrmapbt (&mp->m_sb))
@@ -365,6 +365,7 @@ xfs_rmapbt_write_verify(const struct xfs_buf_ops xfs_rmapbt_buf_ops = { .name ="xfs_rmapbt" , + .magic = {0 ,XFS_RMAP_CRC_MAGIC }, .verify_read = xfs_rmapbt_read_verify, .verify_write = xfs_rmapbt_write_verify, .verify_struct = xfs_rmapbt_verify,
fs/xfs/libxfs/xfs_sb.c +3 -1
@@ -228,7 +228,7 @@ xfs_validate_sb_common(uint32_t agcount =0 ;uint32_t rem; -if (sbp->sb_magicnum !=XFS_SB_MAGIC ) { +if (!xfs_verify_magic (bp, sbp->sb_magicnum)) {xfs_warn (mp,"bad magic number" );return -EWRONGFS ; }
@@ -781,12 +781,14 @@ xfs_sb_write_verify(const struct xfs_buf_ops xfs_sb_buf_ops = { .name ="xfs_sb" , + .magic = {XFS_SB_MAGIC ,XFS_SB_MAGIC }, .verify_read = xfs_sb_read_verify, .verify_write = xfs_sb_write_verify, };const struct xfs_buf_ops xfs_sb_quiet_buf_ops = { .name ="xfs_sb_quiet" , + .magic = {XFS_SB_MAGIC ,XFS_SB_MAGIC }, .verify_read = xfs_sb_quiet_read_verify, .verify_write = xfs_sb_write_verify, };
fs/xfs/libxfs/xfs_symlink_remote.c +2 -1
@@ -95,7 +95,7 @@ xfs_symlink_verify(if (!xfs_sb_version_hascrc (&mp->m_sb))return __this_address; -if (dsl->sl_magic !=cpu_to_be32 (XFS_SYMLINK_MAGIC )) +if (!xfs_verify_magic (bp,be32_to_cpu (dsl->sl_magic)))return __this_address;if (!uuid_equal (&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid))return __this_address;
@@ -159,6 +159,7 @@ xfs_symlink_write_verify(const struct xfs_buf_ops xfs_symlink_buf_ops = { .name ="xfs_symlink" , + .magic = {0 ,XFS_SYMLINK_MAGIC }, .verify_read = xfs_symlink_read_verify, .verify_write = xfs_symlink_write_verify, .verify_struct = xfs_symlink_verify,
Signature · 1 line
2.17.2
PATCH 5/5 xfs: fix typo in xfs_inode_buf_ra_ops verifier name
In reply to Brian FosterFix a typo in the struct xfs_inode_buf_ra_ops verifier name.
--- fs/xfs/libxfs/xfs_inode_buf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/libxfs/xfs_inode_buf.c +1 -1
@@ -152,7 +152,7 @@ const struct xfs_buf_ops xfs_inode_buf_ops = { };const struct xfs_buf_ops xfs_inode_buf_ra_ops = { - .name ="xxfs_inode_ra" , + .name ="xfs_inode_ra" , .verify_read = xfs_inode_buf_readahead_verify, .verify_write = xfs_inode_buf_write_verify, };
Signature · 1 line
2.17.2