xfs: remove the expr argument to XFS_TEST_ERROR

Don't pass expr to XFS_TEST_ERROR.  Most calls pass a constant false,
and the places that do pass an expression become cleaner by moving it
out.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Carlos Maiolino <cem@kernel.org>

diff --git a/fs/xfs/libxfs/xfs_ag_resv.c b/fs/xfs/libxfs/xfs_ag_resv.c
index fb79215a509d21517157265aa5dad841ec0adbc2..8ac8230c3d3cc232e157752e3e2cf40b11813e54 100644 (file)
--- a/fs/xfs/libxfs/xfs_ag_resv.c
+++ b/fs/xfs/libxfs/xfs_ag_resv.c
@@ -92,9 +92,8 @@ xfs_ag_resv_critical(
        trace_xfs_ag_resv_critical(pag, type, avail);
 
        /* Critically low if less than 10% or max btree height remains. */
-       return XFS_TEST_ERROR(avail < orig / 10 ||
-                             avail < mp->m_agbtree_maxlevels,
-                       mp, XFS_ERRTAG_AG_RESV_CRITICAL);
+       return avail < orig / 10 || avail < mp->m_agbtree_maxlevels ||
+               XFS_TEST_ERROR(mp, XFS_ERRTAG_AG_RESV_CRITICAL);
 }
 
 /*
@@ -203,7 +202,7 @@ __xfs_ag_resv_init(
                return -EINVAL;
        }
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_AG_RESV_FAIL))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_AG_RESV_FAIL))
                error = -ENOSPC;
        else
                error = xfs_dec_fdblocks(mp, hidden_space, true);

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index 000cc7f4a3ce5085ab73fef86fb202ebafe59174..ad381c73abc4de60e50acd6def065ae9ad25fdd7 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -3321,7 +3321,7 @@ xfs_agf_read_verify(
                xfs_verifier_error(bp, -EFSBADCRC, __this_address);
        else {
                fa = xfs_agf_verify(bp);
-               if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_ALLOC_READ_AGF))
+               if (fa || XFS_TEST_ERROR(mp, XFS_ERRTAG_ALLOC_READ_AGF))
                        xfs_verifier_error(bp, -EFSCORRUPTED, fa);
        }
 }
@@ -4019,8 +4019,7 @@ __xfs_free_extent(
        ASSERT(len != 0);
        ASSERT(type != XFS_AG_RESV_AGFL);
 
-       if (XFS_TEST_ERROR(false, mp,
-                       XFS_ERRTAG_FREE_EXTENT))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_FREE_EXTENT))
                return -EIO;
 
        error = xfs_free_extent_fix_freelist(tp, pag, &agbp);

diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 47213e6023dd4bdbcae9bff4c403c97e07aff274..91c1b30ebaab31ce760ea42d94dd9ec3c60efa29 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -1212,7 +1212,7 @@ xfs_attr3_leaf_to_node(
 
        trace_xfs_attr_leaf_to_node(args);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_ATTR_LEAF_TO_NODE)) {
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_ATTR_LEAF_TO_NODE)) {
                error = -EIO;
                goto out;
        }

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 80bdb537fcf7832566d207d5a64dd842a02fbeef..53ef4b7e504d627390c9edaddb511a05a13db508 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -3654,8 +3654,7 @@ xfs_bmap_btalloc(
        /* Trim the allocation back to the maximum an AG can fit. */
        args.maxlen = min(ap->length, mp->m_ag_max_usable);
 
-       if (unlikely(XFS_TEST_ERROR(false, mp,
-                       XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
+       if (unlikely(XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
                error = xfs_bmap_exact_minlen_extent_alloc(ap, &args);
        else if ((ap->datatype & XFS_ALLOC_USERDATA) &&
                        xfs_inode_is_filestream(ap->ip))
@@ -3841,7 +3840,7 @@ xfs_bmapi_read(
        }
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -4192,7 +4191,7 @@ xfs_bmapi_write(
                        (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -4537,7 +4536,7 @@ xfs_bmapi_remap(
                        (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -5671,7 +5670,7 @@ xfs_bmap_collapse_extents(
        int                     logflags = 0;
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -5787,7 +5786,7 @@ xfs_bmap_insert_extents(
        int                     logflags = 0;
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -5892,7 +5891,7 @@ xfs_bmap_split_extent(
        int                             i = 0;
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, whichfork);
                return -EFSCORRUPTED;
        }
@@ -6057,7 +6056,7 @@ xfs_bmap_finish_one(
 
        trace_xfs_bmap_deferred(bi);
 
-       if (XFS_TEST_ERROR(false, tp->t_mountp, XFS_ERRTAG_BMAP_FINISH_ONE))
+       if (XFS_TEST_ERROR(tp->t_mountp, XFS_ERRTAG_BMAP_FINISH_ONE))
                return -EIO;
 
        switch (bi->bi_type) {

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index a61211d253f1ca9f91e810da38ba9197a12082f4..dbe9df8c33004edaeef522b034254b7a8248b5d5 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -306,7 +306,7 @@ xfs_btree_check_block(
 
        fa = __xfs_btree_check_block(cur, block, level, bp);
        if (XFS_IS_CORRUPT(mp, fa != NULL) ||
-           XFS_TEST_ERROR(false, mp, xfs_btree_block_errtag(cur))) {
+           XFS_TEST_ERROR(mp, xfs_btree_block_errtag(cur))) {
                if (bp)
                        trace_xfs_btree_corrupt(bp, _RET_IP_);
                xfs_btree_mark_sick(cur);

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 723a0643b8386c2b66e3d548514771fa8ed49240..90f7fc219fccc87bf6813a9a1d73c8797aa7ac3a 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -565,7 +565,7 @@ xfs_da3_split(
 
        trace_xfs_da_split(state->args);
 
-       if (XFS_TEST_ERROR(false, state->mp, XFS_ERRTAG_DA_LEAF_SPLIT))
+       if (XFS_TEST_ERROR(state->mp, XFS_ERRTAG_DA_LEAF_SPLIT))
                return -EIO;
 
        /*

diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 1775abcfa04d613e7275b085d327636e372820fb..82a338458a51794844ba9ca32081555abdd7261b 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -223,7 +223,7 @@ xfs_dir_ino_validate(
        bool            ino_ok = xfs_verify_dir_ino(mp, ino);
 
        if (XFS_IS_CORRUPT(mp, !ino_ok) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_DIR_INO_VALIDATE)) {
                xfs_warn(mp, "Invalid inode number 0x%Lx",
                                (unsigned long long) ino);
                return -EFSCORRUPTED;

diff --git a/fs/xfs/libxfs/xfs_exchmaps.c b/fs/xfs/libxfs/xfs_exchmaps.c
index 3f1d6a98c1181987f3517087397854dc469472d6..932ee4619e9ea65deca94f84db859291d59da00e 100644 (file)
--- a/fs/xfs/libxfs/xfs_exchmaps.c
+++ b/fs/xfs/libxfs/xfs_exchmaps.c
@@ -616,7 +616,7 @@ xfs_exchmaps_finish_one(
                        return error;
        }
 
-       if (XFS_TEST_ERROR(false, tp->t_mountp, XFS_ERRTAG_EXCHMAPS_FINISH_ONE))
+       if (XFS_TEST_ERROR(tp->t_mountp, XFS_ERRTAG_EXCHMAPS_FINISH_ONE))
                return -EIO;
 
        /* If we still have work to do, ask for a new transaction. */
@@ -882,7 +882,7 @@ xmi_ensure_delta_nextents(
                                &new_nextents))
                return -EFBIG;
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REDUCE_MAX_IEXTENTS) &&
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_REDUCE_MAX_IEXTENTS) &&
            new_nextents > 10)
                return -EFBIG;
 

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 5fefdd4fe75dbd2a11b628b4e0d525e2f2f8e080..d97295eaebe631e8f0166a3f9470d319cd459d3f 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -2706,7 +2706,7 @@ xfs_agi_read_verify(
                xfs_verifier_error(bp, -EFSBADCRC, __this_address);
        else {
                fa = xfs_agi_verify(bp);
-               if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_IALLOC_READ_AGI))
+               if (fa || XFS_TEST_ERROR(mp, XFS_ERRTAG_IALLOC_READ_AGI))
                        xfs_verifier_error(bp, -EFSCORRUPTED, fa);
        }
 }

diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index aa13fc00afd707b9baa274a16711126cb67d4da9..b1812b2c3ccece66552933a934353fbbc6b5af11 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -61,8 +61,8 @@ xfs_inode_buf_verify(
                di_ok = xfs_verify_magic16(bp, dip->di_magic) &&
                        xfs_dinode_good_version(mp, dip->di_version) &&
                        xfs_verify_agino_or_null(bp->b_pag, unlinked_ino);
-               if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
-                                               XFS_ERRTAG_ITOBP_INOTOBP))) {
+               if (unlikely(!di_ok ||
+                               XFS_TEST_ERROR(mp, XFS_ERRTAG_ITOBP_INOTOBP))) {
                        if (readahead) {
                                bp->b_flags &= ~XBF_DONE;
                                xfs_buf_ioerror(bp, -EIO);

diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index 4f99b90add5526f35161f77e17de7706b3776af0..1772d82f2d68b654a3c49c020b35dda9559df506 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -756,8 +756,7 @@ xfs_iext_count_extend(
        if (nr_exts < ifp->if_nextents)
                return -EFBIG;
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REDUCE_MAX_IEXTENTS) &&
-           nr_exts > 10)
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_REDUCE_MAX_IEXTENTS) && nr_exts > 10)
                return -EFBIG;
 
        if (nr_exts > xfs_iext_max_nextents(has_large, whichfork)) {

diff --git a/fs/xfs/libxfs/xfs_metafile.c b/fs/xfs/libxfs/xfs_metafile.c
index 225923e463c41e39feceb740c781c06c8acdd6cc..b02e3d6c0868c6f4f0a3485bd7a5b49157a81f53 100644 (file)
--- a/fs/xfs/libxfs/xfs_metafile.c
+++ b/fs/xfs/libxfs/xfs_metafile.c
@@ -121,7 +121,7 @@ xfs_metafile_resv_critical(
                        div_u64(mp->m_metafile_resv_target, 10)))
                return true;
 
-       return XFS_TEST_ERROR(false, mp, XFS_ERRTAG_METAFILE_RESV_CRITICAL);
+       return XFS_TEST_ERROR(mp, XFS_ERRTAG_METAFILE_RESV_CRITICAL);
 }
 
 /* Allocate a block from the metadata file's reservation. */

diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index 8977840374836e45b1dd7767be61a636d9427df8..2484dc9f6d7ecc567bb1ce34f086bb7b277bd798 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -1113,8 +1113,7 @@ xfs_refcount_still_have_space(
         * refcount continue update "error" has been injected.
         */
        if (cur->bc_refc.nr_ops > 2 &&
-           XFS_TEST_ERROR(false, cur->bc_mp,
-                       XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE))
+           XFS_TEST_ERROR(cur->bc_mp, XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE))
                return false;
 
        if (cur->bc_refc.nr_ops == 0)
@@ -1398,7 +1397,7 @@ xfs_refcount_finish_one(
 
        trace_xfs_refcount_deferred(mp, ri);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE))
                return -EIO;
 
        /*
@@ -1511,7 +1510,7 @@ xfs_rtrefcount_finish_one(
 
        trace_xfs_refcount_deferred(mp, ri);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_REFCOUNT_FINISH_ONE))
                return -EIO;
 
        /*

diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
index 3cdf50563fecb981e9f479c3a6216b079bc2c35d..83e0488ff77364248bbbdb87a8278426d7dbec74 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap.c
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -2690,7 +2690,7 @@ xfs_rmap_finish_one(
 
        trace_xfs_rmap_deferred(mp, ri);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_RMAP_FINISH_ONE))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_RMAP_FINISH_ONE))
                return -EIO;
 
        /*

diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index 5057536e586ca44071a74eb546a64ef687245852..618061d898d4a8cb43053f4ae5fdf0bc1e9d1b01 100644 (file)
--- a/fs/xfs/libxfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
@@ -1067,7 +1067,7 @@ xfs_rtfree_extent(
        ASSERT(rbmip->i_itemp != NULL);
        xfs_assert_ilocked(rbmip, XFS_ILOCK_EXCL);
 
-       if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_FREE_EXTENT))
+       if (XFS_TEST_ERROR(mp, XFS_ERRTAG_FREE_EXTENT))
                return -EIO;
 
        error = xfs_rtcheck_alloc_range(&args, start, len);

diff --git a/fs/xfs/scrub/cow_repair.c b/fs/xfs/scrub/cow_repair.c
index 38a246b8bf11c92a826ba1a90db88063fb04aab4..b2a83801412e917cf37720cc5acd47a6a35dfe0d 100644 (file)
--- a/fs/xfs/scrub/cow_repair.c
+++ b/fs/xfs/scrub/cow_repair.c
@@ -300,7 +300,7 @@ xrep_cow_find_bad(
         * on the debugging knob, replace everything in the CoW fork.
         */
        if ((sc->sm->sm_flags & XFS_SCRUB_IFLAG_FORCE_REBUILD) ||
-           XFS_TEST_ERROR(false, sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR)) {
+           XFS_TEST_ERROR(sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR)) {
                error = xrep_cow_mark_file_range(xc, xc->irec.br_startblock,
                                xc->irec.br_blockcount);
                if (error)
@@ -385,7 +385,7 @@ xrep_cow_find_bad_rt(
         * CoW fork and then scan for staging extents in the refcountbt.
         */
        if ((sc->sm->sm_flags & XFS_SCRUB_IFLAG_FORCE_REBUILD) ||
-           XFS_TEST_ERROR(false, sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR)) {
+           XFS_TEST_ERROR(sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR)) {
                error = xrep_cow_mark_file_range(xc, xc->irec.br_startblock,
                                xc->irec.br_blockcount);
                if (error)

diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index d00c18954a26b8848c00d43864fba14489d164e6..efd5a7ccdf624a1d762ab81621e219e2a0db2310 100644 (file)
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -1110,7 +1110,7 @@ xrep_will_attempt(
                return true;
 
        /* Let debug users force us into the repair routines. */
-       if (XFS_TEST_ERROR(false, sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR))
+       if (XFS_TEST_ERROR(sc->mp, XFS_ERRTAG_FORCE_SCRUB_REPAIR))
                return true;
 
        /* Metadata is corrupt or failed cross-referencing. */

diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
index 5eef3bc30bda1a40d742ccd99e9e9f758c61b746..c3a593319bee71497f1c688062f06d37d6ea20b2 100644 (file)
--- a/fs/xfs/xfs_attr_item.c
+++ b/fs/xfs/xfs_attr_item.c
@@ -491,7 +491,7 @@ xfs_attr_finish_item(
        /* Reset trans after EAGAIN cycle since the transaction is new */
        args->trans = tp;
 
-       if (XFS_TEST_ERROR(false, args->dp->i_mount, XFS_ERRTAG_LARP)) {
+       if (XFS_TEST_ERROR(args->dp->i_mount, XFS_ERRTAG_LARP)) {
                error = -EIO;
                goto out;
        }

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index f9ef3b2a332a6fb4a8c55323dd4171c0e3e86061..8360e77b3215ddc8e073cff8c37b8ca95eed19f0 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1299,7 +1299,7 @@ xfs_buf_bio_end_io(
        if (bio->bi_status)
                xfs_buf_ioerror(bp, blk_status_to_errno(bio->bi_status));
        else if ((bp->b_flags & XBF_WRITE) && (bp->b_flags & XBF_ASYNC) &&
-                XFS_TEST_ERROR(false, bp->b_mount, XFS_ERRTAG_BUF_IOERROR))
+                XFS_TEST_ERROR(bp->b_mount, XFS_ERRTAG_BUF_IOERROR))
                xfs_buf_ioerror(bp, -EIO);
 
        if (bp->b_flags & XBF_ASYNC) {
@@ -2084,7 +2084,7 @@ void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)
         * This allows userspace to disrupt buffer caching for debug/testing
         * purposes.
         */
-       if (XFS_TEST_ERROR(false, bp->b_mount, XFS_ERRTAG_BUF_LRU_REF))
+       if (XFS_TEST_ERROR(bp->b_mount, XFS_ERRTAG_BUF_LRU_REF))
                lru_ref = 0;
 
        atomic_set(&bp->b_lru_ref, lru_ref);

diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index fac35ff3da65caa5f7b314eba36f4d410a49f5fe..44dd8aba00979c2ec90a912edf98156b06d888e1 100644 (file)
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -291,7 +291,6 @@ xfs_errortag_enabled(
 bool
 xfs_errortag_test(
        struct xfs_mount        *mp,
-       const char              *expression,
        const char              *file,
        int                     line,
        unsigned int            error_tag)
@@ -317,8 +316,8 @@ xfs_errortag_test(
                return false;
 
        xfs_warn_ratelimited(mp,
-"Injecting error (%s) at file %s, line %d, on filesystem \"%s\"",
-                       expression, file, line, mp->m_super->s_id);
+"Injecting error at file %s, line %d, on filesystem \"%s\"",
+                       file, line, mp->m_super->s_id);
        return true;
 }
 

diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h
index fd60a008f9d22de3c0ae9e2beb1fcc46af56e6b0..8429c1ee86e793d0f2b2f5859f1482f2bb9e90ad 100644 (file)
--- a/fs/xfs/xfs_error.h
+++ b/fs/xfs/xfs_error.h
@@ -41,10 +41,10 @@ extern void xfs_inode_verifier_error(struct xfs_inode *ip, int error,
 #ifdef DEBUG
 extern int xfs_errortag_init(struct xfs_mount *mp);
 extern void xfs_errortag_del(struct xfs_mount *mp);
-extern bool xfs_errortag_test(struct xfs_mount *mp, const char *expression,
-               const char *file, int line, unsigned int error_tag);
-#define XFS_TEST_ERROR(expr, mp, tag)          \
-       ((expr) || xfs_errortag_test((mp), #expr, __FILE__, __LINE__, (tag)))
+bool xfs_errortag_test(struct xfs_mount *mp, const char *file, int line,
+               unsigned int error_tag);
+#define XFS_TEST_ERROR(mp, tag)                \
+       xfs_errortag_test((mp), __FILE__, __LINE__, (tag))
 bool xfs_errortag_enabled(struct xfs_mount *mp, unsigned int tag);
 #define XFS_ERRORTAG_DELAY(mp, tag)            \
        do { \
@@ -63,7 +63,7 @@ extern int xfs_errortag_clearall(struct xfs_mount *mp);
 #else
 #define xfs_errortag_init(mp)                  (0)
 #define xfs_errortag_del(mp)
-#define XFS_TEST_ERROR(expr, mp, tag)          (expr)
+#define XFS_TEST_ERROR(mp, tag)                        (false)
 #define XFS_ERRORTAG_DELAY(mp, tag)            ((void)0)
 #define xfs_errortag_add(mp, tag)              (ENOSYS)
 #define xfs_errortag_clearall(mp)              (ENOSYS)

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 0ddb9ce0f5e36f8a5130e8187f2edfe3443ed62e..2bfe87b09c2ada5b25c5642ab2d6f8191db7e1a3 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2381,8 +2381,8 @@ xfs_iflush(
         * error handling as the caller will shutdown and fail the buffer.
         */
        error = -EFSCORRUPTED;
-       if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
-                              mp, XFS_ERRTAG_IFLUSH_1)) {
+       if (dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC) ||
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_IFLUSH_1)) {
                xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
                        "%s: Bad inode %llu magic number 0x%x, ptr "PTR_FMT,
                        __func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
@@ -2398,29 +2398,27 @@ xfs_iflush(
                        goto flush_out;
                }
        } else if (S_ISREG(VFS_I(ip)->i_mode)) {
-               if (XFS_TEST_ERROR(
-                   ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
-                   ip->i_df.if_format != XFS_DINODE_FMT_BTREE,
-                   mp, XFS_ERRTAG_IFLUSH_3)) {
+               if ((ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
+                    ip->i_df.if_format != XFS_DINODE_FMT_BTREE) ||
+                   XFS_TEST_ERROR(mp, XFS_ERRTAG_IFLUSH_3)) {
                        xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
                                "%s: Bad regular inode %llu, ptr "PTR_FMT,
                                __func__, ip->i_ino, ip);
                        goto flush_out;
                }
        } else if (S_ISDIR(VFS_I(ip)->i_mode)) {
-               if (XFS_TEST_ERROR(
-                   ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
-                   ip->i_df.if_format != XFS_DINODE_FMT_BTREE &&
-                   ip->i_df.if_format != XFS_DINODE_FMT_LOCAL,
-                   mp, XFS_ERRTAG_IFLUSH_4)) {
+               if ((ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
+                    ip->i_df.if_format != XFS_DINODE_FMT_BTREE &&
+                    ip->i_df.if_format != XFS_DINODE_FMT_LOCAL) ||
+                   XFS_TEST_ERROR(mp, XFS_ERRTAG_IFLUSH_4)) {
                        xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
                                "%s: Bad directory inode %llu, ptr "PTR_FMT,
                                __func__, ip->i_ino, ip);
                        goto flush_out;
                }
        }
-       if (XFS_TEST_ERROR(ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af) >
-                               ip->i_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
+       if (ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af) >
+           ip->i_nblocks || XFS_TEST_ERROR(mp, XFS_ERRTAG_IFLUSH_5)) {
                xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
                        "%s: detected corrupt incore inode %llu, "
                        "total extents = %llu nblocks = %lld, ptr "PTR_FMT,
@@ -2429,8 +2427,8 @@ xfs_iflush(
                        ip->i_nblocks, ip);
                goto flush_out;
        }
-       if (XFS_TEST_ERROR(ip->i_forkoff > mp->m_sb.sb_inodesize,
-                               mp, XFS_ERRTAG_IFLUSH_6)) {
+       if (ip->i_forkoff > mp->m_sb.sb_inodesize ||
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_IFLUSH_6)) {
                xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
                        "%s: bad inode %llu, forkoff 0x%x, ptr "PTR_FMT,
                        __func__, ip->i_ino, ip->i_forkoff, ip);

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 2a74f2957341032403c2e32ce704ac120c4c11b2..2570d0a66047380c292bd7ad245ce387f991dee9 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -1554,7 +1554,7 @@ xfs_zoned_buffered_write_iomap_begin(
                return error;
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(&ip->i_df)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, XFS_DATA_FORK);
                error = -EFSCORRUPTED;
                goto out_unlock;
@@ -1728,7 +1728,7 @@ xfs_buffered_write_iomap_begin(
                return error;
 
        if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(&ip->i_df)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_BMAPIFORMAT)) {
                xfs_bmap_mark_sick(ip, XFS_DATA_FORK);
                error = -EFSCORRUPTED;
                goto out_unlock;

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 2978de9da38edb55338811453d907b041544fda6..6397a45b293de7fc414ea0e7d3d46a266b531d71 100644 (file)
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -969,8 +969,8 @@ xfs_log_unmount_write(
         * counters will be recalculated.  Refer to xlog_check_unmount_rec for
         * more details.
         */
-       if (XFS_TEST_ERROR(xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS), mp,
-                       XFS_ERRTAG_FORCE_SUMMARY_RECALC)) {
+       if (xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS) ||
+           XFS_TEST_ERROR(mp, XFS_ERRTAG_FORCE_SUMMARY_RECALC)) {
                xfs_alert(mp, "%s: will fix summary counters at next mount",
                                __func__);
                return;
@@ -1240,7 +1240,7 @@ xlog_ioend_work(
        /*
         * Race to shutdown the filesystem if we see an error.
         */
-       if (XFS_TEST_ERROR(error, log->l_mp, XFS_ERRTAG_IODONE_IOERR)) {
+       if (error || XFS_TEST_ERROR(log->l_mp, XFS_ERRTAG_IODONE_IOERR)) {
                xfs_alert(log->l_mp, "log I/O error %d", error);
                xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);
        }
@@ -1827,7 +1827,7 @@ xlog_sync(
         * detects the bad CRC and attempts to recover.
         */
 #ifdef DEBUG
-       if (XFS_TEST_ERROR(false, log->l_mp, XFS_ERRTAG_LOG_BAD_CRC)) {
+       if (XFS_TEST_ERROR(log->l_mp, XFS_ERRTAG_LOG_BAD_CRC)) {
                iclog->ic_header.h_crc &= cpu_to_le32(0xAAAAAAAA);
                iclog->ic_fail_crc = true;
                xfs_warn(log->l_mp,

diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 67c328d23e4ae9c4b0c4b5c07368cbf70a75b0e8..38983c6777df318aa8621514e6acb25ac711836f 100644 (file)
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -374,7 +374,7 @@ xfsaild_push_item(
         * If log item pinning is enabled, skip the push and track the item as
         * pinned. This can help induce head-behind-tail conditions.
         */
-       if (XFS_TEST_ERROR(false, ailp->ail_log->l_mp, XFS_ERRTAG_LOG_ITEM_PIN))
+       if (XFS_TEST_ERROR(ailp->ail_log->l_mp, XFS_ERRTAG_LOG_ITEM_PIN))
                return XFS_ITEM_PINNED;
 
        /*