xfs: miscellaneous verifier magic value fixups

Source kernel commit: 39708c20ab51337c3eb282a824eb0aaff7ebe2e1

Most 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.

Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/libxfs/xfs_alloc.c b/libxfs/xfs_alloc.c
index 189986ba6473475c80215c7f9ba0e8e646729660..7c2f2d76d448615e61946012f93961a72d79bbe1 100644 (file)
--- a/libxfs/xfs_alloc.c
+++ b/libxfs/xfs_alloc.c
@@ -564,9 +564,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, agfl->agfl_magicnum))
                return __this_address;
-       if (agfl->agfl_magicnum != cpu_to_be32(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,
@@ -639,6 +639,7 @@ xfs_agfl_write_verify(
 
 const struct xfs_buf_ops xfs_agfl_buf_ops = {
        .name = "xfs_agfl",
+       .magic = { cpu_to_be32(XFS_AGFL_MAGIC), cpu_to_be32(XFS_AGFL_MAGIC) },
        .verify_read = xfs_agfl_read_verify,
        .verify_write = xfs_agfl_write_verify,
        .verify_struct = xfs_agfl_verify,
@@ -2583,8 +2584,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, 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) &&
@@ -2666,6 +2669,7 @@ xfs_agf_write_verify(
 
 const struct xfs_buf_ops xfs_agf_buf_ops = {
        .name = "xfs_agf",
+       .magic = { cpu_to_be32(XFS_AGF_MAGIC), cpu_to_be32(XFS_AGF_MAGIC) },
        .verify_read = xfs_agf_read_verify,
        .verify_write = xfs_agf_write_verify,
        .verify_struct = xfs_agf_verify,

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index f13f5b14898a1029ccc88073d14d21e33bd79894..d0801791da57f8872b0c8410c90ebf33bf25f48e 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -243,21 +243,18 @@ xfs_attr3_leaf_verify(
 
        xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
 
+       if (!xfs_verify_magic(bp, leaf->hdr.info.magic))
+               return __this_address;
+
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
                struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 
-               if (hdr3->info.hdr.magic != cpu_to_be16(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 (leaf->hdr.info.magic != cpu_to_be16(XFS_ATTR_LEAF_MAGIC))
-                       return __this_address;
        }
        /*
         * In recovery there is a transient state where count == 0 is valid
@@ -364,6 +361,8 @@ xfs_attr3_leaf_read_verify(
 
 const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = {
        .name = "xfs_attr3_leaf",
+       .magic = { cpu_to_be16(XFS_ATTR_LEAF_MAGIC),
+                  cpu_to_be16(XFS_ATTR3_LEAF_MAGIC) },
        .verify_read = xfs_attr3_leaf_read_verify,
        .verify_write = xfs_attr3_leaf_write_verify,
        .verify_struct = xfs_attr3_leaf_verify,

diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index da3728af5d6b2a0722feea2329e5a171aaeb0080..7fe28a000382469d85382107c918c57332a61a5f 100644 (file)
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -74,6 +74,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)
@@ -82,7 +83,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, rmt->rm_magic))
                return __this_address;
        if (!uuid_equal(&rmt->rm_uuid, &mp->m_sb.sb_meta_uuid))
                return __this_address;
@@ -126,7 +127,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;
@@ -188,7 +189,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;
@@ -215,6 +216,7 @@ xfs_attr3_rmt_write_verify(
 
 const struct xfs_buf_ops xfs_attr3_rmt_buf_ops = {
        .name = "xfs_attr3_rmt",
+       .magic = { 0, cpu_to_be32(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,

diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
index 24c32a9c0c32d55c8d934e43c906157a6ae568d0..b16f90199b41f4bca607a38ecc8e1fee87adc231 100644 (file)
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -413,8 +413,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, 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.
@@ -422,11 +424,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;
        }
 
        /*
@@ -478,6 +475,8 @@ xfs_bmbt_write_verify(
 
 const struct xfs_buf_ops xfs_bmbt_buf_ops = {
        .name = "xfs_bmbt",
+       .magic = { cpu_to_be32(XFS_BMAP_MAGIC),
+                  cpu_to_be32(XFS_BMAP_CRC_MAGIC) },
        .verify_read = xfs_bmbt_read_verify,
        .verify_write = xfs_bmbt_write_verify,
        .verify_struct = xfs_bmbt_verify,

diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
index afc3c6839f1c48a92582e426bd174c17911e2476..cb419d1e0d9516ea0c8f60fa42f8a8bd308b5e21 100644 (file)
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -124,21 +124,18 @@ xfs_da3_node_verify(
 
        ops->node_hdr_from_disk(&ichdr, hdr);
 
+       if (!xfs_verify_magic(bp, hdr->hdr.info.magic))
+               return __this_address;
+
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
                struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 
-               if (hdr3->info.hdr.magic != cpu_to_be16(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 (hdr->hdr.info.magic != cpu_to_be16(XFS_DA_NODE_MAGIC))
-                       return __this_address;
        }
        if (ichdr.level == 0)
                return __this_address;
@@ -252,6 +249,8 @@ xfs_da3_node_verify_struct(
 
 const struct xfs_buf_ops xfs_da3_node_buf_ops = {
        .name = "xfs_da3_node",
+       .magic = { cpu_to_be16(XFS_DA_NODE_MAGIC),
+                  cpu_to_be16(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,

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index 554029c2245f05e3920ebdabc588099d53706262..d13fafa48efef27fb13e1aeea58740b8fdf58d14 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -49,18 +49,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, 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);
 }
@@ -108,6 +106,8 @@ xfs_dir3_block_write_verify(
 
 const struct xfs_buf_ops xfs_dir3_block_buf_ops = {
        .name = "xfs_dir3_block",
+       .magic = { cpu_to_be32(XFS_DIR2_BLOCK_MAGIC),
+                  cpu_to_be32(XFS_DIR3_BLOCK_MAGIC) },
        .verify_read = xfs_dir3_block_read_verify,
        .verify_write = xfs_dir3_block_write_verify,
        .verify_struct = xfs_dir3_block_verify,

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index 0a6862adfe0b1db7d1ef79ee6c98b3dca20f3016..e3d698f3bee05993f61f232b4d79e8c26029dc2d 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -249,18 +249,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, 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);
 }
@@ -336,6 +334,8 @@ xfs_dir3_data_write_verify(
 
 const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
        .name = "xfs_dir3_data",
+       .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
+                  cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
        .verify_read = xfs_dir3_data_read_verify,
        .verify_write = xfs_dir3_data_write_verify,
        .verify_struct = xfs_dir3_data_verify,
@@ -343,6 +343,8 @@ const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
 
 static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = {
        .name = "xfs_dir3_data_reada",
+       .magic = { cpu_to_be32(XFS_DIR2_DATA_MAGIC),
+                  cpu_to_be32(XFS_DIR3_DATA_MAGIC) },
        .verify_read = xfs_dir3_data_reada_verify,
        .verify_write = xfs_dir3_data_write_verify,
 };

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index a0d2dce045fd62c56c8e839270f72a54b3e2dbeb..9492bfdc83426cd99bcb1b2cdb912796502cd8ee 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -84,20 +84,18 @@ 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, 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;
                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 */
@@ -148,6 +146,8 @@ xfs_dir3_free_write_verify(
 
 const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
        .name = "xfs_dir3_free",
+       .magic = { cpu_to_be32(XFS_DIR2_FREE_MAGIC),
+                  cpu_to_be32(XFS_DIR3_FREE_MAGIC) },
        .verify_read = xfs_dir3_free_read_verify,
        .verify_write = xfs_dir3_free_write_verify,
        .verify_struct = xfs_dir3_free_verify,

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index a600c038a2a4a895d40927b1c2339891ed14dc7e..0cdf39e86c469d9ace461cf32d79b81cfbc8bbf3 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -2502,7 +2502,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, agi->agi_magicnum))
                return __this_address;
        if (!XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum)))
                return __this_address;
@@ -2576,6 +2576,7 @@ xfs_agi_write_verify(
 
 const struct xfs_buf_ops xfs_agi_buf_ops = {
        .name = "xfs_agi",
+       .magic = { cpu_to_be32(XFS_AGI_MAGIC), cpu_to_be32(XFS_AGI_MAGIC) },
        .verify_read = xfs_agi_read_verify,
        .verify_write = xfs_agi_write_verify,
        .verify_struct = xfs_agi_verify,

diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c
index 09f3045cff78df81951e1090e3d1b51fdd0ede59..65018b12a2dfc8a69d26cf3bc4176c5e28e85f02 100644 (file)
--- a/libxfs/xfs_refcount_btree.c
+++ b/libxfs/xfs_refcount_btree.c
@@ -208,7 +208,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, block->bb_magic))
                return __this_address;
 
        if (!xfs_sb_version_hasreflink(&mp->m_sb))
@@ -263,6 +263,7 @@ xfs_refcountbt_write_verify(
 
 const struct xfs_buf_ops xfs_refcountbt_buf_ops = {
        .name                   = "xfs_refcountbt",
+       .magic                  = { 0, cpu_to_be32(XFS_REFC_CRC_MAGIC) },
        .verify_read            = xfs_refcountbt_read_verify,
        .verify_write           = xfs_refcountbt_write_verify,
        .verify_struct          = xfs_refcountbt_verify,

diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
index cd81bbc22493e8d78fef3fff5eafb6ad2f706e57..59abe4136824d0f5098ad48a8fc1d1ac735efb52 100644 (file)
--- a/libxfs/xfs_rmap_btree.c
+++ b/libxfs/xfs_rmap_btree.c
@@ -308,7 +308,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, block->bb_magic))
                return __this_address;
 
        if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
@@ -363,6 +363,7 @@ xfs_rmapbt_write_verify(
 
 const struct xfs_buf_ops xfs_rmapbt_buf_ops = {
        .name                   = "xfs_rmapbt",
+       .magic                  = { 0, cpu_to_be32(XFS_RMAP_CRC_MAGIC) },
        .verify_read            = xfs_rmapbt_read_verify,
        .verify_write           = xfs_rmapbt_write_verify,
        .verify_struct          = xfs_rmapbt_verify,

diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
index 9094d7bf62780f3ab8dd063e8478ba268b8100c5..f0b141950f413ae740346d7e29fc071be303fd41 100644 (file)
--- a/libxfs/xfs_sb.c
+++ b/libxfs/xfs_sb.c
@@ -226,7 +226,7 @@ xfs_validate_sb_common(
        uint32_t                agcount = 0;
        uint32_t                rem;
 
-       if (dsb->sb_magicnum != cpu_to_be32(XFS_SB_MAGIC)) {
+       if (!xfs_verify_magic(bp, dsb->sb_magicnum)) {
                xfs_warn(mp, "bad magic number");
                return -EWRONGFS;
        }
@@ -759,12 +759,14 @@ out_error:
 
 const struct xfs_buf_ops xfs_sb_buf_ops = {
        .name = "xfs_sb",
+       .magic = { cpu_to_be32(XFS_SB_MAGIC), cpu_to_be32(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 = { cpu_to_be32(XFS_SB_MAGIC), cpu_to_be32(XFS_SB_MAGIC) },
        .verify_read = xfs_sb_quiet_read_verify,
        .verify_write = xfs_sb_write_verify,
 };

diff --git a/libxfs/xfs_symlink_remote.c b/libxfs/xfs_symlink_remote.c
index db58eb4eee1218be56f47244d010f6719c262e13..66de21a3ac10f9b971726fb005f8b3cd3e41208c 100644 (file)
--- a/libxfs/xfs_symlink_remote.c
+++ b/libxfs/xfs_symlink_remote.c
@@ -91,7 +91,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, dsl->sl_magic))
                return __this_address;
        if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid))
                return __this_address;
@@ -155,6 +155,7 @@ xfs_symlink_write_verify(
 
 const struct xfs_buf_ops xfs_symlink_buf_ops = {
        .name = "xfs_symlink",
+       .magic = { 0, cpu_to_be32(XFS_SYMLINK_MAGIC) },
        .verify_read = xfs_symlink_read_verify,
        .verify_write = xfs_symlink_write_verify,
        .verify_struct = xfs_symlink_verify,