xfs: introduce xfs_buf_daddr()

Introduce a helper function xfs_buf_daddr() to extract the disk
address of the buffer from the struct xfs_buf. This will replace
direct accesses to bp->b_bn and bp->b_maps[0].bm_bn, as well as
the XFS_BUF_ADDR() macro.

This patch introduces the helper function and replaces all uses of
XFS_BUF_ADDR() as this is just a simple sed replacement.

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

diff --git a/fs/xfs/libxfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index 8d2718e358cdf46f40829aa9ddf1a4e0bdd74dfb..6746fd735550dd01e6e05fbf9a985cb7d683d462 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -87,7 +87,7 @@ xfs_allocbt_free_block(
        xfs_agblock_t           bno;
        int                     error;
 
-       bno = xfs_daddr_to_agbno(cur->bc_mp, XFS_BUF_ADDR(bp));
+       bno = xfs_daddr_to_agbno(cur->bc_mp, xfs_buf_daddr(bp));
        error = xfs_alloc_put_freelist(cur->bc_tp, agbp, NULL, bno, 1);
        if (error)
                return error;

diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 23b50bcb5e7fdf7974b3eb1c0fccc7b566d9db7f..fbc9d816882ce64269fea3d8d915554da2182929 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -1540,7 +1540,7 @@ xfs_attr_fillstate(xfs_da_state_t *state)
        ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
        for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
                if (blk->bp) {
-                       blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
+                       blk->disk_blkno = xfs_buf_daddr(blk->bp);
                        blk->bp = NULL;
                } else {
                        blk->disk_blkno = 0;
@@ -1555,7 +1555,7 @@ xfs_attr_fillstate(xfs_da_state_t *state)
        ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
        for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
                if (blk->bp) {
-                       blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
+                       blk->disk_blkno = xfs_buf_daddr(blk->bp);
                        blk->bp = NULL;
                } else {
                        blk->disk_blkno = 0;

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 75354023cea7e2703ccd519114cb489e6e6ac5a6..d0bfa9a1f549ecf8b9329a494d40cb3d490162ed 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -242,7 +242,7 @@ xfs_bmap_get_bp(
        for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) {
                if (!cur->bc_bufs[i])
                        break;
-               if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno)
+               if (xfs_buf_daddr(cur->bc_bufs[i]) == bno)
                        return cur->bc_bufs[i];
        }
 
@@ -251,7 +251,7 @@ xfs_bmap_get_bp(
                struct xfs_buf_log_item *bip = (struct xfs_buf_log_item *)lip;
 
                if (bip->bli_item.li_type == XFS_LI_BUF &&
-                   XFS_BUF_ADDR(bip->bli_buf) == bno)
+                   xfs_buf_daddr(bip->bli_buf) == bno)
                        return bip->bli_buf;
        }
 

diff --git a/fs/xfs/libxfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index 9366876de5941e45a29500ed7b5271c38134371c..72444b8b38a6401920a817864582f4e132bcf406 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -282,7 +282,7 @@ xfs_bmbt_free_block(
        struct xfs_mount        *mp = cur->bc_mp;
        struct xfs_inode        *ip = cur->bc_ino.ip;
        struct xfs_trans        *tp = cur->bc_tp;
-       xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
+       xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));
        struct xfs_owner_info   oinfo;
 
        xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, cur->bc_ino.whichfork);

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index 86c061fa82fe4ba6dd7cb0cb202ab9a771e6d99a..16a71465cb0b47b76a1452c4b5791ed06a1c46f1 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -420,7 +420,7 @@ xfs_btree_dup_cursor(
                bp = cur->bc_bufs[i];
                if (bp) {
                        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
-                                                  XFS_BUF_ADDR(bp), mp->m_bsize,
+                                                  xfs_buf_daddr(bp), mp->m_bsize,
                                                   0, &bp,
                                                   cur->bc_ops->buf_ops);
                        if (error) {
@@ -1192,10 +1192,10 @@ xfs_btree_buf_to_ptr(
 {
        if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
                ptr->l = cpu_to_be64(XFS_DADDR_TO_FSB(cur->bc_mp,
-                                       XFS_BUF_ADDR(bp)));
+                                       xfs_buf_daddr(bp)));
        else {
                ptr->s = cpu_to_be32(xfs_daddr_to_agbno(cur->bc_mp,
-                                       XFS_BUF_ADDR(bp)));
+                                       xfs_buf_daddr(bp)));
        }
 }
 
@@ -1739,7 +1739,7 @@ xfs_btree_lookup_get_block(
        error = xfs_btree_ptr_to_daddr(cur, pp, &daddr);
        if (error)
                return error;
-       if (bp && XFS_BUF_ADDR(bp) == daddr) {
+       if (bp && xfs_buf_daddr(bp) == daddr) {
                *blkp = XFS_BUF_TO_BLOCK(bp);
                return 0;
        }
@@ -4499,7 +4499,7 @@ xfs_btree_sblock_verify(
                return __this_address;
 
        /* sibling pointer verification */
-       agno = xfs_daddr_to_agno(mp, XFS_BUF_ADDR(bp));
+       agno = xfs_daddr_to_agno(mp, xfs_buf_daddr(bp));
        if (block->bb_u.s.bb_leftsib != cpu_to_be32(NULLAGBLOCK) &&
            !xfs_verify_agbno(mp, agno, be32_to_cpu(block->bb_u.s.bb_leftsib)))
                return __this_address;

diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 62e3c6c8da339c66f36ff844f5e90119e7fc8621..27190840c5d889435c7cc2b182f8333fb0823f2b 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -156,7 +156,7 @@ __xfs_inobt_free_block(
 {
        xfs_inobt_mod_blockcount(cur, -1);
        return xfs_free_extent(cur->bc_tp,
-                       XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
+                       XFS_DADDR_TO_FSB(cur->bc_mp, xfs_buf_daddr(bp)), 1,
                        &XFS_RMAP_OINFO_INOBT, resv);
 }
 

diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 036f909ff7a6c2784ab018f0e30347a402ed0d6b..83ba63b4ace4f16af151db800688ef3121ad04a8 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -48,7 +48,7 @@ xfs_inode_buf_verify(
        /*
         * Validate the magic number and version of every inode in the buffer
         */
-       agno = xfs_daddr_to_agno(mp, XFS_BUF_ADDR(bp));
+       agno = xfs_daddr_to_agno(mp, xfs_buf_daddr(bp));
        ni = XFS_BB_TO_FSB(mp, bp->b_length) * mp->m_sb.sb_inopblock;
        for (i = 0; i < ni; i++) {
                int             di_ok;

diff --git a/fs/xfs/libxfs/xfs_refcount_btree.c b/fs/xfs/libxfs/xfs_refcount_btree.c
index ad8807b9e6b404ea3b550984a7e10be6a3df04c7..1ef9b99962ab4aa2fef08c7a7eeb0244da9307d8 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount_btree.c
+++ b/fs/xfs/libxfs/xfs_refcount_btree.c
@@ -102,7 +102,7 @@ xfs_refcountbt_free_block(
        struct xfs_mount        *mp = cur->bc_mp;
        struct xfs_buf          *agbp = cur->bc_ag.agbp;
        struct xfs_agf          *agf = agbp->b_addr;
-       xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
+       xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));
        int                     error;
 
        trace_xfs_refcountbt_free_block(cur->bc_mp, cur->bc_ag.pag->pag_agno,

diff --git a/fs/xfs/libxfs/xfs_rmap_btree.c b/fs/xfs/libxfs/xfs_rmap_btree.c
index 55989cab7db59ced2b7b04c52fd9bca493fc19d3..b7dbbfb3aeed93eba624f5990a20d281f6e2b1fe 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap_btree.c
+++ b/fs/xfs/libxfs/xfs_rmap_btree.c
@@ -122,7 +122,7 @@ xfs_rmapbt_free_block(
        xfs_agblock_t           bno;
        int                     error;
 
-       bno = xfs_daddr_to_agbno(cur->bc_mp, XFS_BUF_ADDR(bp));
+       bno = xfs_daddr_to_agbno(cur->bc_mp, xfs_buf_daddr(bp));
        trace_xfs_rmapbt_free_block(cur->bc_mp, pag->pag_agno,
                        bno, 1);
        be32_add_cpu(&agf->agf_rmap_blocks, -1);

diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 197093acb828bad4ad355056e9a2dff358dc1ace..b1c5ec1bd200fc0592f54f844408b938fe923b6d 100644 (file)
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -192,7 +192,7 @@ xfs_validate_sb_write(
         * secondary superblocks, so allow this usage to continue because
         * we never read counters from such superblocks.
         */
-       if (XFS_BUF_ADDR(bp) == XFS_SB_DADDR && !sbp->sb_inprogress &&
+       if (xfs_buf_daddr(bp) == XFS_SB_DADDR && !sbp->sb_inprogress &&
            (sbp->sb_fdblocks > sbp->sb_dblocks ||
             !xfs_verify_icount(mp, sbp->sb_icount) ||
             sbp->sb_ifree > sbp->sb_icount)) {

diff --git a/fs/xfs/scrub/btree.c b/fs/xfs/scrub/btree.c
index c044e0a8da7ffceb0af267068904587871e6cd2d..fd832f103fa43b23e9ec2b2a9ceae18ea0d7421d 100644 (file)
--- a/fs/xfs/scrub/btree.c
+++ b/fs/xfs/scrub/btree.c
@@ -435,12 +435,12 @@ xchk_btree_check_owner(
                if (!co)
                        return -ENOMEM;
                co->level = level;
-               co->daddr = XFS_BUF_ADDR(bp);
+               co->daddr = xfs_buf_daddr(bp);
                list_add_tail(&co->list, &bs->to_check);
                return 0;
        }
 
-       return xchk_btree_check_block_owner(bs, level, XFS_BUF_ADDR(bp));
+       return xchk_btree_check_block_owner(bs, level, xfs_buf_daddr(bp));
 }
 
 /* Decide if we want to check minrecs of a btree block in the inode root. */

diff --git a/fs/xfs/xfs_attr_inactive.c b/fs/xfs/xfs_attr_inactive.c
index aaa7e66c42d742223021bdc6954505c683248ca7..d8fdde2068670d07f64c4eb0e3bf21835fc1f0c7 100644 (file)
--- a/fs/xfs/xfs_attr_inactive.c
+++ b/fs/xfs/xfs_attr_inactive.c
@@ -177,7 +177,7 @@ xfs_attr3_node_inactive(
                        return error;
 
                /* save for re-read later */
-               child_blkno = XFS_BUF_ADDR(child_bp);
+               child_blkno = xfs_buf_daddr(child_bp);
 
                /*
                 * Invalidate the subtree, however we have to.

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 82dd9bfa4265a849f10fd23bae96e65d7275a398..c1bb6e41595bde50be8acc5222a72f20cab23b00 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1335,7 +1335,7 @@ xfs_buf_ioerror_alert(
 {
        xfs_buf_alert_ratelimited(bp, "XFS: metadata IO error",
                "metadata I/O error in \"%pS\" at daddr 0x%llx len %d error %d",
-                                 func, (uint64_t)XFS_BUF_ADDR(bp),
+                                 func, (uint64_t)xfs_buf_daddr(bp),
                                  bp->b_length, -bp->b_error);
 }
 

diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 37c9004f11de128712dd22a5916162dd2d1d3683..6db2fba44b466ab1d5b5bfe43590c2be4018b4bc 100644 (file)
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -311,9 +311,13 @@ extern void xfs_buf_terminate(void);
  * In future, uncached buffers will pass the block number directly to the io
  * request function and hence these macros will go away at that point.
  */
-#define XFS_BUF_ADDR(bp)               ((bp)->b_maps[0].bm_bn)
 #define XFS_BUF_SET_ADDR(bp, bno)      ((bp)->b_maps[0].bm_bn = (xfs_daddr_t)(bno))
 
+static inline xfs_daddr_t xfs_buf_daddr(struct xfs_buf *bp)
+{
+       return bp->b_maps[0].bm_bn;
+}
+
 void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref);
 
 /*

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 4ff274ce31c4ef7b179c65c0bf6f9083a7eff4ef..6549e50d852c0e3f87d14db64680b57a8db7c2f8 100644 (file)
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -38,7 +38,7 @@ xfs_trans_buf_item_match(
                blip = (struct xfs_buf_log_item *)lip;
                if (blip->bli_item.li_type == XFS_LI_BUF &&
                    blip->bli_buf->b_target == target &&
-                   XFS_BUF_ADDR(blip->bli_buf) == map[0].bm_bn &&
+                   xfs_buf_daddr(blip->bli_buf) == map[0].bm_bn &&
                    blip->bli_buf->b_length == len) {
                        ASSERT(blip->bli_buf->b_map_count == nmaps);
                        return blip->bli_buf;