xfs: convert bp->b_bn references to xfs_buf_daddr()

Source kernel commit: 9343ee76909e3f6466d85c9ebb0e343cdf54de71

Stop directly referencing b_bn in code outside the buffer cache, as
b_bn is supposed to be used only as an internal cache index.

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

diff --git a/db/metadump.c b/db/metadump.c
index 2c649c155cae9ce6f82957919308c17d85b03001..48cda88a3ea5684136f581718d576c55bdc29b16 100644 (file)
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -204,7 +204,7 @@ write_buf(
                        print_warning(
                            "obfuscation corrupted block at %s bno 0x%llx/0x%x",
                                bp->b_ops->name,
-                               (long long)bp->b_bn, BBTOB(bp->b_length));
+                               (long long)xfs_buf_daddr(bp), BBTOB(bp->b_length));
                }
        }
 

diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c
index a55e3a7982a5c0b812d7e6fb1ca1ac9d0d8e5b43..f07fad6222746a33d79a40804bc85f2090c939d6 100644 (file)
--- a/libxfs/rdwr.c
+++ b/libxfs/rdwr.c
@@ -214,7 +214,7 @@ libxfs_bcompare(struct cache_node *node, cache_key_t key)
        "%lx: Badness in key lookup (length)\n"
        "bp=(bno 0x%llx, len %u bytes) key=(bno 0x%llx, len %u bytes)\n",
                                pthread_self(),
-                               (unsigned long long)bp->b_bn, 
+                               (unsigned long long)xfs_buf_daddr(bp),
                                BBTOB(bp->b_length),
                                (unsigned long long)bkey->blkno,
                                BBTOB(bkey->bblen));
@@ -833,14 +833,16 @@ libxfs_bwrite(
                        fprintf(stderr,
        _("%s: write verifier failed on %s bno 0x%llx/0x%x\n"),
                                __func__, bp->b_ops->name,
-                               (long long)bp->b_bn, bp->b_length);
+                               (unsigned long long)xfs_buf_daddr(bp),
+                               bp->b_length);
                        return bp->b_error;
                }
        }
 
        if (!(bp->b_flags & LIBXFS_B_DISCONTIG)) {
                bp->b_error = __write_buf(fd, bp->b_addr, BBTOB(bp->b_length),
-                                   LIBXFS_BBTOOFF64(bp->b_bn), bp->b_flags);
+                                   LIBXFS_BBTOOFF64(xfs_buf_daddr(bp)),
+                                   bp->b_flags);
        } else {
                int     i;
                void    *buf = bp->b_addr;
@@ -861,7 +863,8 @@ libxfs_bwrite(
                fprintf(stderr,
        _("%s: write failed on %s bno 0x%llx/0x%x, err=%d\n"),
                        __func__, bp->b_ops ? bp->b_ops->name : "(unknown)",
-                       (long long)bp->b_bn, bp->b_length, -bp->b_error);
+                       (unsigned long long)xfs_buf_daddr(bp),
+                       bp->b_length, -bp->b_error);
        } else {
                bp->b_flags |= LIBXFS_B_UPTODATE;
                bp->b_flags &= ~(LIBXFS_B_DIRTY | LIBXFS_B_UNCHECKED);

diff --git a/libxfs/util.c b/libxfs/util.c
index 9c8230cd15d3f948bca6efb81a4be3bac60cc550..69cc477c25ed61919605ba782fdf2e037dcb69c8 100644 (file)
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -556,7 +556,7 @@ xfs_verifier_error(
        xfs_alert(NULL, "Metadata %s detected at %p, %s block 0x%llx/0x%x",
                  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
                  failaddr ? failaddr : __return_address,
-                 bp->b_ops->name, bp->b_bn, BBTOB(bp->b_length));
+                 bp->b_ops->name, xfs_buf_daddr(bp), BBTOB(bp->b_length));
 }
 
 /*
@@ -589,7 +589,7 @@ xfs_buf_corruption_error(
        xfs_failaddr_t          fa)
 {
        xfs_alert(NULL, "Metadata corruption detected at %p, %s block 0x%llx",
-                 fa, bp->b_ops->name, bp->b_bn);
+                 fa, bp->b_ops->name, xfs_buf_daddr(bp));
 }
 
 /*

diff --git a/libxfs/xfs_ag.c b/libxfs/xfs_ag.c
index 6691ca70f66506ce071afc20254cb44a90c5382a..c95e8b261cb7bb6086354ab9923046046f4c58b1 100644 (file)
--- a/libxfs/xfs_ag.c
+++ b/libxfs/xfs_ag.c
@@ -313,7 +313,6 @@ xfs_get_aghdr_buf(
        if (error)
                return error;
 
-       bp->b_bn = blkno;
        bp->b_maps[0].bm_bn = blkno;
        bp->b_ops = ops;
 

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 308fc0f74c824e0ba079b06fb0af0c21997f4b53..76a525735a68256ea46f5c6f48a5825f33c873f2 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -1203,7 +1203,7 @@ xfs_attr3_leaf_to_node(
        memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize);
        if (xfs_has_crc(mp)) {
                struct xfs_da3_blkinfo *hdr3 = bp2->b_addr;
-               hdr3->blkno = cpu_to_be64(bp2->b_bn);
+               hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp2));
        }
        xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1);
 
@@ -1271,7 +1271,7 @@ xfs_attr3_leaf_create(
 
                ichdr.magic = XFS_ATTR3_LEAF_MAGIC;
 
-               hdr3->blkno = cpu_to_be64(bp->b_bn);
+               hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp));
                hdr3->owner = cpu_to_be64(dp->i_ino);
                uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
 

diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 73eb256e7e8dbfa6b0a3bb9faea2821fc538804f..afa932904602fc19bd9bec7eca1f239b677e24e5 100644 (file)
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -129,7 +129,7 @@ __xfs_attr3_rmt_read_verify(
                return 0;
 
        ptr = bp->b_addr;
-       bno = bp->b_bn;
+       bno = xfs_buf_daddr(bp);
        len = BBTOB(bp->b_length);
        ASSERT(len >= blksize);
 
@@ -194,7 +194,7 @@ xfs_attr3_rmt_write_verify(
                return;
 
        ptr = bp->b_addr;
-       bno = bp->b_bn;
+       bno = xfs_buf_daddr(bp);
        len = BBTOB(bp->b_length);
        ASSERT(len >= blksize);
 
@@ -283,7 +283,7 @@ xfs_attr_rmtval_copyout(
        uint8_t         **dst)
 {
        char            *src = bp->b_addr;
-       xfs_daddr_t     bno = bp->b_bn;
+       xfs_daddr_t     bno = xfs_buf_daddr(bp);
        int             len = BBTOB(bp->b_length);
        int             blksize = mp->m_attr_geo->blksize;
 
@@ -331,7 +331,7 @@ xfs_attr_rmtval_copyin(
        uint8_t         **src)
 {
        char            *dst = bp->b_addr;
-       xfs_daddr_t     bno = bp->b_bn;
+       xfs_daddr_t     bno = xfs_buf_daddr(bp);
        int             len = BBTOB(bp->b_length);
        int             blksize = mp->m_attr_geo->blksize;
 

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index 1edf623611dcfdc2bfb323205e451253696957d0..d5ccce1f1c297d567bdf6aabb2b1a6a3163e509d 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -732,7 +732,7 @@ xfs_bmap_extents_to_btree(
         */
        abp->b_ops = &xfs_bmbt_buf_ops;
        ablock = XFS_BUF_TO_BLOCK(abp);
-       xfs_btree_init_block_int(mp, ablock, abp->b_bn,
+       xfs_btree_init_block_int(mp, ablock, xfs_buf_daddr(abp),
                                XFS_BTNUM_BMAP, 0, 0, ip->i_ino,
                                XFS_BTREE_LONG_PTRS);
 

diff --git a/libxfs/xfs_btree.c b/libxfs/xfs_btree.c
index 2f86ab68936dfb92a0a2770a971a912d72f017f8..3d9d0dcc68a957899ddb99d97c17caeb70d70a95 100644 (file)
--- a/libxfs/xfs_btree.c
+++ b/libxfs/xfs_btree.c
@@ -67,7 +67,7 @@ __xfs_btree_check_lblock(
                if (!uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
                if (block->bb_u.l.bb_blkno !=
-                   cpu_to_be64(bp ? bp->b_bn : XFS_BUF_DADDR_NULL))
+                   cpu_to_be64(bp ? xfs_buf_daddr(bp) : XFS_BUF_DADDR_NULL))
                        return __this_address;
                if (block->bb_u.l.bb_pad != cpu_to_be32(0))
                        return __this_address;
@@ -132,7 +132,7 @@ __xfs_btree_check_sblock(
                if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
                if (block->bb_u.s.bb_blkno !=
-                   cpu_to_be64(bp ? bp->b_bn : XFS_BUF_DADDR_NULL))
+                   cpu_to_be64(bp ? xfs_buf_daddr(bp) : XFS_BUF_DADDR_NULL))
                        return __this_address;
        }
 
@@ -1128,7 +1128,7 @@ xfs_btree_init_block(
        __u16           numrecs,
        __u64           owner)
 {
-       xfs_btree_init_block_int(mp, XFS_BUF_TO_BLOCK(bp), bp->b_bn,
+       xfs_btree_init_block_int(mp, XFS_BUF_TO_BLOCK(bp), xfs_buf_daddr(bp),
                                 btnum, level, numrecs, owner, 0);
 }
 
@@ -1152,9 +1152,9 @@ xfs_btree_init_block_cur(
        else
                owner = cur->bc_ag.pag->pag_agno;
 
-       xfs_btree_init_block_int(cur->bc_mp, XFS_BUF_TO_BLOCK(bp), bp->b_bn,
-                                cur->bc_btnum, level, numrecs,
-                                owner, cur->bc_flags);
+       xfs_btree_init_block_int(cur->bc_mp, XFS_BUF_TO_BLOCK(bp),
+                               xfs_buf_daddr(bp), cur->bc_btnum, level,
+                               numrecs, owner, cur->bc_flags);
 }
 
 /*
@@ -2924,10 +2924,11 @@ xfs_btree_new_iroot(
         */
        memcpy(cblock, block, xfs_btree_block_len(cur));
        if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS) {
+               __be64 bno = cpu_to_be64(xfs_buf_daddr(cbp));
                if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
-                       cblock->bb_u.l.bb_blkno = cpu_to_be64(cbp->b_bn);
+                       cblock->bb_u.l.bb_blkno = bno;
                else
-                       cblock->bb_u.s.bb_blkno = cpu_to_be64(cbp->b_bn);
+                       cblock->bb_u.s.bb_blkno = bno;
        }
 
        be16_add_cpu(&block->bb_level, 1);
@@ -3226,7 +3227,7 @@ xfs_btree_insrec(
 
        /* Get pointers to the btree buffer and block. */
        block = xfs_btree_get_block(cur, level, &bp);
-       old_bn = bp ? bp->b_bn : XFS_BUF_DADDR_NULL;
+       old_bn = bp ? xfs_buf_daddr(bp) : XFS_BUF_DADDR_NULL;
        numrecs = xfs_btree_get_numrecs(block);
 
 #ifdef DEBUG
@@ -3342,7 +3343,7 @@ xfs_btree_insrec(
         * some records into the new tree block), so use the regular key
         * update mechanism.
         */
-       if (bp && bp->b_bn != old_bn) {
+       if (bp && xfs_buf_daddr(bp) != old_bn) {
                xfs_btree_get_keys(cur, block, lkey);
        } else if (xfs_btree_needs_key_update(cur, optr)) {
                error = xfs_btree_update_keys(cur, level);
@@ -4423,7 +4424,7 @@ xfs_btree_lblock_v5hdr_verify(
                return __this_address;
        if (!uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_meta_uuid))
                return __this_address;
-       if (block->bb_u.l.bb_blkno != cpu_to_be64(bp->b_bn))
+       if (block->bb_u.l.bb_blkno != cpu_to_be64(xfs_buf_daddr(bp)))
                return __this_address;
        if (owner != XFS_RMAP_OWN_UNKNOWN &&
            be64_to_cpu(block->bb_u.l.bb_owner) != owner)
@@ -4473,7 +4474,7 @@ xfs_btree_sblock_v5hdr_verify(
                return __this_address;
        if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_meta_uuid))
                return __this_address;
-       if (block->bb_u.s.bb_blkno != cpu_to_be64(bp->b_bn))
+       if (block->bb_u.s.bb_blkno != cpu_to_be64(xfs_buf_daddr(bp)))
                return __this_address;
        if (pag && be32_to_cpu(block->bb_u.s.bb_owner) != pag->pag_agno)
                return __this_address;

diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
index d2dec4aabc2b5b9853457f04a03c9be701adfba4..0e504d2d241c4b5262c0ac885ddbb22ae01f063a 100644 (file)
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -191,7 +191,7 @@ xfs_da3_blkinfo_verify(
        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)
+               if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
                        return __this_address;
                if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
                        return __this_address;
@@ -444,7 +444,7 @@ xfs_da3_node_create(
 
                memset(hdr3, 0, sizeof(struct xfs_da3_node_hdr));
                ichdr.magic = XFS_DA3_NODE_MAGIC;
-               hdr3->info.blkno = cpu_to_be64(bp->b_bn);
+               hdr3->info.blkno = cpu_to_be64(xfs_buf_daddr(bp));
                hdr3->info.owner = cpu_to_be64(args->dp->i_ino);
                uuid_copy(&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid);
        } else {
@@ -708,7 +708,7 @@ xfs_da3_root_split(
            oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
                struct xfs_da3_intnode *node3 = (struct xfs_da3_intnode *)node;
 
-               node3->hdr.info.blkno = cpu_to_be64(bp->b_bn);
+               node3->hdr.info.blkno = cpu_to_be64(xfs_buf_daddr(bp));
        }
        xfs_trans_log_buf(tp, bp, 0, size - 1);
 
@@ -1216,7 +1216,7 @@ xfs_da3_root_join(
        xfs_trans_buf_copy_type(root_blk->bp, bp);
        if (oldroothdr.magic == XFS_DA3_NODE_MAGIC) {
                struct xfs_da3_blkinfo *da3 = root_blk->bp->b_addr;
-               da3->blkno = cpu_to_be64(root_blk->bp->b_bn);
+               da3->blkno = cpu_to_be64(xfs_buf_daddr(root_blk->bp));
        }
        xfs_trans_log_buf(args->trans, root_blk->bp, 0,
                          args->geo->blksize - 1);

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index f5d0f703b1b573e248e0290a0e12149fbbbf0c44..1b8c2521c02b6af6325af68598e5d83a536b0483 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -53,7 +53,7 @@ xfs_dir3_block_verify(
        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)
+               if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
                        return __this_address;
                if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
                        return __this_address;
@@ -171,7 +171,7 @@ xfs_dir3_block_init(
        if (xfs_has_crc(mp)) {
                memset(hdr3, 0, sizeof(*hdr3));
                hdr3->magic = cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
-               hdr3->blkno = cpu_to_be64(bp->b_bn);
+               hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp));
                hdr3->owner = cpu_to_be64(dp->i_ino);
                uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
                return;

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index 85cb14d3ff21c4cbe5b87afb27da56f43f8e68f0..4e207986bc926c6794f5bb9b5fb42c6999afb585 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -297,7 +297,7 @@ xfs_dir3_data_verify(
        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)
+               if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
                        return __this_address;
                if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
                        return __this_address;
@@ -719,7 +719,7 @@ xfs_dir3_data_init(
 
                memset(hdr3, 0, sizeof(*hdr3));
                hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
-               hdr3->blkno = cpu_to_be64(bp->b_bn);
+               hdr3->blkno = cpu_to_be64(xfs_buf_daddr(bp));
                hdr3->owner = cpu_to_be64(dp->i_ino);
                uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
 

diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
index 70b1f08321da885d3fc44ffa16fd92103f53973c..8827c96c189e0986a8350f038c053e88a63e2005 100644 (file)
--- a/libxfs/xfs_dir2_leaf.c
+++ b/libxfs/xfs_dir2_leaf.c
@@ -106,7 +106,7 @@ xfs_dir3_leaf1_check(
 
        if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
                struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
-               if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn)
+               if (be64_to_cpu(leaf3->info.blkno) != xfs_buf_daddr(bp))
                        return __this_address;
        } else if (leafhdr.magic != XFS_DIR2_LEAF1_MAGIC)
                return __this_address;
@@ -314,7 +314,7 @@ xfs_dir3_leaf_init(
                leaf3->info.hdr.magic = (type == XFS_DIR2_LEAF1_MAGIC)
                                         ? cpu_to_be16(XFS_DIR3_LEAF1_MAGIC)
                                         : cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
-               leaf3->info.blkno = cpu_to_be64(bp->b_bn);
+               leaf3->info.blkno = cpu_to_be64(xfs_buf_daddr(bp));
                leaf3->info.owner = cpu_to_be64(owner);
                uuid_copy(&leaf3->info.uuid, &mp->m_sb.sb_meta_uuid);
        } else {

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index e7ed4b46fa178b56ced84255ab9f95eb155d7813..c0eb335c3002f30a5e5f576e171c00fd29a16820 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -65,7 +65,7 @@ xfs_dir3_leafn_check(
 
        if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) {
                struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
-               if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn)
+               if (be64_to_cpu(leaf3->info.blkno) != xfs_buf_daddr(bp))
                        return __this_address;
        } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC)
                return __this_address;
@@ -107,7 +107,7 @@ xfs_dir3_free_verify(
 
                if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
                        return __this_address;
-               if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
+               if (be64_to_cpu(hdr3->blkno) != xfs_buf_daddr(bp))
                        return __this_address;
                if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
                        return __this_address;
@@ -343,7 +343,7 @@ xfs_dir3_free_get_buf(
 
                hdr.magic = XFS_DIR3_FREE_MAGIC;
 
-               hdr3->hdr.blkno = cpu_to_be64(bp->b_bn);
+               hdr3->hdr.blkno = cpu_to_be64(xfs_buf_daddr(bp));
                hdr3->hdr.owner = cpu_to_be64(dp->i_ino);
                uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_meta_uuid);
        } else

diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
index 516dab251ba8bac472e5c56f806658204f0ea836..68bd5f52b3df5d8e20c4a9e6187f7243916e0285 100644 (file)
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -68,7 +68,7 @@ xfs_inode_buf_verify(
 #ifdef DEBUG
                        xfs_alert(mp,
                                "bad inode magic/vsn daddr %lld #%d (magic=%x)",
-                               (unsigned long long)bp->b_bn, i,
+                               (unsigned long long)xfs_buf_daddr(bp), i,
                                be16_to_cpu(dip->di_magic));
 #endif
                        xfs_buf_verifier_error(bp, -EFSCORRUPTED,

diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
index 680441ae179a7dc777f118d47dd58e25dc5c6003..d7e3526c9f1935beb379e207980fbe2248d6071a 100644 (file)
--- a/libxfs/xfs_sb.c
+++ b/libxfs/xfs_sb.c
@@ -745,7 +745,7 @@ xfs_sb_read_verify(
 
                if (!xfs_buf_verify_cksum(bp, XFS_SB_CRC_OFF)) {
                        /* Only fail bad secondaries on a known V5 filesystem */
-                       if (bp->b_maps[0].bm_bn == XFS_SB_DADDR ||
+                       if (xfs_buf_daddr(bp) == XFS_SB_DADDR ||
                            xfs_has_crc(mp)) {
                                error = -EFSBADCRC;
                                goto out_error;

diff --git a/libxfs/xfs_symlink_remote.c b/libxfs/xfs_symlink_remote.c
index e0a683191a2cc390ff205d95092d4af1b3c4e5c8..a5cbb40fb2a24a665f396186f88816e18aa5c8b3 100644 (file)
--- a/libxfs/xfs_symlink_remote.c
+++ b/libxfs/xfs_symlink_remote.c
@@ -48,7 +48,7 @@ xfs_symlink_hdr_set(
        dsl->sl_bytes = cpu_to_be32(size);
        uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid);
        dsl->sl_owner = cpu_to_be64(ino);
-       dsl->sl_blkno = cpu_to_be64(bp->b_bn);
+       dsl->sl_blkno = cpu_to_be64(xfs_buf_daddr(bp));
        bp->b_ops = &xfs_symlink_buf_ops;
 
        return sizeof(struct xfs_dsymlink_hdr);
@@ -92,7 +92,7 @@ xfs_symlink_verify(
                return __this_address;
        if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid))
                return __this_address;
-       if (bp->b_bn != be64_to_cpu(dsl->sl_blkno))
+       if (xfs_buf_daddr(bp) != be64_to_cpu(dsl->sl_blkno))
                return __this_address;
        if (be32_to_cpu(dsl->sl_offset) +
                                be32_to_cpu(dsl->sl_bytes) >= XFS_SYMLINK_MAXLEN)

diff --git a/repair/attr_repair.c b/repair/attr_repair.c
index df1b519f2a9d7fcfa01adeedf86ab393d7f584e0..927dd0953bfaecf7371ea9c86f7940b16c886269 100644 (file)
--- a/repair/attr_repair.c
+++ b/repair/attr_repair.c
@@ -935,14 +935,14 @@ __check_attr_header(
                do_warn(
 _("expected owner inode %" PRIu64 ", got %llu, attr block %" PRIu64 "\n"),
                        ino, (unsigned long long)be64_to_cpu(info->owner),
-                       bp->b_bn);
+                       xfs_buf_daddr(bp));
                return 1;
        }
        /* verify block number */
-       if (be64_to_cpu(info->blkno) != bp->b_bn) {
+       if (be64_to_cpu(info->blkno) != xfs_buf_daddr(bp)) {
                do_warn(
 _("expected block %" PRIu64 ", got %llu, inode %" PRIu64 "attr block\n"),
-                       bp->b_bn, (unsigned long long)be64_to_cpu(info->blkno),
+                       xfs_buf_daddr(bp), (unsigned long long)be64_to_cpu(info->blkno),
                        ino);
                return 1;
        }
@@ -950,7 +950,7 @@ _("expected block %" PRIu64 ", got %llu, inode %" PRIu64 "attr block\n"),
        if (platform_uuid_compare(&info->uuid, &mp->m_sb.sb_meta_uuid) != 0) {
                do_warn(
 _("wrong FS UUID, inode %" PRIu64 " attr block %" PRIu64 "\n"),
-                       ino, bp->b_bn);
+                       ino, xfs_buf_daddr(bp));
                return 1;
        }
 

diff --git a/repair/phase6.c b/repair/phase6.c
index 647dc1c5ffb4ec95de38625c6ffd1b87e0aaa348..9e60c87ba240858bce912f273b11cbd017042d6f 100644 (file)
--- a/repair/phase6.c
+++ b/repair/phase6.c
@@ -1905,21 +1905,21 @@ __check_dir3_header(
        if (be64_to_cpu(owner) != ino) {
                do_warn(
 _("expected owner inode %" PRIu64 ", got %llu, directory block %" PRIu64 "\n"),
-                       ino, (unsigned long long)be64_to_cpu(owner), bp->b_bn);
+                       ino, (unsigned long long)be64_to_cpu(owner), xfs_buf_daddr(bp));
                return 1;
        }
        /* verify block number */
-       if (be64_to_cpu(blkno) != bp->b_bn) {
+       if (be64_to_cpu(blkno) != xfs_buf_daddr(bp)) {
                do_warn(
 _("expected block %" PRIu64 ", got %llu, directory inode %" PRIu64 "\n"),
-                       bp->b_bn, (unsigned long long)be64_to_cpu(blkno), ino);
+                       xfs_buf_daddr(bp), (unsigned long long)be64_to_cpu(blkno), ino);
                return 1;
        }
        /* verify uuid */
        if (platform_uuid_compare(uuid, &mp->m_sb.sb_meta_uuid) != 0) {
                do_warn(
 _("wrong FS UUID, directory inode %" PRIu64 " block %" PRIu64 "\n"),
-                       ino, bp->b_bn);
+                       ino, xfs_buf_daddr(bp));
                return 1;
        }
 

diff --git a/repair/xfs_repair.c b/repair/xfs_repair.c
index bcd44cd5e82047883f2ae396fdc1aadde185c6ce..4769c130bef7f6a9344a4b6f3765993608fc3e19 100644 (file)
--- a/repair/xfs_repair.c
+++ b/repair/xfs_repair.c
@@ -850,7 +850,7 @@ repair_capture_writeback(
         * avoid hook recursion when setting NEEDSREPAIR.  Higher level code
         * modifying an sb must control the flag manually.
         */
-       if (bp->b_ops == &xfs_sb_buf_ops || bp->b_bn == XFS_SB_DADDR)
+       if (bp->b_ops == &xfs_sb_buf_ops || xfs_buf_daddr(bp) == XFS_SB_DADDR)
                return;
 
        pthread_mutex_lock(&wb_mutex);