xfs: refactor xfs_verifier_error and xfs_buf_ioerror

Source kernel commit: 31ca03c92c329525ee3a97d99c47f1ebbaed5d63

Since all verification errors also mark the buffer as having an error,
we can combine these two calls.  Later we'll add a xfs_failaddr_t
parameter to promote the idea of reporting corruption errors and the
address of the failing check to enable better debugging reports.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h
index 82ae2e9cc7d01247014de3b2fd7a56a7e73c5a3f..029740ac7bd84e54647e2800ecfecead2262cc5a 100644 (file)
--- a/libxfs/libxfs_priv.h
+++ b/libxfs/libxfs_priv.h
@@ -494,7 +494,7 @@ int  libxfs_mod_incore_sb(struct xfs_mount *, int, int64_t, int);
 #define xfs_reinit_percpu_counters(mp)
 
 void xfs_trans_mod_sb(struct xfs_trans *, uint, long);
-void xfs_verifier_error(struct xfs_buf *bp);
+void xfs_verifier_error(struct xfs_buf *bp, int error);
 
 /* XXX: this is clearly a bug - a shared header needs to export this */
 /* xfs_rtalloc.c */

diff --git a/libxfs/util.c b/libxfs/util.c
index 5f49b825a4858fab85a58e551d448579f38021a9..9653abb420662877b750049493307e3596d6d85d 100644 (file)
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -733,8 +733,11 @@ cmn_err(int level, char *fmt, ...)
  */
 void
 xfs_verifier_error(
-       struct xfs_buf          *bp)
+       struct xfs_buf          *bp,
+       int                     error)
 {
+       xfs_buf_ioerror(bp, error);
+
        xfs_alert(NULL, "Metadata %s detected at %s block 0x%llx/0x%x",
                  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
                  bp->b_ops->name, bp->b_bn, BBTOB(bp->b_length));

diff --git a/libxfs/xfs_alloc.c b/libxfs/xfs_alloc.c
index c65c93dfacbdbd57161c3a49378dba1da22f1586..5754dab13b2afcfa0de9a23d246117eb3b02c08e 100644 (file)
--- a/libxfs/xfs_alloc.c
+++ b/libxfs/xfs_alloc.c
@@ -563,12 +563,9 @@ xfs_agfl_read_verify(
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_agfl_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -583,8 +580,7 @@ xfs_agfl_write_verify(
                return;
 
        if (!xfs_agfl_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 
@@ -2457,13 +2453,10 @@ xfs_agf_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp,
                                XFS_ERRTAG_ALLOC_READ_AGF))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -2474,8 +2467,7 @@ xfs_agf_write_verify(
        struct xfs_buf_log_item *bip = bp->b_fspriv;
 
        if (!xfs_agf_verify(mp, bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 

diff --git a/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c
index 4c2fd42283dfe56f7162f61b1238f792ef0c8511..f9b0c3235d0114fad1c2070180eadee64f47ec39 100644 (file)
--- a/libxfs/xfs_alloc_btree.c
+++ b/libxfs/xfs_alloc_btree.c
@@ -362,14 +362,12 @@ xfs_allocbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_allocbt_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 
-       if (bp->b_error) {
+       if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp);
-       }
 }
 
 static void
@@ -378,8 +376,7 @@ xfs_allocbt_write_verify(
 {
        if (!xfs_allocbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 2f2456717e1ef4504ca812c95afd391ba71e39a4..19109ac05768007bafef46d186f964e7eeb54032 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -292,8 +292,7 @@ xfs_attr3_leaf_write_verify(
        struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_attr3_leaf_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 
@@ -320,12 +319,9 @@ xfs_attr3_leaf_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_attr3_leaf_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = {

diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 2f4374770ef55ef86bf20d24221e6a769343bb2e..a3821c2474823fdcf000f45e0fb8adf8a53dd263 100644 (file)
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -132,22 +132,20 @@ xfs_attr3_rmt_read_verify(
 
        while (len > 0) {
                if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {
-                       xfs_buf_ioerror(bp, -EFSBADCRC);
-                       break;
+                       xfs_verifier_error(bp, -EFSBADCRC);
+                       return;
                }
                if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
-                       break;
+                       xfs_verifier_error(bp, -EFSCORRUPTED);
+                       return;
                }
                len -= blksize;
                ptr += blksize;
                bno += BTOBB(blksize);
        }
 
-       if (bp->b_error)
-               xfs_verifier_error(bp);
-       else
-               ASSERT(len == 0);
+       if (len != 0)
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -173,8 +171,7 @@ xfs_attr3_rmt_write_verify(
                struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr;
 
                if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
-                       xfs_verifier_error(bp);
+                       xfs_verifier_error(bp, -EFSCORRUPTED);
                        return;
                }
 
@@ -183,8 +180,7 @@ xfs_attr3_rmt_write_verify(
                 * xfs_attr3_rmt_hdr_set() for the explanation.
                 */
                if (rmt->rm_lsn != cpu_to_be64(NULLCOMMITLSN)) {
-                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
-                       xfs_verifier_error(bp);
+                       xfs_verifier_error(bp, -EFSCORRUPTED);
                        return;
                }
                xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);
@@ -193,7 +189,9 @@ xfs_attr3_rmt_write_verify(
                ptr += blksize;
                bno += BTOBB(blksize);
        }
-       ASSERT(len == 0);
+
+       if (len != 0)
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 const struct xfs_buf_ops xfs_attr3_rmt_buf_ops = {

diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
index e99c7676deedf35fa84fa4a9db3c63bd28492cca..763935445e4e140a2552b49ddb13a3a3ad534268 100644 (file)
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -464,14 +464,12 @@ xfs_bmbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_lblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_bmbt_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 
-       if (bp->b_error) {
+       if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp);
-       }
 }
 
 static void
@@ -480,8 +478,7 @@ xfs_bmbt_write_verify(
 {
        if (!xfs_bmbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
        xfs_btree_lblock_calc_crc(bp);

diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
index b2457fdc58d099605e9d442c075964385766cfbf..8a4e4cd095304251a87df105b84429bfda7b4121 100644 (file)
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -181,8 +181,7 @@ xfs_da3_node_write_verify(
        struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_da3_node_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 
@@ -210,15 +209,13 @@ xfs_da3_node_read_verify(
        switch (be16_to_cpu(info->magic)) {
                case XFS_DA3_NODE_MAGIC:
                        if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) {
-                               xfs_buf_ioerror(bp, -EFSBADCRC);
+                               xfs_verifier_error(bp, -EFSBADCRC);
                                break;
                        }
                        /* fall through */
                case XFS_DA_NODE_MAGIC:
-                       if (!xfs_da3_node_verify(bp)) {
-                               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-                               break;
-                       }
+                       if (!xfs_da3_node_verify(bp))
+                               xfs_verifier_error(bp, -EFSCORRUPTED);
                        return;
                case XFS_ATTR_LEAF_MAGIC:
                case XFS_ATTR3_LEAF_MAGIC:
@@ -231,12 +228,9 @@ xfs_da3_node_read_verify(
                        bp->b_ops->verify_read(bp);
                        return;
                default:
-                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
+                       xfs_verifier_error(bp, -EFSCORRUPTED);
                        break;
        }
-
-       /* corrupt block */
-       xfs_verifier_error(bp);
 }
 
 const struct xfs_buf_ops xfs_da3_node_buf_ops = {

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index a2b17eb2b363d754c148012dd2927957d380231c..1450c7644bb0b4b50d12b4cdccf4e3bb803ed88b 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -85,12 +85,9 @@ xfs_dir3_block_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_dir3_block_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -102,8 +99,7 @@ xfs_dir3_block_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_block_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index d4a6d6647c57aa5e9bb570d08d0b618a4494a687..541ec1c07e9398a2a3a27e5f29b940e43fa85309 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -264,8 +264,7 @@ xfs_dir3_data_reada_verify(
                bp->b_ops->verify_read(bp);
                return;
        default:
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                break;
        }
 }
@@ -277,13 +276,10 @@ xfs_dir3_data_read_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
-            !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-                xfs_buf_ioerror(bp, -EFSBADCRC);
+           !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_dir3_data_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -295,8 +291,7 @@ xfs_dir3_data_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_data_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
index 5e9cf90105a0b92242777a458564b34695dbff54..1c97db4547bf70f3f5f9a0621d391996f5de693c 100644 (file)
--- a/libxfs/xfs_dir2_leaf.c
+++ b/libxfs/xfs_dir2_leaf.c
@@ -181,12 +181,9 @@ __read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_dir3_leaf_verify(bp, magic))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -199,8 +196,7 @@ __write_verify(
        struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_leaf_verify(bp, magic)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index d8539cc1ef977ee649906d0b2d4a7d9c57c6c1f2..e65baf156c26b0d110c817b45a6b81357de5bcba 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -115,12 +115,9 @@ xfs_dir3_free_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_dir3_free_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -132,8 +129,7 @@ xfs_dir3_free_write_verify(
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
        if (!xfs_dir3_free_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 
@@ -206,8 +202,7 @@ __xfs_dir3_free_read(
 
        /* Check things that we can't do in the verifier. */
        if (!xfs_dir3_free_header_check(dp, fbno, *bpp)) {
-               xfs_buf_ioerror(*bpp, -EFSCORRUPTED);
-               xfs_verifier_error(*bpp);
+               xfs_verifier_error(*bpp, -EFSCORRUPTED);
                xfs_trans_brelse(tp, *bpp);
                return -EFSCORRUPTED;
        }

diff --git a/libxfs/xfs_dquot_buf.c b/libxfs/xfs_dquot_buf.c
index a19a20a16cb23aabe46ada8867f64394539c78d4..3b69788abd0136030db0a75fd6c0a65e8a2823bb 100644 (file)
--- a/libxfs/xfs_dquot_buf.c
+++ b/libxfs/xfs_dquot_buf.c
@@ -247,12 +247,9 @@ xfs_dquot_buf_read_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
 
        if (!xfs_dquot_buf_verify_crc(mp, bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 /*
@@ -286,8 +283,7 @@ xfs_dquot_buf_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
 
        if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 }

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index 7913c446b44d97a46edde36a4f6205118715e2b6..ef76e3d90e9fc3421de94c3455a8b6a266fab034 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -2538,13 +2538,10 @@ xfs_agi_read_verify(
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp,
                                XFS_ERRTAG_IALLOC_READ_AGI))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -2555,8 +2552,7 @@ xfs_agi_write_verify(
        struct xfs_buf_log_item *bip = bp->b_fspriv;
 
        if (!xfs_agi_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
 

diff --git a/libxfs/xfs_ialloc_btree.c b/libxfs/xfs_ialloc_btree.c
index 5faf59ecf60fcd5227a4d43797fc59d5f43a506b..3c06f40145505e3e51c1d8f3d6e00b94b6e79aad 100644 (file)
--- a/libxfs/xfs_ialloc_btree.c
+++ b/libxfs/xfs_ialloc_btree.c
@@ -293,14 +293,12 @@ xfs_inobt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_inobt_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 
-       if (bp->b_error) {
+       if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp);
-       }
 }
 
 static void
@@ -309,8 +307,7 @@ xfs_inobt_write_verify(
 {
        if (!xfs_inobt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
index a3a5239b6ce5d08a104b1037fb6c83bd2c46f249..10b10f3710afc7bedba4ff4f24b2c9556bd17323 100644 (file)
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -111,8 +111,7 @@ xfs_inode_buf_verify(
                                return;
                        }
 
-                       xfs_buf_ioerror(bp, -EFSCORRUPTED);
-                       xfs_verifier_error(bp);
+                       xfs_verifier_error(bp, -EFSCORRUPTED);
 #ifdef DEBUG
                        xfs_alert(mp,
                                "bad inode magic/vsn daddr %lld #%d (magic=%x)",

diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c
index 09326dbb06a86e25de32cf2262baa39f0bc1dca6..2c0c8d4f53e441c8c4267a01e65a24ed61db0666 100644 (file)
--- a/libxfs/xfs_refcount_btree.c
+++ b/libxfs/xfs_refcount_btree.c
@@ -254,14 +254,12 @@ xfs_refcountbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_refcountbt_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 
-       if (bp->b_error) {
+       if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp);
-       }
 }
 
 STATIC void
@@ -270,8 +268,7 @@ xfs_refcountbt_write_verify(
 {
        if (!xfs_refcountbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
index 5595cf4d28fd2bbe5390976db9f1008a08a7b5b8..9a28d2baeefce93dcaa5e3ac3522cf2900502d75 100644 (file)
--- a/libxfs/xfs_rmap_btree.c
+++ b/libxfs/xfs_rmap_btree.c
@@ -345,14 +345,12 @@ xfs_rmapbt_read_verify(
        struct xfs_buf  *bp)
 {
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_rmapbt_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 
-       if (bp->b_error) {
+       if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp);
-       }
 }
 
 static void
@@ -361,8 +359,7 @@ xfs_rmapbt_write_verify(
 {
        if (!xfs_rmapbt_verify(bp)) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
index 51f69704a0aad2c30a29cf0a28e38fa092491b3e..ce828c2a5bcd2f552060da6ae10fb5af20319e5e 100644 (file)
--- a/libxfs/xfs_sb.c
+++ b/libxfs/xfs_sb.c
@@ -622,11 +622,10 @@ xfs_sb_read_verify(
        error = xfs_sb_verify(bp, true);
 
 out_error:
-       if (error) {
+       if (error == -EFSCORRUPTED || error == -EFSBADCRC)
+               xfs_verifier_error(bp, error);
+       else if (error)
                xfs_buf_ioerror(bp, error);
-               if (error == -EFSCORRUPTED || error == -EFSBADCRC)
-                       xfs_verifier_error(bp);
-       }
 }
 
 /*
@@ -660,8 +659,7 @@ xfs_sb_write_verify(
 
        error = xfs_sb_verify(bp, false);
        if (error) {
-               xfs_buf_ioerror(bp, error);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, error);
                return;
        }
 

diff --git a/libxfs/xfs_symlink_remote.c b/libxfs/xfs_symlink_remote.c
index d638530beb59f63452b59dc0ffe94e8695895b64..3b4c6abba9f54653c122f9d6d4e380e3a451b788 100644 (file)
--- a/libxfs/xfs_symlink_remote.c
+++ b/libxfs/xfs_symlink_remote.c
@@ -131,12 +131,9 @@ xfs_symlink_read_verify(
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (!xfs_symlink_verify(bp))
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
 }
 
 static void
@@ -151,8 +148,7 @@ xfs_symlink_write_verify(
                return;
 
        if (!xfs_symlink_verify(bp)) {
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
                return;
        }