xfs: convert open coded corruption check to use XFS_IS_CORRUPT

Convert the last of the open coded corruption check and report idioms to
use the XFS_IS_CORRUPT macro.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index fcee5e8..c284e10 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -1071,8 +1071,7 @@ xfs_alloc_ag_vextent_small(
                struct xfs_buf  *bp;
 
                bp = xfs_btree_get_bufs(args->mp, args->tp, args->agno, fbno);
-               if (!bp) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, args->mp);
+               if (XFS_IS_CORRUPT(args->mp, !bp)) {
                        error = -EFSCORRUPTED;
                        goto error;
                }
@@ -2341,10 +2340,8 @@ xfs_free_agfl_block(
                return error;
 
        bp = xfs_btree_get_bufs(tp->t_mountp, tp, agno, agbno);
-       if (!bp) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, tp->t_mountp);
+       if (XFS_IS_CORRUPT(tp->t_mountp, !bp))
                return -EFSCORRUPTED;
-       }
        xfs_trans_binval(tp, bp);
 
        return 0;

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 97b6a1f..4acc6e3 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -731,8 +731,7 @@ xfs_bmap_extents_to_btree(
        ip->i_d.di_nblocks++;
        xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
        abp = xfs_btree_get_bufl(mp, tp, args.fsbno);
-       if (!abp) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !abp)) {
                error = -EFSCORRUPTED;
                goto out_unreserve_dquot;
        }
@@ -1090,8 +1089,7 @@ xfs_bmap_add_attrfork(
                goto trans_cancel;
        if (XFS_IFORK_Q(ip))
                goto trans_cancel;
-       if (ip->i_d.di_anextents != 0) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, ip->i_d.di_anextents != 0)) {
                error = -EFSCORRUPTED;
                goto trans_cancel;
        }
@@ -1238,8 +1236,9 @@ xfs_iread_extents(
 
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 
-       if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp,
+                          XFS_IFORK_FORMAT(ip, whichfork) !=
+                          XFS_DINODE_FMT_BTREE)) {
                error = -EFSCORRUPTED;
                goto out;
        }
@@ -1253,8 +1252,8 @@ xfs_iread_extents(
        if (error)
                goto out;
 
-       if (ir.loaded != XFS_IFORK_NEXTENTS(ip, whichfork)) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp,
+                          ir.loaded != XFS_IFORK_NEXTENTS(ip, whichfork))) {
                error = -EFSCORRUPTED;
                goto out;
        }
@@ -1444,10 +1443,8 @@ xfs_bmap_last_offset(
        if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL)
                return 0;
 
-       if (!xfs_ifork_has_extents(ip, whichfork)) {
-               ASSERT(0);
+       if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ip, whichfork)))
                return -EFSCORRUPTED;
-       }
 
        error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
        if (error || is_empty)
@@ -3906,10 +3903,8 @@ xfs_bmapi_read(
                           XFS_BMAPI_COWFORK)));
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL));
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 
@@ -4417,10 +4412,8 @@ xfs_bmapi_write(
        ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
                        (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 
@@ -4686,10 +4679,8 @@ xfs_bmapi_remap(
        ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
                        (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 
@@ -5311,7 +5302,7 @@ __xfs_bunmapi(
        int                     isrt;           /* freeing in rt area */
        int                     logflags;       /* transaction logging flags */
        xfs_extlen_t            mod;            /* rt extent offset */
-       struct xfs_mount        *mp;            /* mount structure */
+       struct xfs_mount        *mp = ip->i_mount;
        int                     tmp_logflags;   /* partial logging flags */
        int                     wasdel;         /* was a delayed alloc extent */
        int                     whichfork;      /* data or attribute fork */
@@ -5328,12 +5319,8 @@ __xfs_bunmapi(
        whichfork = xfs_bmapi_whichfork(flags);
        ASSERT(whichfork != XFS_COW_FORK);
        ifp = XFS_IFORK_PTR(ip, whichfork);
-       if (unlikely(!xfs_ifork_has_extents(ip, whichfork))) {
-               XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW,
-                                ip->i_mount);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)))
                return -EFSCORRUPTED;
-       }
-       mp = ip->i_mount;
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
 
@@ -5826,10 +5813,8 @@ xfs_bmap_collapse_extents(
        int                     error = 0;
        int                     logflags = 0;
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 
@@ -5945,10 +5930,8 @@ xfs_bmap_insert_extents(
        int                     error = 0;
        int                     logflags = 0;
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 
@@ -5986,8 +5969,8 @@ xfs_bmap_insert_extents(
                goto del_cursor;
        }
 
-       if (stop_fsb >= got.br_startoff + got.br_blockcount) {
-               ASSERT(0);
+       if (XFS_IS_CORRUPT(mp,
+                          stop_fsb >= got.br_startoff + got.br_blockcount)) {
                error = -EFSCORRUPTED;
                goto del_cursor;
        }
@@ -6053,11 +6036,8 @@ xfs_bmap_split_extent_at(
        int                             logflags = 0;
        int                             i = 0;
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, whichfork),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT("xfs_bmap_split_extent_at",
-                                XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
 

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index 897dfb9..8f0e3a3 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -105,11 +105,10 @@ xfs_btree_check_lblock(
        xfs_failaddr_t          fa;
 
        fa = __xfs_btree_check_lblock(cur, block, level, bp);
-       if (unlikely(XFS_TEST_ERROR(fa != NULL, mp,
-                       XFS_ERRTAG_BTREE_CHECK_LBLOCK))) {
+       if (XFS_IS_CORRUPT(mp, fa != NULL) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK)) {
                if (bp)
                        trace_xfs_btree_corrupt(bp, _RET_IP_);
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
                return -EFSCORRUPTED;
        }
        return 0;
@@ -169,11 +168,10 @@ xfs_btree_check_sblock(
        xfs_failaddr_t          fa;
 
        fa = __xfs_btree_check_sblock(cur, block, level, bp);
-       if (unlikely(XFS_TEST_ERROR(fa != NULL, mp,
-                       XFS_ERRTAG_BTREE_CHECK_SBLOCK))) {
+       if (XFS_IS_CORRUPT(mp, fa != NULL) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_SBLOCK)) {
                if (bp)
                        trace_xfs_btree_corrupt(bp, _RET_IP_);
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
                return -EFSCORRUPTED;
        }
        return 0;
@@ -1849,10 +1847,8 @@ xfs_btree_lookup(
        XFS_BTREE_STATS_INC(cur, lookup);
 
        /* No such thing as a zero-level tree. */
-       if (cur->bc_nlevels == 0) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, cur->bc_mp);
+       if (XFS_IS_CORRUPT(cur->bc_mp, cur->bc_nlevels == 0))
                return -EFSCORRUPTED;
-       }
 
        block = NULL;
        keyno = 0;

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 46b1c3f..4181894 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -1663,17 +1663,12 @@ xfs_da3_node_lookup_int(
                }
 
                /* We can't point back to the root. */
-               if (blkno == args->geo->leafblk) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                       dp->i_mount);
+               if (XFS_IS_CORRUPT(dp->i_mount, blkno == args->geo->leafblk))
                        return -EFSCORRUPTED;
-               }
        }
 
-       if (expected_level != 0) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, dp->i_mount);
+       if (XFS_IS_CORRUPT(dp->i_mount, expected_level != 0))
                return -EFSCORRUPTED;
-       }
 
        /*
         * A leaf block that ends in the hashval that we are interested in
@@ -2267,11 +2262,8 @@ xfs_da3_swap_lastblock(
        error = xfs_bmap_last_before(tp, dp, &lastoff, w);
        if (error)
                return error;
-       if (unlikely(lastoff == 0)) {
-               XFS_ERROR_REPORT("xfs_da_swap_lastblock(1)", XFS_ERRLEVEL_LOW,
-                                mp);
+       if (XFS_IS_CORRUPT(mp, lastoff == 0))
                return -EFSCORRUPTED;
-       }
        /*
         * Read the last block in the btree space.
         */
@@ -2317,11 +2309,9 @@ xfs_da3_swap_lastblock(
                if (error)
                        goto done;
                sib_info = sib_buf->b_addr;
-               if (unlikely(
-                   be32_to_cpu(sib_info->forw) != last_blkno ||
-                   sib_info->magic != dead_info->magic)) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(2)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp,
+                                  be32_to_cpu(sib_info->forw) != last_blkno ||
+                                  sib_info->magic != dead_info->magic)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2339,11 +2329,9 @@ xfs_da3_swap_lastblock(
                if (error)
                        goto done;
                sib_info = sib_buf->b_addr;
-               if (unlikely(
-                      be32_to_cpu(sib_info->back) != last_blkno ||
-                      sib_info->magic != dead_info->magic)) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(3)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp,
+                                  be32_to_cpu(sib_info->back) != last_blkno ||
+                                  sib_info->magic != dead_info->magic)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2364,9 +2352,8 @@ xfs_da3_swap_lastblock(
                        goto done;
                par_node = par_buf->b_addr;
                xfs_da3_node_hdr_from_disk(dp->i_mount, &par_hdr, par_node);
-               if (level >= 0 && level != par_hdr.level + 1) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp,
+                                  level >= 0 && level != par_hdr.level + 1)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2377,9 +2364,7 @@ xfs_da3_swap_lastblock(
                     be32_to_cpu(btree[entno].hashval) < dead_hash;
                     entno++)
                        continue;
-               if (entno == par_hdr.count) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp, entno == par_hdr.count)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2404,9 +2389,7 @@ xfs_da3_swap_lastblock(
                par_blkno = par_hdr.forw;
                xfs_trans_brelse(tp, par_buf);
                par_buf = NULL;
-               if (unlikely(par_blkno == 0)) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp, par_blkno == 0)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2415,9 +2398,7 @@ xfs_da3_swap_lastblock(
                        goto done;
                par_node = par_buf->b_addr;
                xfs_da3_node_hdr_from_disk(dp->i_mount, &par_hdr, par_node);
-               if (par_hdr.level != level) {
-                       XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
-                                        XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp, par_hdr.level != level)) {
                        error = -EFSCORRUPTED;
                        goto done;
                }
@@ -2611,7 +2592,7 @@ xfs_dabuf_map(
 
        if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
                /* Caller ok with no mapping. */
-               if (mappedbno == -2) {
+               if (!XFS_IS_CORRUPT(mp, mappedbno != -2)) {
                        error = -1;
                        goto out;
                }
@@ -2632,7 +2613,6 @@ xfs_dabuf_map(
                                        irecs[i].br_state);
                        }
                }
-               XFS_ERROR_REPORT("xfs_da_do_buf(1)", XFS_ERRLEVEL_LOW, mp);
                error = -EFSCORRUPTED;
                goto out;
        }

diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 624c05e..83cc877 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -208,10 +208,10 @@ xfs_dir_ino_validate(
 {
        bool            ino_ok = xfs_verify_dir_ino(mp, ino);
 
-       if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE))) {
+       if (XFS_IS_CORRUPT(mp, !ino_ok) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) {
                xfs_warn(mp, "Invalid inode number 0x%Lx",
                                (unsigned long long) ino);
-               XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
                return -EFSCORRUPTED;
        }
        return 0;
@@ -617,10 +617,10 @@ xfs_dir2_isblock(
        if ((rval = xfs_bmap_last_offset(args->dp, &last, XFS_DATA_FORK)))
                return rval;
        rval = XFS_FSB_TO_B(args->dp->i_mount, last) == args->geo->blksize;
-       if (rval != 0 && args->dp->i_d.di_size != args->geo->blksize) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, args->dp->i_mount);
+       if (XFS_IS_CORRUPT(args->dp->i_mount,
+                          rval != 0 &&
+                          args->dp->i_d.di_size != args->geo->blksize))
                return -EFSCORRUPTED;
-       }
        *vp = rval;
        return 0;
 }

diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index 5f30a19..560b7e9 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -728,10 +728,9 @@ xfs_dir2_leafn_lookup_for_addname(
                         * If it has room, return it.
                         */
                        xfs_dir2_free_hdr_from_disk(mp, &freehdr, free);
-                       if (unlikely(
-                           freehdr.bests[fi] == cpu_to_be16(NULLDATAOFF))) {
-                               XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
-                                                       XFS_ERRLEVEL_LOW, mp);
+                       if (XFS_IS_CORRUPT(mp,
+                                          freehdr.bests[fi] ==
+                                          cpu_to_be16(NULLDATAOFF))) {
                                if (curfdb != newfdb)
                                        xfs_trans_brelse(tp, curbp);
                                return -EFSCORRUPTED;
@@ -1722,7 +1721,9 @@ xfs_dir2_node_add_datablk(
                if (error)
                        return error;
 
-               if (xfs_dir2_db_to_fdb(args->geo, *dbno) != fbno) {
+               if (XFS_IS_CORRUPT(mp,
+                                  xfs_dir2_db_to_fdb(args->geo, *dbno) !=
+                                  fbno)) {
                        xfs_alert(mp,
 "%s: dir ino %llu needed freesp block %lld for data block %lld, got %lld",
                                __func__, (unsigned long long)dp->i_ino,
@@ -1736,7 +1737,6 @@ xfs_dir2_node_add_datablk(
                        } else {
                                xfs_alert(mp, " ... fblk is NULL");
                        }
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
                        return -EFSCORRUPTED;
                }
 

diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index af7fc4f..d7d702e 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -1177,7 +1177,7 @@ xfs_refcount_finish_one(
                                XFS_ALLOC_FLAG_FREEING, &agbp);
                if (error)
                        return error;
-               if (!agbp)
+               if (XFS_IS_CORRUPT(tp->t_mountp, !agbp))
                        return -EFSCORRUPTED;
 
                rcur = xfs_refcountbt_init_cursor(mp, tp, agbp, agno);
@@ -1661,17 +1661,16 @@ struct xfs_refcount_recovery {
 /* Stuff an extent on the recovery list. */
 STATIC int
 xfs_refcount_recover_extent(
-       struct xfs_btree_cur            *cur,
+       struct xfs_btree_cur            *cur,
        union xfs_btree_rec             *rec,
        void                            *priv)
 {
        struct list_head                *debris = priv;
        struct xfs_refcount_recovery    *rr;
 
-       if (be32_to_cpu(rec->refc.rc_refcount) != 1) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, cur->bc_mp);
+       if (XFS_IS_CORRUPT(cur->bc_mp,
+                          be32_to_cpu(rec->refc.rc_refcount) != 1))
                return -EFSCORRUPTED;
-       }
 
        rr = kmem_alloc(sizeof(struct xfs_refcount_recovery), 0);
        xfs_refcount_btrec_to_irec(rec, &rr->rr_rrec);

diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
index 9488cbe..ff9412f 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap.c
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -2400,7 +2400,7 @@ xfs_rmap_finish_one(
                error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
                if (error)
                        return error;
-               if (!agbp)
+               if (XFS_IS_CORRUPT(tp->t_mountp, !agbp))
                        return -EFSCORRUPTED;
 
                rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);

diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index d8aaa1d..f42c74c 100644 (file)
--- a/fs/xfs/libxfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
@@ -70,10 +70,8 @@ xfs_rtbuf_get(
        if (error)
                return error;
 
-       if (nmap == 0 || !xfs_bmap_is_real_extent(&map)) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, nmap == 0 || !xfs_bmap_is_real_extent(&map)))
                return -EFSCORRUPTED;
-       }
 
        ASSERT(map.br_startblock != NULLFSBLOCK);
        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,

diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index 0ec6606..7a099df 100644 (file)
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -86,11 +86,10 @@ xfs_attr_shortform_list(
            (XFS_ISRESET_CURSOR(cursor) &&
             (dp->i_afp->if_bytes + sf->hdr.count * 16) < context->bufsize)) {
                for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
-                       if (!xfs_attr_namecheck(sfe->nameval, sfe->namelen)) {
-                               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                                context->dp->i_mount);
+                       if (XFS_IS_CORRUPT(context->dp->i_mount,
+                                          !xfs_attr_namecheck(sfe->nameval,
+                                                              sfe->namelen)))
                                return -EFSCORRUPTED;
-                       }
                        context->put_listent(context,
                                             sfe->flags,
                                             sfe->nameval,
@@ -179,9 +178,9 @@ xfs_attr_shortform_list(
                        cursor->hashval = sbp->hash;
                        cursor->offset = 0;
                }
-               if (!xfs_attr_namecheck(sbp->name, sbp->namelen)) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                        context->dp->i_mount);
+               if (XFS_IS_CORRUPT(context->dp->i_mount,
+                                  !xfs_attr_namecheck(sbp->name,
+                                                      sbp->namelen))) {
                        error = -EFSCORRUPTED;
                        goto out;
                }
@@ -269,10 +268,8 @@ xfs_attr_node_list_lookup(
                        return 0;
 
                /* We can't point back to the root. */
-               if (cursor->blkno == 0) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+               if (XFS_IS_CORRUPT(mp, cursor->blkno == 0))
                        return -EFSCORRUPTED;
-               }
        }
 
        if (expected_level != 0)
@@ -473,11 +470,9 @@ xfs_attr3_leaf_list_int(
                        valuelen = be32_to_cpu(name_rmt->valuelen);
                }
 
-               if (!xfs_attr_namecheck(name, namelen)) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                        context->dp->i_mount);
+               if (XFS_IS_CORRUPT(context->dp->i_mount,
+                                  !xfs_attr_namecheck(name, namelen)))
                        return -EFSCORRUPTED;
-               }
                context->put_listent(context, entry->flags,
                                              name, namelen, valuelen);
                if (context->seen_enough)

diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index b149cb4..95bc9ef 100644 (file)
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -117,11 +117,10 @@ xfs_dir2_sf_getdents(
                ino = xfs_dir2_sf_get_ino(mp, sfp, sfep);
                filetype = xfs_dir2_sf_get_ftype(mp, sfep);
                ctx->pos = off & 0x7fffffff;
-               if (!xfs_dir2_namecheck(sfep->name, sfep->namelen)) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                        dp->i_mount);
+               if (XFS_IS_CORRUPT(dp->i_mount,
+                                  !xfs_dir2_namecheck(sfep->name,
+                                                      sfep->namelen)))
                        return -EFSCORRUPTED;
-               }
                if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
                            xfs_dir3_get_dtype(mp, filetype)))
                        return 0;
@@ -207,9 +206,9 @@ xfs_dir2_block_getdents(
                /*
                 * If it didn't fit, set the final offset to here & return.
                 */
-               if (!xfs_dir2_namecheck(dep->name, dep->namelen)) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                        dp->i_mount);
+               if (XFS_IS_CORRUPT(dp->i_mount,
+                                  !xfs_dir2_namecheck(dep->name,
+                                                      dep->namelen))) {
                        error = -EFSCORRUPTED;
                        goto out_rele;
                }
@@ -459,9 +458,9 @@ xfs_dir2_leaf_getdents(
                filetype = xfs_dir2_data_get_ftype(mp, dep);
 
                ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
-               if (!xfs_dir2_namecheck(dep->name, dep->namelen)) {
-                       XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                        dp->i_mount);
+               if (XFS_IS_CORRUPT(dp->i_mount,
+                                  !xfs_dir2_namecheck(dep->name,
+                                                      dep->namelen))) {
                        error = -EFSCORRUPTED;
                        break;
                }

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index d1960ff..28e2d1f 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -856,10 +856,8 @@ xfs_buffered_write_iomap_begin(
 
        xfs_ilock(ip, XFS_ILOCK_EXCL);
 
-       if (unlikely(XFS_TEST_ERROR(
-           !xfs_ifork_has_extents(ip, XFS_DATA_FORK),
-            mp, XFS_ERRTAG_BMAPIFORMAT))) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, XFS_DATA_FORK)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                error = -EFSCORRUPTED;
                goto out_unlock;
        }

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 57e6e44..b129e07 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -481,10 +481,8 @@ xfs_vn_get_link_inline(
         * if_data is junk.
         */
        link = ip->i_df.if_u1.if_data;
-       if (!link) {
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, ip->i_mount);
+       if (XFS_IS_CORRUPT(ip->i_mount, !link))
                return ERR_PTR(-EFSCORRUPTED);
-       }
        return link;
 }
 

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 02f2147..a008e33 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -103,10 +103,9 @@ xlog_alloc_buffer(
         * Pass log block 0 since we don't have an addr yet, buffer will be
         * verified on read.
         */
-       if (!xlog_verify_bno(log, 0, nbblks)) {
+       if (XFS_IS_CORRUPT(log->l_mp, !xlog_verify_bno(log, 0, nbblks))) {
                xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
                        nbblks);
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
                return NULL;
        }
 
@@ -152,11 +151,10 @@ xlog_do_io(
 {
        int                     error;
 
-       if (!xlog_verify_bno(log, blk_no, nbblks)) {
+       if (XFS_IS_CORRUPT(log->l_mp, !xlog_verify_bno(log, blk_no, nbblks))) {
                xfs_warn(log->l_mp,
                         "Invalid log block/length (0x%llx, 0x%x) for buffer",
                         blk_no, nbblks);
-               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
                return -EFSCORRUPTED;
        }
 
@@ -244,19 +242,17 @@ xlog_header_check_recover(
         * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
         * a dirty log created in IRIX.
         */
-       if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
+       if (XFS_IS_CORRUPT(mp, head->h_fmt != cpu_to_be32(XLOG_FMT))) {
                xfs_warn(mp,
        "dirty log written in incompatible format - can't recover");
                xlog_header_check_dump(mp, head);
-               XFS_ERROR_REPORT("xlog_header_check_recover(1)",
-                                XFS_ERRLEVEL_HIGH, mp);
                return -EFSCORRUPTED;
-       } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
+       }
+       if (XFS_IS_CORRUPT(mp, !uuid_equal(&mp->m_sb.sb_uuid,
+                                          &head->h_fs_uuid))) {
                xfs_warn(mp,
        "dirty log entry has mismatched uuid - can't recover");
                xlog_header_check_dump(mp, head);
-               XFS_ERROR_REPORT("xlog_header_check_recover(2)",
-                                XFS_ERRLEVEL_HIGH, mp);
                return -EFSCORRUPTED;
        }
        return 0;
@@ -279,11 +275,10 @@ xlog_header_check_mount(
                 * by IRIX and continue.
                 */
                xfs_warn(mp, "null uuid in log - IRIX style log");
-       } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
+       } else if (XFS_IS_CORRUPT(mp, !uuid_equal(&mp->m_sb.sb_uuid,
+                                                 &head->h_fs_uuid))) {
                xfs_warn(mp, "log has mismatched uuid - can't recover");
                xlog_header_check_dump(mp, head);
-               XFS_ERROR_REPORT("xlog_header_check_mount",
-                                XFS_ERRLEVEL_HIGH, mp);
                return -EFSCORRUPTED;
        }
        return 0;
@@ -1699,11 +1694,10 @@ xlog_clear_stale_blocks(
                 * the distance from the beginning of the log to the
                 * tail.
                 */
-               if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
-                       XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
-                                        XFS_ERRLEVEL_LOW, log->l_mp);
+               if (XFS_IS_CORRUPT(log->l_mp,
+                                  head_block < tail_block ||
+                                  head_block >= log->l_logBBsize))
                        return -EFSCORRUPTED;
-               }
                tail_distance = tail_block + (log->l_logBBsize - head_block);
        } else {
                /*
@@ -1711,11 +1705,10 @@ xlog_clear_stale_blocks(
                 * so the distance from the head to the tail is just
                 * the tail block minus the head block.
                 */
-               if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
-                       XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
-                                        XFS_ERRLEVEL_LOW, log->l_mp);
+               if (XFS_IS_CORRUPT(log->l_mp,
+                                  head_block >= tail_block ||
+                                  head_cycle != tail_cycle + 1))
                        return -EFSCORRUPTED;
-               }
                tail_distance = tail_block - head_block;
        }
 
@@ -2135,13 +2128,11 @@ xlog_recover_do_inode_buffer(
                 */
                logged_nextp = item->ri_buf[item_index].i_addr +
                                next_unlinked_offset - reg_buf_offset;
-               if (unlikely(*logged_nextp == 0)) {
+               if (XFS_IS_CORRUPT(mp, *logged_nextp == 0)) {
                        xfs_alert(mp,
                "Bad inode buffer log record (ptr = "PTR_FMT", bp = "PTR_FMT"). "
                "Trying to replay bad (0) inode di_next_unlinked field.",
                                item, bp);
-                       XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
-                                        XFS_ERRLEVEL_LOW, mp);
                        return -EFSCORRUPTED;
                }
 
@@ -2969,22 +2960,18 @@ xlog_recover_inode_pass2(
         * Make sure the place we're flushing out to really looks
         * like an inode!
         */
-       if (unlikely(!xfs_verify_magic16(bp, dip->di_magic))) {
+       if (XFS_IS_CORRUPT(mp, !xfs_verify_magic16(bp, dip->di_magic))) {
                xfs_alert(mp,
        "%s: Bad inode magic number, dip = "PTR_FMT", dino bp = "PTR_FMT", ino = %Ld",
                        __func__, dip, bp, in_f->ilf_ino);
-               XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
-                                XFS_ERRLEVEL_LOW, mp);
                error = -EFSCORRUPTED;
                goto out_release;
        }
        ldip = item->ri_buf[1].i_addr;
-       if (unlikely(ldip->di_magic != XFS_DINODE_MAGIC)) {
+       if (XFS_IS_CORRUPT(mp, ldip->di_magic != XFS_DINODE_MAGIC)) {
                xfs_alert(mp,
                        "%s: Bad inode log record, rec ptr "PTR_FMT", ino %Ld",
                        __func__, item, in_f->ilf_ino);
-               XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
-                                XFS_ERRLEVEL_LOW, mp);
                error = -EFSCORRUPTED;
                goto out_release;
        }
@@ -5209,14 +5196,13 @@ xlog_valid_rec_header(
 {
        int                     hlen;
 
-       if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
-               XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
-                               XFS_ERRLEVEL_LOW, log->l_mp);
+       if (XFS_IS_CORRUPT(log->l_mp,
+                          rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM)))
                return -EFSCORRUPTED;
-       }
-       if (unlikely(
-           (!rhead->h_version ||
-           (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
+       if (XFS_IS_CORRUPT(log->l_mp,
+                          (!rhead->h_version ||
+                          (be32_to_cpu(rhead->h_version) &
+                           (~XLOG_VERSION_OKBITS))))) {
                xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
                        __func__, be32_to_cpu(rhead->h_version));
                return -EFSCORRUPTED;
@@ -5224,16 +5210,11 @@ xlog_valid_rec_header(
 
        /* LR body must have data or it wouldn't have been written */
        hlen = be32_to_cpu(rhead->h_len);
-       if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
-               XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
-                               XFS_ERRLEVEL_LOW, log->l_mp);
+       if (XFS_IS_CORRUPT(log->l_mp, hlen <= 0 || hlen > INT_MAX))
                return -EFSCORRUPTED;
-       }
-       if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
-               XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
-                               XFS_ERRLEVEL_LOW, log->l_mp);
+       if (XFS_IS_CORRUPT(log->l_mp,
+                          blkno > log->l_logBBsize || blkno > INT_MAX))
                return -EFSCORRUPTED;
-       }
        return 0;
 }
 

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 5ea9524..fca6510 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -761,9 +761,8 @@ xfs_mountfs(
                goto out_free_dir;
        }
 
-       if (!sbp->sb_logblocks) {
+       if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {
                xfs_warn(mp, "no log defined");
-               XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
                error = -EFSCORRUPTED;
                goto out_free_perag;
        }
@@ -801,12 +800,10 @@ xfs_mountfs(
 
        ASSERT(rip != NULL);
 
-       if (unlikely(!S_ISDIR(VFS_I(rip)->i_mode))) {
+       if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {
                xfs_warn(mp, "corrupted root inode %llu: not a directory",
                        (unsigned long long)rip->i_ino);
                xfs_iunlock(rip, XFS_ILOCK_EXCL);
-               XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
-                                mp);
                error = -EFSCORRUPTED;
                goto out_rele_rip;
        }

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 66ea8e4..7e264cb 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -755,19 +755,15 @@ xfs_qm_qino_alloc(
                if ((flags & XFS_QMOPT_PQUOTA) &&
                             (mp->m_sb.sb_gquotino != NULLFSINO)) {
                        ino = mp->m_sb.sb_gquotino;
-                       if (mp->m_sb.sb_pquotino != NULLFSINO) {
-                               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                               mp);
+                       if (XFS_IS_CORRUPT(mp,
+                                          mp->m_sb.sb_pquotino != NULLFSINO))
                                return -EFSCORRUPTED;
-                       }
                } else if ((flags & XFS_QMOPT_GQUOTA) &&
                             (mp->m_sb.sb_pquotino != NULLFSINO)) {
                        ino = mp->m_sb.sb_pquotino;
-                       if (mp->m_sb.sb_gquotino != NULLFSINO) {
-                               XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW,
-                                               mp);
+                       if (XFS_IS_CORRUPT(mp,
+                                          mp->m_sb.sb_gquotino != NULLFSINO))
                                return -EFSCORRUPTED;
-                       }
                }
                if (ino != NULLFSINO) {
                        error = xfs_iget(mp, NULL, ino, 0, 0, ip);