xfs: refactor verifier callers to print address of failing check

Source kernel commit: bc1a09b8e334bf5fca1d6727aec538dcff957961

Refactor the callers of verifiers to print the instruction address of a
failing check.

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 029740ac7bd84e54647e2800ecfecead2262cc5a..eef344bb51648a27850c283730af6eeb63974c23 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, int error);
+void xfs_verifier_error(struct xfs_buf *bp, int error, xfs_failaddr_t failaddr);
 
 /* 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 9653abb420662877b750049493307e3596d6d85d..f6ce3949d80339ce39dc566a8b5f43f7a5cc7cae 100644 (file)
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -734,12 +734,14 @@ cmn_err(int level, char *fmt, ...)
 void
 xfs_verifier_error(
        struct xfs_buf          *bp,
-       int                     error)
+       int                     error,
+       xfs_failaddr_t          failaddr)
 {
        xfs_buf_ioerror(bp, error);
 
-       xfs_alert(NULL, "Metadata %s detected at %s block 0x%llx/0x%x",
+       xfs_alert(NULL, "Metadata %s detected at %p, %s block 0x%llx/0x%x",
                  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
+                 failaddr ? failaddr : __return_address,
                  bp->b_ops->name, bp->b_bn, BBTOB(bp->b_length));
 }
 

diff --git a/libxfs/xfs_alloc.c b/libxfs/xfs_alloc.c
index 88377dfe7d0ee8168f4f485b8c97b17935e0002b..1e2470793afa62699370f1bac9f82869d235b728 100644 (file)
--- a/libxfs/xfs_alloc.c
+++ b/libxfs/xfs_alloc.c
@@ -553,6 +553,7 @@ xfs_agfl_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t  fa;
 
        /*
         * There is no verification of non-crc AGFLs because mkfs does not
@@ -564,9 +565,12 @@ xfs_agfl_read_verify(
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_agfl_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_agfl_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -575,13 +579,15 @@ xfs_agfl_write_verify(
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
+       xfs_failaddr_t          fa;
 
        /* no verification of non-crc AGFLs */
        if (!xfs_sb_version_hascrc(&mp->m_sb))
                return;
 
-       if (xfs_agfl_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_agfl_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 
@@ -2451,13 +2457,16 @@ xfs_agf_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t  fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (XFS_TEST_ERROR(xfs_agf_verify(mp, bp), mp,
-                               XFS_ERRTAG_ALLOC_READ_AGF))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_agf_verify(mp, bp);
+               if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_ALLOC_READ_AGF))
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -2466,9 +2475,11 @@ xfs_agf_write_verify(
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
+       xfs_failaddr_t          fa;
 
-       if (xfs_agf_verify(mp, bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_agf_verify(mp, bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 

diff --git a/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c
index e3763e84acab5ff86b72705e7b4eedaebfce90b1..e3a3d4aa1b472666d1c64c60ddc546ea49c94560 100644 (file)
--- a/libxfs/xfs_alloc_btree.c
+++ b/libxfs/xfs_alloc_btree.c
@@ -364,10 +364,15 @@ static void
 xfs_allocbt_read_verify(
        struct xfs_buf  *bp)
 {
+       xfs_failaddr_t  fa;
+
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_allocbt_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_allocbt_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 
        if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -377,9 +382,12 @@ static void
 xfs_allocbt_write_verify(
        struct xfs_buf  *bp)
 {
-       if (xfs_allocbt_verify(bp)) {
+       xfs_failaddr_t  fa;
+
+       fa = xfs_allocbt_verify(bp);
+       if (fa) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 23718bc3fa6c22416f4f5843de157c86969aec18..ead3e71cc9b5062005550bdca32927594fc70432 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -290,9 +290,11 @@ xfs_attr3_leaf_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_attr3_leaf_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_attr3_leaf_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 
@@ -316,12 +318,16 @@ xfs_attr3_leaf_read_verify(
        struct xfs_buf          *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t          fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_attr3_leaf_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_attr3_leaf_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 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 0c4f728b03149d2dca2818b433fb03d864d85287..cff9d79545e30b75df4b7c0b6feb5fb4d82122ea 100644 (file)
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -117,6 +117,7 @@ xfs_attr3_rmt_read_verify(
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
        char            *ptr;
+       xfs_failaddr_t  fa;
        int             len;
        xfs_daddr_t     bno;
        int             blksize = mp->m_attr_geo->blksize;
@@ -132,12 +133,13 @@ xfs_attr3_rmt_read_verify(
 
        while (len > 0) {
                if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {
-                       xfs_verifier_error(bp, -EFSBADCRC);
+                       xfs_verifier_error(bp, -EFSBADCRC, __this_address);
                        return;
                }
-               if (xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_verifier_error(bp, -EFSCORRUPTED);
-                       return;
+               fa = xfs_attr3_rmt_verify(mp, ptr, blksize, bno);
+               if (fa) {
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+                       break;
                }
                len -= blksize;
                ptr += blksize;
@@ -145,7 +147,7 @@ xfs_attr3_rmt_read_verify(
        }
 
        if (len != 0)
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 }
 
 static void
@@ -153,6 +155,7 @@ xfs_attr3_rmt_write_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t  fa;
        int             blksize = mp->m_attr_geo->blksize;
        char            *ptr;
        int             len;
@@ -170,8 +173,9 @@ xfs_attr3_rmt_write_verify(
        while (len > 0) {
                struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr;
 
-               if (xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                       xfs_verifier_error(bp, -EFSCORRUPTED);
+               fa = xfs_attr3_rmt_verify(mp, ptr, blksize, bno);
+               if (fa) {
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                        return;
                }
 
@@ -180,7 +184,7 @@ xfs_attr3_rmt_write_verify(
                 * xfs_attr3_rmt_hdr_set() for the explanation.
                 */
                if (rmt->rm_lsn != cpu_to_be64(NULLCOMMITLSN)) {
-                       xfs_verifier_error(bp, -EFSCORRUPTED);
+                       xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
                        return;
                }
                xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);
@@ -191,7 +195,7 @@ xfs_attr3_rmt_write_verify(
        }
 
        if (len != 0)
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 }
 
 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 9b4724e466a6f582168d5bc328daf0f67c0fbbcc..2c1b0bd582f9b6b8f2535766ac3662f87637bda1 100644 (file)
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -465,10 +465,15 @@ static void
 xfs_bmbt_read_verify(
        struct xfs_buf  *bp)
 {
+       xfs_failaddr_t  fa;
+
        if (!xfs_btree_lblock_verify_crc(bp))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_bmbt_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_bmbt_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 
        if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -478,9 +483,12 @@ static void
 xfs_bmbt_write_verify(
        struct xfs_buf  *bp)
 {
-       if (xfs_bmbt_verify(bp)) {
+       xfs_failaddr_t  fa;
+
+       fa = xfs_bmbt_verify(bp);
+       if (fa) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
        xfs_btree_lblock_calc_crc(bp);

diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
index de11049f98f5f9c4c363c224f21fb5b37bc45b29..2027b0f74bf0068789bd3e7e883a6285a093f2d3 100644 (file)
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -179,9 +179,11 @@ xfs_da3_node_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_da3_node_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_da3_node_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 
@@ -205,17 +207,20 @@ xfs_da3_node_read_verify(
        struct xfs_buf          *bp)
 {
        struct xfs_da_blkinfo   *info = bp->b_addr;
+       xfs_failaddr_t          fa;
 
        switch (be16_to_cpu(info->magic)) {
                case XFS_DA3_NODE_MAGIC:
                        if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) {
-                               xfs_verifier_error(bp, -EFSBADCRC);
+                               xfs_verifier_error(bp, -EFSBADCRC,
+                                               __this_address);
                                break;
                        }
                        /* fall through */
                case XFS_DA_NODE_MAGIC:
-                       if (xfs_da3_node_verify(bp))
-                               xfs_verifier_error(bp, -EFSCORRUPTED);
+                       fa = xfs_da3_node_verify(bp);
+                       if (fa)
+                               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                        return;
                case XFS_ATTR_LEAF_MAGIC:
                case XFS_ATTR3_LEAF_MAGIC:
@@ -228,7 +233,7 @@ xfs_da3_node_read_verify(
                        bp->b_ops->verify_read(bp);
                        return;
                default:
-                       xfs_verifier_error(bp, -EFSCORRUPTED);
+                       xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
                        break;
        }
 }

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index 6f6eec302a43b097f4c299210abdbeced5cc204b..765fba143ddad18b6089bf7e8acb8bfa7993911c 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -82,12 +82,16 @@ xfs_dir3_block_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t          fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_dir3_block_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_dir3_block_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -97,9 +101,11 @@ xfs_dir3_block_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_dir3_block_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_dir3_block_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index 3e6d068387ff6701845a68a7a31c83f9f8aaa235..6099cff304a71a2d749d713dd122184e45cd15b9 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -281,7 +281,7 @@ xfs_dir3_data_reada_verify(
                bp->b_ops->verify_read(bp);
                return;
        default:
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
                break;
        }
 }
@@ -291,12 +291,16 @@ xfs_dir3_data_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t          fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_dir3_data_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_dir3_data_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -306,9 +310,11 @@ xfs_dir3_data_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_dir3_data_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_dir3_data_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
index 038d0c425f54ca2a7dd049c95db94fe27632b78f..4c76f844830a4bd8e3052aa94e927310bfb48970 100644 (file)
--- a/libxfs/xfs_dir2_leaf.c
+++ b/libxfs/xfs_dir2_leaf.c
@@ -187,12 +187,16 @@ __read_verify(
        uint16_t        magic)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t          fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_dir3_leaf_verify(bp, magic))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_dir3_leaf_verify(bp, magic);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -203,9 +207,11 @@ __write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_dir3_leaf_verify(bp, magic)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_dir3_leaf_verify(bp, magic);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index 954bba3798afe4e1e8d5624fb29e9acf301cf030..c5ef0b54a3a39b32205f12519a331926736e0fb1 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -121,12 +121,16 @@ xfs_dir3_free_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount        *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t          fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_dir3_free_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_dir3_free_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -136,9 +140,11 @@ xfs_dir3_free_write_verify(
        struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
        struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
+       xfs_failaddr_t          fa;
 
-       if (xfs_dir3_free_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_dir3_free_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 
@@ -158,7 +164,7 @@ const struct xfs_buf_ops xfs_dir3_free_buf_ops = {
 };
 
 /* Everything ok in the free block header? */
-static bool
+static xfs_failaddr_t
 xfs_dir3_free_header_check(
        struct xfs_inode        *dp,
        xfs_dablk_t             fbno,
@@ -202,6 +208,7 @@ __xfs_dir3_free_read(
        xfs_daddr_t             mappedbno,
        struct xfs_buf          **bpp)
 {
+       xfs_failaddr_t          fa;
        int                     err;
 
        err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
@@ -210,8 +217,9 @@ __xfs_dir3_free_read(
                return err;
 
        /* Check things that we can't do in the verifier. */
-       if (xfs_dir3_free_header_check(dp, fbno, *bpp)) {
-               xfs_verifier_error(*bpp, -EFSCORRUPTED);
+       fa = xfs_dir3_free_header_check(dp, fbno, *bpp);
+       if (fa) {
+               xfs_verifier_error(*bpp, -EFSCORRUPTED, fa);
                xfs_trans_brelse(tp, *bpp);
                return -EFSCORRUPTED;
        }

diff --git a/libxfs/xfs_dquot_buf.c b/libxfs/xfs_dquot_buf.c
index 3b69788abd0136030db0a75fd6c0a65e8a2823bb..2dcf5c018d5321320c03b85be1823819f1cfd17a 100644 (file)
--- a/libxfs/xfs_dquot_buf.c
+++ b/libxfs/xfs_dquot_buf.c
@@ -247,9 +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_verifier_error(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
        else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 }
 
 /*
@@ -283,7 +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_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
                return;
        }
 }

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index e092a6015ad6e8b0bdace9b72d179b47bb825421..6d66440f7a06b19c6e6a060dc3bee6b5c5689945 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -2535,13 +2535,16 @@ xfs_agi_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t  fa;
 
        if (xfs_sb_version_hascrc(&mp->m_sb) &&
            !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (XFS_TEST_ERROR(xfs_agi_verify(bp), mp,
-                               XFS_ERRTAG_IALLOC_READ_AGI))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_agi_verify(bp);
+               if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_IALLOC_READ_AGI))
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -2550,9 +2553,11 @@ xfs_agi_write_verify(
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
+       xfs_failaddr_t          fa;
 
-       if (xfs_agi_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_agi_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
 

diff --git a/libxfs/xfs_ialloc_btree.c b/libxfs/xfs_ialloc_btree.c
index f5044523d83477571fc67979f2645c00b2fe7c89..ea8ca12d80a9d3795b723dbc138155240229c15c 100644 (file)
--- a/libxfs/xfs_ialloc_btree.c
+++ b/libxfs/xfs_ialloc_btree.c
@@ -294,10 +294,15 @@ static void
 xfs_inobt_read_verify(
        struct xfs_buf  *bp)
 {
+       xfs_failaddr_t  fa;
+
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_inobt_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_inobt_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 
        if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -307,9 +312,12 @@ static void
 xfs_inobt_write_verify(
        struct xfs_buf  *bp)
 {
-       if (xfs_inobt_verify(bp)) {
+       xfs_failaddr_t  fa;
+
+       fa = xfs_inobt_verify(bp);
+       if (fa) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
index 3cdabd5897edcd7a502fb65d45ef5ce1d40d114a..e82e56d922e906f5597ed1bf67892c026ef186a8 100644 (file)
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -111,7 +111,7 @@ xfs_inode_buf_verify(
                                return;
                        }
 
-                       xfs_verifier_error(bp, -EFSCORRUPTED);
+                       xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 #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 4f6f7bba7ead447de394a5818dee46788a6fc5e2..dd3b4d6a2bba5479b46da079741b2c046d357433 100644 (file)
--- a/libxfs/xfs_refcount_btree.c
+++ b/libxfs/xfs_refcount_btree.c
@@ -255,10 +255,15 @@ STATIC void
 xfs_refcountbt_read_verify(
        struct xfs_buf  *bp)
 {
+       xfs_failaddr_t  fa;
+
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_refcountbt_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_refcountbt_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 
        if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -268,9 +273,12 @@ STATIC void
 xfs_refcountbt_write_verify(
        struct xfs_buf  *bp)
 {
-       if (xfs_refcountbt_verify(bp)) {
+       xfs_failaddr_t  fa;
+
+       fa = xfs_refcountbt_verify(bp);
+       if (fa) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
index 0ba0b441833556ad4aba72563a5a9eebee8c89a1..1a2d9084306ac44483a8c295a7c688cd2371c4d1 100644 (file)
--- a/libxfs/xfs_rmap_btree.c
+++ b/libxfs/xfs_rmap_btree.c
@@ -346,10 +346,15 @@ static void
 xfs_rmapbt_read_verify(
        struct xfs_buf  *bp)
 {
+       xfs_failaddr_t  fa;
+
        if (!xfs_btree_sblock_verify_crc(bp))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_rmapbt_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_rmapbt_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 
        if (bp->b_error)
                trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -359,9 +364,12 @@ static void
 xfs_rmapbt_write_verify(
        struct xfs_buf  *bp)
 {
-       if (xfs_rmapbt_verify(bp)) {
+       xfs_failaddr_t  fa;
+
+       fa = xfs_rmapbt_verify(bp);
+       if (fa) {
                trace_xfs_btree_corrupt(bp, _RET_IP_);
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }
        xfs_btree_sblock_calc_crc(bp);

diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
index ce828c2a5bcd2f552060da6ae10fb5af20319e5e..a339a84bdb2c8f2649d0388ffa9c3d75cb76a121 100644 (file)
--- a/libxfs/xfs_sb.c
+++ b/libxfs/xfs_sb.c
@@ -623,7 +623,7 @@ xfs_sb_read_verify(
 
 out_error:
        if (error == -EFSCORRUPTED || error == -EFSBADCRC)
-               xfs_verifier_error(bp, error);
+               xfs_verifier_error(bp, error, __this_address);
        else if (error)
                xfs_buf_ioerror(bp, error);
 }
@@ -659,7 +659,7 @@ xfs_sb_write_verify(
 
        error = xfs_sb_verify(bp, false);
        if (error) {
-               xfs_verifier_error(bp, error);
+               xfs_verifier_error(bp, error, __this_address);
                return;
        }
 

diff --git a/libxfs/xfs_symlink_remote.c b/libxfs/xfs_symlink_remote.c
index 67c1e3467ec724a837f91a3d48140ceb1e4e64db..ff61d32941e07cde4e8a641f510619ace79784d3 100644 (file)
--- a/libxfs/xfs_symlink_remote.c
+++ b/libxfs/xfs_symlink_remote.c
@@ -125,15 +125,19 @@ xfs_symlink_read_verify(
        struct xfs_buf  *bp)
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
+       xfs_failaddr_t  fa;
 
        /* no verification of non-crc buffers */
        if (!xfs_sb_version_hascrc(&mp->m_sb))
                return;
 
        if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
-               xfs_verifier_error(bp, -EFSBADCRC);
-       else if (xfs_symlink_verify(bp))
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSBADCRC, __this_address);
+       else {
+               fa = xfs_symlink_verify(bp);
+               if (fa)
+                       xfs_verifier_error(bp, -EFSCORRUPTED, fa);
+       }
 }
 
 static void
@@ -142,13 +146,15 @@ xfs_symlink_write_verify(
 {
        struct xfs_mount *mp = bp->b_target->bt_mount;
        struct xfs_buf_log_item *bip = bp->b_fspriv;
+       xfs_failaddr_t          fa;
 
        /* no verification of non-crc buffers */
        if (!xfs_sb_version_hascrc(&mp->m_sb))
                return;
 
-       if (xfs_symlink_verify(bp)) {
-               xfs_verifier_error(bp, -EFSCORRUPTED);
+       fa = xfs_symlink_verify(bp);
+       if (fa) {
+               xfs_verifier_error(bp, -EFSCORRUPTED, fa);
                return;
        }