xfs: convert xfs_sb_version_has checks to use mount features

This is a conversion of the remaining xfs_sb_version_has..(sbp)
checks to use xfs_has_..(mp) feature checks.

This was largely done with a vim replacement macro that did:

:0,$s/xfs_sb_version_has\(.*\)&\(.*\)->m_sb/xfs_has_\1\2/g<CR>

A couple of other variants were also used, and the rest touched up
by hand.

$ size -t fs/xfs/built-in.a
	   text    data     bss     dec     hex filename
before	1127533  311352     484 1439369  15f689 (TOTALS)
after	1125360  311352     484 1437196  15ee0c (TOTALS)

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 6e391bdc4d6d0deef8b36a77d9500cfc50c661de..92033c4672a4b1616b3b1d2000d22e544fb13764 100644 (file)
--- a/fs/xfs/libxfs/xfs_ag.c
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -607,9 +607,9 @@ xfs_agiblock_init(
        }
        for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
                agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
-       if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+       if (xfs_has_inobtcounts(mp)) {
                agi->agi_iblocks = cpu_to_be32(1);
-               if (xfs_sb_version_hasfinobt(&mp->m_sb))
+               if (xfs_has_finobt(mp))
                        agi->agi_fblocks = cpu_to_be32(1);
        }
 }

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index 5be077eb674d0b8eea36084f54d90e79f9091423..95157f5a5a6c0f7cf41ace1292dc34fd67eed725 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -2264,7 +2264,7 @@ xfs_alloc_min_freelist(
        min_free += min_t(unsigned int, levels[XFS_BTNUM_CNTi] + 1,
                                       mp->m_ag_maxlevels);
        /* space needed reverse mapping used space btree */
-       if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+       if (xfs_has_rmapbt(mp))
                min_free += min_t(unsigned int, levels[XFS_BTNUM_RMAPi] + 1,
                                                mp->m_rmap_maxlevels);
 
@@ -2912,7 +2912,7 @@ xfs_agf_verify(
             be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) > mp->m_rmap_maxlevels))
                return __this_address;
 
-       if (xfs_sb_version_hasrmapbt(&mp->m_sb) &&
+       if (xfs_has_rmapbt(mp) &&
            be32_to_cpu(agf->agf_rmap_blocks) > be32_to_cpu(agf->agf_length))
                return __this_address;
 
@@ -2925,16 +2925,16 @@ xfs_agf_verify(
        if (bp->b_pag && be32_to_cpu(agf->agf_seqno) != bp->b_pag->pag_agno)
                return __this_address;
 
-       if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
+       if (xfs_has_lazysbcount(mp) &&
            be32_to_cpu(agf->agf_btreeblks) > be32_to_cpu(agf->agf_length))
                return __this_address;
 
-       if (xfs_sb_version_hasreflink(&mp->m_sb) &&
+       if (xfs_has_reflink(mp) &&
            be32_to_cpu(agf->agf_refcount_blocks) >
            be32_to_cpu(agf->agf_length))
                return __this_address;
 
-       if (xfs_sb_version_hasreflink(&mp->m_sb) &&
+       if (xfs_has_reflink(mp) &&
            (be32_to_cpu(agf->agf_refcount_level) < 1 ||
             be32_to_cpu(agf->agf_refcount_level) > mp->m_refc_maxlevels))
                return __this_address;
@@ -3073,7 +3073,7 @@ xfs_alloc_read_agf(
                 * counter only tracks non-root blocks.
                 */
                allocbt_blks = pag->pagf_btreeblks;
-               if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+               if (xfs_has_rmapbt(mp))
                        allocbt_blks -= be32_to_cpu(agf->agf_rmap_blocks) - 1;
                if (allocbt_blks > 0)
                        atomic64_add(allocbt_blks, &mp->m_allocbt_blks);

diff --git a/fs/xfs/libxfs/xfs_alloc.h b/fs/xfs/libxfs/xfs_alloc.h
index e14c56938bacc278e2800c108b112b7cca728c23..df4aefaf0046e818b49a87b1fdc35b2a00398de9 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.h
+++ b/fs/xfs/libxfs/xfs_alloc.h
@@ -243,7 +243,7 @@ static inline __be32 *
 xfs_buf_to_agfl_bno(
        struct xfs_buf          *bp)
 {
-       if (xfs_sb_version_hascrc(&bp->b_mount->m_sb))
+       if (xfs_has_crc(bp->b_mount))
                return bp->b_addr + sizeof(struct xfs_agfl);
        return bp->b_addr;
 }

diff --git a/fs/xfs/libxfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index 28eb66acf9ad33e2dfe3f39751b01ab02117acfe..8d2718e358cdf46f40829aa9ddf1a4e0bdd74dfb 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -295,7 +295,7 @@ xfs_allocbt_verify(
        if (!xfs_verify_magic(bp, block->bb_magic))
                return __this_address;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                fa = xfs_btree_sblock_v5hdr_verify(bp);
                if (fa)
                        return fa;

diff --git a/fs/xfs/libxfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index 098ff59c4500561648d59b5c7e3764d0976e145a..9366876de5941e45a29500ed7b5271c38134371c 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -428,7 +428,7 @@ xfs_bmbt_verify(
        if (!xfs_verify_magic(bp, block->bb_magic))
                return __this_address;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                /*
                 * XXX: need a better way of verifying the owner here. Right now
                 * just make sure there has been one set.

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index 0c1e96dcd2ba7384172299cf2b0175f84bf114cd..86c061fa82fe4ba6dd7cb0cb202ab9a771e6d99a 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -273,7 +273,7 @@ xfs_btree_lblock_calc_crc(
        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
        struct xfs_buf_log_item *bip = bp->b_log_item;
 
-       if (!xfs_sb_version_hascrc(&bp->b_mount->m_sb))
+       if (!xfs_has_crc(bp->b_mount))
                return;
        if (bip)
                block->bb_u.l.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn);
@@ -311,7 +311,7 @@ xfs_btree_sblock_calc_crc(
        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
        struct xfs_buf_log_item *bip = bp->b_log_item;
 
-       if (!xfs_sb_version_hascrc(&bp->b_mount->m_sb))
+       if (!xfs_has_crc(bp->b_mount))
                return;
        if (bip)
                block->bb_u.s.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn);
@@ -1749,7 +1749,7 @@ xfs_btree_lookup_get_block(
                return error;
 
        /* Check the inode owner since the verifiers don't. */
-       if (xfs_sb_version_hascrc(&cur->bc_mp->m_sb) &&
+       if (xfs_has_crc(cur->bc_mp) &&
            !(cur->bc_ino.flags & XFS_BTCUR_BMBT_INVALID_OWNER) &&
            (cur->bc_flags & XFS_BTREE_LONG_PTRS) &&
            be64_to_cpu((*blkp)->bb_u.l.bb_owner) !=

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 0a8cde1fbe0d98b6127241272c41bbbe1a66f5fa..99f81f6bb30689f9c267a8e72b4a3ad83e7d75f3 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -129,7 +129,7 @@ xfs_da3_node_hdr_from_disk(
        struct xfs_da3_icnode_hdr       *to,
        struct xfs_da_intnode           *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_da3_intnode  *from3 = (struct xfs_da3_intnode *)from;
 
                to->forw = be32_to_cpu(from3->hdr.info.hdr.forw);
@@ -156,7 +156,7 @@ xfs_da3_node_hdr_to_disk(
        struct xfs_da_intnode           *to,
        struct xfs_da3_icnode_hdr       *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_da3_intnode  *to3 = (struct xfs_da3_intnode *)to;
 
                ASSERT(from->magic == XFS_DA3_NODE_MAGIC);
@@ -191,7 +191,7 @@ xfs_da3_blkinfo_verify(
        if (!xfs_verify_magic16(bp, hdr->magic))
                return __this_address;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
                if (be64_to_cpu(hdr3->blkno) != bp->b_bn)

diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 050bdcc4fe7376033161b1178c6d629207849de2..50546eadaae2515f6ead424a36c55f7f0871a701 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -115,7 +115,7 @@ xfs_da_mount(
        dageo->fsblog = mp->m_sb.sb_blocklog;
        dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb);
        dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog;
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr);
                dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr);
                dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr);
@@ -730,7 +730,7 @@ xfs_dir2_hashname(
        struct xfs_mount        *mp,
        struct xfs_name         *name)
 {
-       if (unlikely(xfs_sb_version_hasasciici(&mp->m_sb)))
+       if (unlikely(xfs_has_asciici(mp)))
                return xfs_ascii_ci_hashname(name);
        return xfs_da_hashname(name->name, name->len);
 }
@@ -741,7 +741,7 @@ xfs_dir2_compname(
        const unsigned char     *name,
        int                     len)
 {
-       if (unlikely(xfs_sb_version_hasasciici(&args->dp->i_mount->m_sb)))
+       if (unlikely(xfs_has_asciici(args->dp->i_mount)))
                return xfs_ascii_ci_compname(args, name, len);
        return xfs_da_compname(args, name, len);
 }

diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index 49e61ca1045bc289c801e786165658875611887f..41e406067f91571292d8a4ad3bf6f5553bae3104 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -53,7 +53,7 @@ xfs_dir3_block_verify(
        if (!xfs_verify_magic(bp, hdr3->magic))
                return __this_address;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
                if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
@@ -121,7 +121,7 @@ xfs_dir3_block_header_check(
 {
        struct xfs_mount        *mp = dp->i_mount;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
                if (be64_to_cpu(hdr3->owner) != dp->i_ino)

diff --git a/fs/xfs/libxfs/xfs_dir2_data.c b/fs/xfs/libxfs/xfs_dir2_data.c
index 920bd13512a8a2b04994221903b2d5eda8c2a2f9..c90180f2ba5c4db4034c0115f1b1eb3a4ac482fb 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_data.c
+++ b/fs/xfs/libxfs/xfs_dir2_data.c
@@ -29,7 +29,7 @@ xfs_dir2_data_bestfree_p(
        struct xfs_mount                *mp,
        struct xfs_dir2_data_hdr        *hdr)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb))
+       if (xfs_has_crc(mp))
                return ((struct xfs_dir3_data_hdr *)hdr)->best_free;
        return hdr->bestfree;
 }
@@ -51,7 +51,7 @@ xfs_dir2_data_get_ftype(
        struct xfs_mount                *mp,
        struct xfs_dir2_data_entry      *dep)
 {
-       if (xfs_sb_version_hasftype(&mp->m_sb)) {
+       if (xfs_has_ftype(mp)) {
                uint8_t                 ftype = dep->name[dep->namelen];
 
                if (likely(ftype < XFS_DIR3_FT_MAX))
@@ -70,7 +70,7 @@ xfs_dir2_data_put_ftype(
        ASSERT(ftype < XFS_DIR3_FT_MAX);
        ASSERT(dep->namelen != 0);
 
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                dep->name[dep->namelen] = ftype;
 }
 
@@ -297,7 +297,7 @@ xfs_dir3_data_verify(
        if (!xfs_verify_magic(bp, hdr3->magic))
                return __this_address;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
                if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
@@ -401,7 +401,7 @@ xfs_dir3_data_header_check(
 {
        struct xfs_mount        *mp = dp->i_mount;
 
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_data_hdr *hdr3 = bp->b_addr;
 
                if (be64_to_cpu(hdr3->hdr.owner) != dp->i_ino)

diff --git a/fs/xfs/libxfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index 40ac411acf03701ea9e7b81969ab34683b066c0a..d03db9cde2719a34cdd5ece3e8548a8e7b7eb1ca 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -37,7 +37,7 @@ xfs_dir2_leaf_hdr_from_disk(
        struct xfs_dir3_icleaf_hdr      *to,
        struct xfs_dir2_leaf            *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_leaf *from3 = (struct xfs_dir3_leaf *)from;
 
                to->forw = be32_to_cpu(from3->hdr.info.hdr.forw);
@@ -68,7 +68,7 @@ xfs_dir2_leaf_hdr_to_disk(
        struct xfs_dir2_leaf            *to,
        struct xfs_dir3_icleaf_hdr      *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_leaf *to3 = (struct xfs_dir3_leaf *)to;
 
                ASSERT(from->magic == XFS_DIR3_LEAF1_MAGIC ||

diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index a2ee1d48519c4ebb8c48680bdc212f8d57a5c448..fbd2de8b3cf28f61d5aa2fb72d59dd0adccc1973 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -247,7 +247,7 @@ xfs_dir2_free_hdr_from_disk(
        struct xfs_dir3_icfree_hdr      *to,
        struct xfs_dir2_free            *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_free    *from3 = (struct xfs_dir3_free *)from;
 
                to->magic = be32_to_cpu(from3->hdr.hdr.magic);
@@ -274,7 +274,7 @@ xfs_dir2_free_hdr_to_disk(
        struct xfs_dir2_free            *to,
        struct xfs_dir3_icfree_hdr      *from)
 {
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                struct xfs_dir3_free    *to3 = (struct xfs_dir3_free *)to;
 
                ASSERT(from->magic == XFS_DIR3_FREE_MAGIC);

diff --git a/fs/xfs/libxfs/xfs_dir2_priv.h b/fs/xfs/libxfs/xfs_dir2_priv.h
index 94943ce49cab0198c42ab26c68f2e771fa125b27..711709a2aa53cdf6a73e37023bfe0860370e7f30 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_priv.h
+++ b/fs/xfs/libxfs/xfs_dir2_priv.h
@@ -196,7 +196,7 @@ xfs_dir2_data_entsize(
 
        len = offsetof(struct xfs_dir2_data_entry, name[0]) + namelen +
                        sizeof(xfs_dir2_data_off_t) /* tag */;
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                len += sizeof(uint8_t);
        return round_up(len, XFS_DIR2_DATA_ALIGN);
 }

diff --git a/fs/xfs/libxfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index 1afe09910bee15524bc8221ad404b27195639127..5a97a87eaa20db5cdf047ed4053942211ddd3c27 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -48,7 +48,7 @@ xfs_dir2_sf_entsize(
        count += sizeof(struct xfs_dir2_sf_entry);      /* namelen + offset */
        count += hdr->i8count ? XFS_INO64_SIZE : XFS_INO32_SIZE; /* ino # */
 
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                count += sizeof(uint8_t);
        return count;
 }
@@ -76,7 +76,7 @@ xfs_dir2_sf_get_ino(
 {
        uint8_t                         *from = sfep->name + sfep->namelen;
 
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                from++;
 
        if (!hdr->i8count)
@@ -95,7 +95,7 @@ xfs_dir2_sf_put_ino(
 
        ASSERT(ino <= XFS_MAXINUMBER);
 
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                to++;
 
        if (hdr->i8count)
@@ -135,7 +135,7 @@ xfs_dir2_sf_get_ftype(
        struct xfs_mount                *mp,
        struct xfs_dir2_sf_entry        *sfep)
 {
-       if (xfs_sb_version_hasftype(&mp->m_sb)) {
+       if (xfs_has_ftype(mp)) {
                uint8_t                 ftype = sfep->name[sfep->namelen];
 
                if (ftype < XFS_DIR3_FT_MAX)
@@ -153,7 +153,7 @@ xfs_dir2_sf_put_ftype(
 {
        ASSERT(ftype < XFS_DIR3_FT_MAX);
 
-       if (xfs_sb_version_hasftype(&mp->m_sb))
+       if (xfs_has_ftype(mp))
                sfep->name[sfep->namelen] = ftype;
 }
 

diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index edd0f413f03014290a580084e14785bb8c8ffeb4..deeb74becabc72845b9802ce120b4e295ea86034 100644 (file)
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -70,7 +70,7 @@ xfs_dquot_verify(
                return __this_address;
 
        if ((ddq->d_type & XFS_DQTYPE_BIGTIME) &&
-           !xfs_sb_version_hasbigtime(&mp->m_sb))
+           !xfs_has_bigtime(mp))
                return __this_address;
 
        if ((ddq->d_type & XFS_DQTYPE_BIGTIME) && !ddq->d_id)

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 61f94e24d5db6178e9346cf2ea4725e17b0be853..58dcac44237e3a7c3490f63388864bc8df049797 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -302,7 +302,7 @@ xfs_ialloc_inode_init(
         * That means for v3 inode we log the entire buffer rather than just the
         * inode cores.
         */
-       if (xfs_sb_version_has_v3inode(&mp->m_sb)) {
+       if (xfs_has_v3inodes(mp)) {
                version = 3;
                ino = XFS_AGINO_TO_INO(mp, agno, XFS_AGB_TO_AGINO(mp, agbno));
 
@@ -635,7 +635,7 @@ xfs_ialloc_ag_alloc(
 
 #ifdef DEBUG
        /* randomly do sparse inode allocations */
-       if (xfs_sb_version_hassparseinodes(&tp->t_mountp->m_sb) &&
+       if (xfs_has_sparseinodes(tp->t_mountp) &&
            igeo->ialloc_min_blks < igeo->ialloc_blks)
                do_sparse = prandom_u32() & 1;
 #endif
@@ -754,7 +754,7 @@ xfs_ialloc_ag_alloc(
         * Finally, try a sparse allocation if the filesystem supports it and
         * the sparse allocation length is smaller than a full chunk.
         */
-       if (xfs_sb_version_hassparseinodes(&args.mp->m_sb) &&
+       if (xfs_has_sparseinodes(args.mp) &&
            igeo->ialloc_min_blks < igeo->ialloc_blks &&
            args.fsbno == NULLFSBLOCK) {
 sparse_alloc:
@@ -856,7 +856,7 @@ sparse_alloc:
                 * from the previous call. Set merge false to replace any
                 * existing record with this one.
                 */
-               if (xfs_sb_version_hasfinobt(&args.mp->m_sb)) {
+               if (xfs_has_finobt(args.mp)) {
                        error = xfs_inobt_insert_sprec(args.mp, tp, agbp, pag,
                                       XFS_BTNUM_FINO, &rec, false);
                        if (error)
@@ -869,7 +869,7 @@ sparse_alloc:
                if (error)
                        return error;
 
-               if (xfs_sb_version_hasfinobt(&args.mp->m_sb)) {
+               if (xfs_has_finobt(args.mp)) {
                        error = xfs_inobt_insert(args.mp, tp, agbp, pag, newino,
                                                 newlen, XFS_BTNUM_FINO);
                        if (error)
@@ -1448,7 +1448,7 @@ xfs_dialloc_ag(
        int                             offset;
        int                             i;
 
-       if (!xfs_sb_version_hasfinobt(&mp->m_sb))
+       if (!xfs_has_finobt(mp))
                return xfs_dialloc_ag_inobt(tp, agbp, pag, parent, inop);
 
        /*
@@ -2187,7 +2187,7 @@ xfs_difree(
        /*
         * Fix up the free inode btree.
         */
-       if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
+       if (xfs_has_finobt(mp)) {
                error = xfs_difree_finobt(mp, tp, agbp, pag, agino, &rec);
                if (error)
                        goto error0;
@@ -2771,7 +2771,7 @@ xfs_ialloc_setup_geometry(
        uint                    inodes;
 
        igeo->new_diflags2 = 0;
-       if (xfs_sb_version_hasbigtime(&mp->m_sb))
+       if (xfs_has_bigtime(mp))
                igeo->new_diflags2 |= XFS_DIFLAG2_BIGTIME;
 
        /* Compute inode btree geometry. */
@@ -2826,7 +2826,7 @@ xfs_ialloc_setup_geometry(
         * cannot change the behavior.
         */
        igeo->inode_cluster_size_raw = XFS_INODE_BIG_CLUSTER_SIZE;
-       if (xfs_sb_version_has_v3inode(&mp->m_sb)) {
+       if (xfs_has_v3inodes(mp)) {
                int     new_size = igeo->inode_cluster_size_raw;
 
                new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
@@ -2844,7 +2844,7 @@ xfs_ialloc_setup_geometry(
        igeo->inodes_per_cluster = XFS_FSB_TO_INO(mp, igeo->blocks_per_cluster);
 
        /* Calculate inode cluster alignment. */
-       if (xfs_sb_version_hasalign(&mp->m_sb) &&
+       if (xfs_has_align(mp) &&
            mp->m_sb.sb_inoalignmt >= igeo->blocks_per_cluster)
                igeo->cluster_align = mp->m_sb.sb_inoalignmt;
        else
@@ -2892,15 +2892,15 @@ xfs_ialloc_calc_rootino(
        first_bno += xfs_alloc_min_freelist(mp, NULL);
 
        /* ...the free inode btree root... */
-       if (xfs_sb_version_hasfinobt(&mp->m_sb))
+       if (xfs_has_finobt(mp))
                first_bno++;
 
        /* ...the reverse mapping btree root... */
-       if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+       if (xfs_has_rmapbt(mp))
                first_bno++;
 
        /* ...the reference count btree... */
-       if (xfs_sb_version_hasreflink(&mp->m_sb))
+       if (xfs_has_reflink(mp))
                first_bno++;
 
        /*
@@ -2918,9 +2918,9 @@ xfs_ialloc_calc_rootino(
         * Now round first_bno up to whatever allocation alignment is given
         * by the filesystem or was passed in.
         */
-       if (xfs_sb_version_hasdalign(&mp->m_sb) && igeo->ialloc_align > 0)
+       if (xfs_has_dalign(mp) && igeo->ialloc_align > 0)
                first_bno = roundup(first_bno, sunit);
-       else if (xfs_sb_version_hasalign(&mp->m_sb) &&
+       else if (xfs_has_align(mp) &&
                        mp->m_sb.sb_inoalignmt > 1)
                first_bno = roundup(first_bno, mp->m_sb.sb_inoalignmt);
 

diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 4b411ced15fa488d68ce2481201d4c68373a675f..62e3c6c8da339c66f36ff844f5e90119e7fc8621 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -76,7 +76,7 @@ xfs_inobt_mod_blockcount(
        struct xfs_buf          *agbp = cur->bc_ag.agbp;
        struct xfs_agi          *agi = agbp->b_addr;
 
-       if (!xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb))
+       if (!xfs_has_inobtcounts(cur->bc_mp))
                return;
 
        if (cur->bc_btnum == XFS_BTNUM_FINO)
@@ -292,7 +292,7 @@ xfs_inobt_verify(
         * but beware of the landmine (i.e. need to check pag->pagi_init) if we
         * ever do.
         */
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+       if (xfs_has_crc(mp)) {
                fa = xfs_btree_sblock_v5hdr_verify(bp);
                if (fa)
                        return fa;
@@ -511,7 +511,7 @@ xfs_inobt_commit_staged_btree(
                fields = XFS_AGI_ROOT | XFS_AGI_LEVEL;
                agi->agi_root = cpu_to_be32(afake->af_root);
                agi->agi_level = cpu_to_be32(afake->af_levels);
-               if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
+               if (xfs_has_inobtcounts(cur->bc_mp)) {
                        agi->agi_iblocks = cpu_to_be32(afake->af_blocks);
                        fields |= XFS_AGI_IBLOCKS;
                }
@@ -521,7 +521,7 @@ xfs_inobt_commit_staged_btree(
                fields = XFS_AGI_FREE_ROOT | XFS_AGI_FREE_LEVEL;
                agi->agi_free_root = cpu_to_be32(afake->af_root);
                agi->agi_free_level = cpu_to_be32(afake->af_levels);
-               if (xfs_sb_version_hasinobtcounts(&cur->bc_mp->m_sb)) {
+               if (xfs_has_inobtcounts(cur->bc_mp)) {
                        agi->agi_fblocks = cpu_to_be32(afake->af_blocks);
                        fields |= XFS_AGI_IBLOCKS;
                }
@@ -740,7 +740,7 @@ xfs_finobt_calc_reserves(
        if (!xfs_has_finobt(mp))
                return 0;
 
-       if (xfs_sb_version_hasinobtcounts(&mp->m_sb))
+       if (xfs_has_inobtcounts(mp))
                error = xfs_finobt_read_blocks(mp, tp, pag, &tree_len);
        else
                error = xfs_inobt_count_blocks(mp, tp, pag, XFS_BTNUM_FINO,

diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 698af856a7f73a3688ae5ae20d2d2d46841d25ba..fefecdf3f632249b327aa9c0c546dfb9608982fd 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -192,7 +192,7 @@ xfs_inode_from_disk(
         * inode. If the inode is unused, mode is zero and we shouldn't mess
         * with the uninitialized part of it.
         */
-       if (!xfs_sb_version_has_v3inode(&ip->i_mount->m_sb))
+       if (!xfs_has_v3inodes(ip->i_mount))
                ip->i_flushiter = be16_to_cpu(from->di_flushiter);
        inode->i_generation = be32_to_cpu(from->di_gen);
        inode->i_mode = be16_to_cpu(from->di_mode);
@@ -235,7 +235,7 @@ xfs_inode_from_disk(
        if (from->di_dmevmask || from->di_dmstate)
                xfs_iflags_set(ip, XFS_IPRESERVE_DM_FIELDS);
 
-       if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) {
+       if (xfs_has_v3inodes(ip->i_mount)) {
                inode_set_iversion_queried(inode,
                                           be64_to_cpu(from->di_changecount));
                ip->i_crtime = xfs_inode_from_disk_ts(from, from->di_crtime);
@@ -313,7 +313,7 @@ xfs_inode_to_disk(
        to->di_aformat = xfs_ifork_format(ip->i_afp);
        to->di_flags = cpu_to_be16(ip->i_diflags);
 
-       if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) {
+       if (xfs_has_v3inodes(ip->i_mount)) {
                to->di_version = 3;
                to->di_changecount = cpu_to_be64(inode_peek_iversion(inode));
                to->di_crtime = xfs_inode_to_disk_ts(ip, ip->i_crtime);
@@ -413,7 +413,7 @@ xfs_dinode_verify(
 
        /* Verify v3 integrity information first */
        if (dip->di_version >= 3) {
-               if (!xfs_sb_version_has_v3inode(&mp->m_sb))
+               if (!xfs_has_v3inodes(mp))
                        return __this_address;
                if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize,
                                      XFS_DINODE_CRC_OFF))
@@ -534,7 +534,7 @@ xfs_dinode_verify(
 
        /* bigtime iflag can only happen on bigtime filesystems */
        if (xfs_dinode_has_bigtime(dip) &&
-           !xfs_sb_version_hasbigtime(&mp->m_sb))
+           !xfs_has_bigtime(mp))
                return __this_address;
 
        return NULL;

diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
index 28c020472f9a05595c5283da259d99e052073ec6..b322db523d65c849fc7bee35f0df1f9c37e81126 100644 (file)
--- a/fs/xfs/libxfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -434,7 +434,7 @@ struct xfs_log_dinode {
 };
 
 #define xfs_log_dinode_size(mp)                                                \
-       (xfs_sb_version_has_v3inode(&(mp)->m_sb) ?                      \
+       (xfs_has_v3inodes((mp)) ?                                       \
                sizeof(struct xfs_log_dinode) :                         \
                offsetof(struct xfs_log_dinode, di_next_unlinked))
 

diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index 5f46dbe8c8d966606ba2fbd6c2120da31ebc8de3..e5d767a7fc5d24cd9f1337ca55e0a9895077f108 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -1253,7 +1253,7 @@ xfs_refcount_increase_extent(
        struct xfs_trans                *tp,
        struct xfs_bmbt_irec            *PREV)
 {
-       if (!xfs_sb_version_hasreflink(&tp->t_mountp->m_sb))
+       if (!xfs_has_reflink(tp->t_mountp))
                return;
 
        __xfs_refcount_add(tp, XFS_REFCOUNT_INCREASE, PREV->br_startblock,
@@ -1268,7 +1268,7 @@ xfs_refcount_decrease_extent(
        struct xfs_trans                *tp,
        struct xfs_bmbt_irec            *PREV)
 {
-       if (!xfs_sb_version_hasreflink(&tp->t_mountp->m_sb))
+       if (!xfs_has_reflink(tp->t_mountp))
                return;
 
        __xfs_refcount_add(tp, XFS_REFCOUNT_DECREASE, PREV->br_startblock,
@@ -1617,7 +1617,7 @@ xfs_refcount_alloc_cow_extent(
 {
        struct xfs_mount                *mp = tp->t_mountp;
 
-       if (!xfs_sb_version_hasreflink(&mp->m_sb))
+       if (!xfs_has_reflink(mp))
                return;
 
        __xfs_refcount_add(tp, XFS_REFCOUNT_ALLOC_COW, fsb, len);
@@ -1636,7 +1636,7 @@ xfs_refcount_free_cow_extent(
 {
        struct xfs_mount                *mp = tp->t_mountp;
 
-       if (!xfs_sb_version_hasreflink(&mp->m_sb))
+       if (!xfs_has_reflink(mp))
                return;
 
        /* Remove rmap entry */

diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 0455c3fa706fce0968ccaaa9c6e930b78e17cec6..e2b50f5e9f3563fc7668e313e17d2ba08f330794 100644 (file)
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -911,7 +911,7 @@ xfs_log_sb(
         * unclean shutdown, this will be corrected by log recovery rebuilding
         * the counters from the AGF block counts.
         */
-       if (xfs_sb_version_haslazysbcount(&mp->m_sb)) {
+       if (xfs_has_lazysbcount(mp)) {
                mp->m_sb.sb_icount = percpu_counter_sum(&mp->m_icount);
                mp->m_sb.sb_ifree = percpu_counter_sum(&mp->m_ifree);
                mp->m_sb.sb_fdblocks = percpu_counter_sum(&mp->m_fdblocks);

diff --git a/fs/xfs/libxfs/xfs_trans_inode.c b/fs/xfs/libxfs/xfs_trans_inode.c
index 16f723ebe8dda95b0562e3659597f99bba5845fd..8b55470733791d9916ff57679833df8a97bf108a 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_inode.c
+++ b/fs/xfs/libxfs/xfs_trans_inode.c
@@ -136,7 +136,7 @@ xfs_trans_log_inode(
         * to upgrade this inode to bigtime format, do so now.
         */
        if ((flags & (XFS_ILOG_CORE | XFS_ILOG_TIMESTAMP)) &&
-           xfs_sb_version_hasbigtime(&ip->i_mount->m_sb) &&
+           xfs_has_bigtime(ip->i_mount) &&
            !xfs_inode_has_bigtime(ip)) {
                ip->i_diflags2 |= XFS_DIFLAG2_BIGTIME;
                flags |= XFS_ILOG_CORE;

diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index 99df706fe2b9bc91ce85d2f2a7fe05ca71b8e210..5e300daa255931532915905270506a0948d70e80 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -187,7 +187,7 @@ xfs_calc_inode_chunk_res(
                               XFS_FSB_TO_B(mp, 1));
        if (alloc) {
                /* icreate tx uses ordered buffers */
-               if (xfs_sb_version_has_v3inode(&mp->m_sb))
+               if (xfs_has_v3inodes(mp))
                        return res;
                size = XFS_FSB_TO_B(mp, 1);
        }
@@ -268,7 +268,7 @@ xfs_calc_write_reservation(
             xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
             xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2), blksz);
 
-       if (xfs_sb_version_hasrealtime(&mp->m_sb)) {
+       if (xfs_has_realtime(mp)) {
                t2 = xfs_calc_inode_res(mp, 1) +
                     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
                                     blksz) +
@@ -317,7 +317,7 @@ xfs_calc_itruncate_reservation(
        t2 = xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
             xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4), blksz);
 
-       if (xfs_sb_version_hasrealtime(&mp->m_sb)) {
+       if (xfs_has_realtime(mp)) {
                t3 = xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
                     xfs_calc_buf_res(xfs_rtalloc_log_count(mp, 2), blksz) +
                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2), blksz);

diff --git a/fs/xfs/libxfs/xfs_trans_space.h b/fs/xfs/libxfs/xfs_trans_space.h
index 7ad3659c5d2a9fc6edd38affbb6ab03c17fcbbac..50332be343881e88c8211087741450ae480efd9b 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_space.h
+++ b/fs/xfs/libxfs/xfs_trans_space.h
@@ -57,8 +57,7 @@
        XFS_DAREMOVE_SPACE_RES(mp, XFS_DATA_FORK)
 #define        XFS_IALLOC_SPACE_RES(mp)        \
        (M_IGEO(mp)->ialloc_blks + \
-        ((xfs_sb_version_hasfinobt(&mp->m_sb) ? 2 : 1) * \
-         M_IGEO(mp)->inobt_maxlevels))
+        ((xfs_has_finobt(mp) ? 2 : 1) * M_IGEO(mp)->inobt_maxlevels))
 
 /*
  * Space reservation values for various transactions.
@@ -94,8 +93,7 @@
 #define        XFS_SYMLINK_SPACE_RES(mp,nl,b)  \
        (XFS_IALLOC_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl) + (b))
 #define XFS_IFREE_SPACE_RES(mp)                \
-       (xfs_sb_version_hasfinobt(&mp->m_sb) ? \
-                       M_IGEO(mp)->inobt_maxlevels : 0)
+       (xfs_has_finobt(mp) ? M_IGEO(mp)->inobt_maxlevels : 0)
 
 
 #endif /* __XFS_TRANS_SPACE_H__ */

diff --git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
index 9210461a4d64c3bb1cf7eefb58ddf8f2396983ac..16a5c8fe8db48a2dc62d10e37ac0a8d785ca27a4 100644 (file)
--- a/fs/xfs/scrub/agheader.c
+++ b/fs/xfs/scrub/agheader.c
@@ -430,7 +430,7 @@ xchk_agf_xref_btreeblks(
        int                     error;
 
        /* agf_btreeblks didn't exist before lazysbcount */
-       if (!xfs_sb_version_haslazysbcount(&sc->mp->m_sb))
+       if (!xfs_has_lazysbcount(sc->mp))
                return;
 
        /* Check agf_rmap_blocks; set up for agf_btreeblks check */
@@ -598,7 +598,7 @@ xchk_agf(
                xchk_block_set_corrupt(sc, sc->sa.agf_bp);
        if (pag->pagf_flcount != be32_to_cpu(agf->agf_flcount))
                xchk_block_set_corrupt(sc, sc->sa.agf_bp);
-       if (xfs_sb_version_haslazysbcount(&sc->mp->m_sb) &&
+       if (xfs_has_lazysbcount(sc->mp) &&
            pag->pagf_btreeblks != be32_to_cpu(agf->agf_btreeblks))
                xchk_block_set_corrupt(sc, sc->sa.agf_bp);
 
@@ -797,7 +797,7 @@ xchk_agi_xref_fiblocks(
        xfs_agblock_t           blocks;
        int                     error = 0;
 
-       if (!xfs_sb_version_hasinobtcounts(&sc->mp->m_sb))
+       if (!xfs_has_inobtcounts(sc->mp))
                return;
 
        if (sc->sa.ino_cur) {

diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
index fefc059fc6066266c8b14837cf62b0a4b9d15909..0f8deee66f15d4fc3c081a1a4ea48ecb00a601d5 100644 (file)
--- a/fs/xfs/scrub/agheader_repair.c
+++ b/fs/xfs/scrub/agheader_repair.c
@@ -816,7 +816,7 @@ xrep_agi_calc_from_btrees(
        error = xfs_ialloc_count_inodes(cur, &count, &freecount);
        if (error)
                goto err;
-       if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+       if (xfs_has_inobtcounts(mp)) {
                xfs_agblock_t   blocks;
 
                error = xfs_btree_count_blocks(cur, &blocks);
@@ -829,8 +829,7 @@ xrep_agi_calc_from_btrees(
        agi->agi_count = cpu_to_be32(count);
        agi->agi_freecount = cpu_to_be32(freecount);
 
-       if (xfs_sb_version_hasfinobt(&mp->m_sb) &&
-           xfs_sb_version_hasinobtcounts(&mp->m_sb)) {
+       if (xfs_has_finobt(mp) && xfs_has_inobtcounts(mp)) {
                xfs_agblock_t   blocks;
 
                cur = xfs_inobt_init_cursor(mp, sc->tp, agi_bp,

diff --git a/fs/xfs/scrub/bmap.c b/fs/xfs/scrub/bmap.c
index e5fc740fe75840f39fd627affbda1be49b992958..2df5e5a51cbd5cfda3b7cce7ccf820b0c5ef4b80 100644 (file)
--- a/fs/xfs/scrub/bmap.c
+++ b/fs/xfs/scrub/bmap.c
@@ -662,8 +662,7 @@ xchk_bmap(
                }
                break;
        case XFS_ATTR_FORK:
-               if (!xfs_sb_version_hasattr(&mp->m_sb) &&
-                   !xfs_sb_version_hasattr2(&mp->m_sb))
+               if (!xfs_has_attr(mp) && !xfs_has_attr2(mp))
                        xchk_ino_set_corrupt(sc, sc->ip->i_ino);
                break;
        default:

diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
index 562e1075129668d89741ded18fccd19896f2d36b..2f67b7dc5ee3df28f59023e8b6f4d786218eadea 100644 (file)
--- a/fs/xfs/scrub/common.c
+++ b/fs/xfs/scrub/common.c
@@ -485,21 +485,21 @@ xchk_ag_btcur_init(
        }
 
        /* Set up a finobt cursor for cross-referencing. */
-       if (sa->agi_bp && xfs_sb_version_hasfinobt(&mp->m_sb) &&
+       if (sa->agi_bp && xfs_has_finobt(mp) &&
            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_FINO)) {
                sa->fino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
                                sa->pag, XFS_BTNUM_FINO);
        }
 
        /* Set up a rmapbt cursor for cross-referencing. */
-       if (sa->agf_bp && xfs_sb_version_hasrmapbt(&mp->m_sb) &&
+       if (sa->agf_bp && xfs_has_rmapbt(mp) &&
            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_RMAP)) {
                sa->rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, sa->agf_bp,
                                sa->pag);
        }
 
        /* Set up a refcountbt cursor for cross-referencing. */
-       if (sa->agf_bp && xfs_sb_version_hasreflink(&mp->m_sb) &&
+       if (sa->agf_bp && xfs_has_reflink(mp) &&
            xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_REFC)) {
                sa->refc_cur = xfs_refcountbt_init_cursor(mp, sc->tp,
                                sa->agf_bp, sa->pag);

diff --git a/fs/xfs/scrub/fscounters.c b/fs/xfs/scrub/fscounters.c
index b88ee69625d4f56fde814565555b321eab19168d..737aa5b39d5e6fb769a05b096d914d0926f800b0 100644 (file)
--- a/fs/xfs/scrub/fscounters.c
+++ b/fs/xfs/scrub/fscounters.c
@@ -207,7 +207,7 @@ retry:
                /* Add up the free/freelist/bnobt/cntbt blocks */
                fsc->fdblocks += pag->pagf_freeblks;
                fsc->fdblocks += pag->pagf_flcount;
-               if (xfs_sb_version_haslazysbcount(&sc->mp->m_sb)) {
+               if (xfs_has_lazysbcount(sc->mp)) {
                        fsc->fdblocks += pag->pagf_btreeblks;
                } else {
                        error = xchk_fscount_btreeblks(sc, fsc, agno);

diff --git a/fs/xfs/scrub/inode.c b/fs/xfs/scrub/inode.c
index a8703278e1685fa3427569a538ad8ba59bc86e62..d6e0e3a11fbcedced3e2f48f14c108758550ffa5 100644 (file)
--- a/fs/xfs/scrub/inode.c
+++ b/fs/xfs/scrub/inode.c
@@ -199,8 +199,7 @@ xchk_inode_flags2(
                goto bad;
 
        /* no bigtime iflag without the bigtime feature */
-       if (xfs_dinode_has_bigtime(dip) &&
-           !xfs_sb_version_hasbigtime(&mp->m_sb))
+       if (xfs_dinode_has_bigtime(dip) && !xfs_has_bigtime(mp))
                goto bad;
 
        return;

diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 3cccd6d5b5775589691ccd7b45eaf53af61462a9..d6c1b00a4fc8ca88b185bfd09e3c3b47a06fb9d2 100644 (file)
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -127,7 +127,7 @@ xchk_quota_item(
         * a reflink filesystem we're allowed to exceed physical space
         * if there are no quota limits.
         */
-       if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+       if (xfs_has_reflink(mp)) {
                if (mp->m_sb.sb_dblocks < dq->q_blk.count)
                        xchk_fblock_set_warning(sc, XFS_DATA_FORK,
                                        offset);

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 3e0fc7270e41f0b6a282a79e6db7dc656bd2ac1d..06dac09eddbd8004f935d678b15c90dd184aeb12 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1320,7 +1320,7 @@ xfs_clear_incompat_log_features(
 {
        bool                    ret = false;
 
-       if (!xfs_sb_version_hascrc(&mp->m_sb) ||
+       if (!xfs_has_crc(mp) ||
            !xfs_sb_has_incompat_log_feature(&mp->m_sb,
                                XFS_SB_FEAT_INCOMPAT_LOG_ALL) ||
            xfs_is_shutdown(mp))

diff --git a/fs/xfs/xfs_reflink.h b/fs/xfs/xfs_reflink.h
index 487b00434b962b7980d383651c11ba825548a35a..bea65f2fe657687cb954c998b9275aeb1a430837 100644 (file)
--- a/fs/xfs/xfs_reflink.h
+++ b/fs/xfs/xfs_reflink.h
@@ -8,8 +8,7 @@
 
 static inline bool xfs_is_always_cow_inode(struct xfs_inode *ip)
 {
-       return ip->i_mount->m_always_cow &&
-               xfs_sb_version_hasreflink(&ip->i_mount->m_sb);
+       return ip->i_mount->m_always_cow && xfs_has_reflink(ip->i_mount);
 }
 
 static inline bool xfs_is_cow_inode(struct xfs_inode *ip)

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index db1bc7441de30241708831985c0ff1bdba9bd394..cf5a3d936830c3c2657d01d6bc96376ba5ad5c49 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1496,7 +1496,7 @@ xfs_fs_fill_super(
        }
 
        /* Filesystem claims it needs repair, so refuse the mount. */
-       if (xfs_sb_version_needsrepair(&mp->m_sb)) {
+       if (xfs_has_needsrepair(mp)) {
                xfs_warn(mp, "Filesystem needs repair.  Please run xfs_repair.");
                error = -EFSCORRUPTED;
                goto out_free_sb;