libxfs: get rid of b_bcount from xfs_buf

We no longer use it in the kernel - it has been replaced by b_length
and it only exists in userspace because we haven't converted it
over. Do that now before we introduce a heap of code that doesn't
ever set it and so breaks all the progs code.

WHile we are doing this, kill the XFS_BUF_SIZE macro that has also
been removed from the kernel, too.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/db/metadump.c b/db/metadump.c
index 247afc4527348d683b88d59c9a9aece76e283c13..96b098b0eaca727f68215d1f038e068e745bf4bc 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, bp->b_bcount);
+                               (long long)bp->b_bn, BBTOB(bp->b_length));
                }
        }
 

diff --git a/libxfs/libxfs_io.h b/libxfs/libxfs_io.h
index a3a3816cc2942f2949b8588da90f1d1c16c8a8b4..1eccedfc5fe197093e613d995cdc8237a699d668 100644 (file)
--- a/libxfs/libxfs_io.h
+++ b/libxfs/libxfs_io.h
@@ -61,7 +61,6 @@ typedef struct xfs_buf {
        struct cache_node       b_node;
        unsigned int            b_flags;
        xfs_daddr_t             b_bn;
-       unsigned                b_bcount;
        unsigned int            b_length;
        struct xfs_buftarg      *b_target;
        pthread_mutex_t         b_lock;
@@ -97,7 +96,6 @@ typedef unsigned int xfs_buf_flags_t;
 
 #define xfs_buf_offset(bp, offset)     ((bp)->b_addr + (offset))
 #define XFS_BUF_ADDR(bp)               ((bp)->b_bn)
-#define XFS_BUF_SIZE(bp)               ((bp)->b_bcount)
 
 #define XFS_BUF_SET_ADDR(bp,blk)       ((bp)->b_bn = (blk))
 
@@ -190,7 +188,7 @@ static inline int
 xfs_buf_associate_memory(struct xfs_buf *bp, void *mem, size_t len)
 {
        bp->b_addr = mem;
-       bp->b_bcount = len;
+       bp->b_length = BTOBB(len);
        return 0;
 }
 

diff --git a/libxfs/logitem.c b/libxfs/logitem.c
index db5c961d2132d23b3db684f61ede6b630c042906..43a98f284129ae5772579ac2288f23b427904718 100644 (file)
--- a/libxfs/logitem.c
+++ b/libxfs/logitem.c
@@ -47,7 +47,7 @@ xfs_trans_buf_item_match(
                if (blip->bli_item.li_type == XFS_LI_BUF &&
                    blip->bli_buf->b_target->bt_bdev == btp->bt_bdev &&
                    XFS_BUF_ADDR(blip->bli_buf) == map[0].bm_bn &&
-                   blip->bli_buf->b_bcount == BBTOB(len)) {
+                   blip->bli_buf->b_length == len) {
                        ASSERT(blip->bli_buf->b_map_count == nmaps);
                        return blip->bli_buf;
                }
@@ -105,7 +105,7 @@ xfs_buf_item_init(
        bip->bli_buf = bp;
        bip->__bli_format.blf_type = XFS_LI_BUF;
        bip->__bli_format.blf_blkno = (int64_t)XFS_BUF_ADDR(bp);
-       bip->__bli_format.blf_len = (unsigned short)BTOBB(bp->b_bcount);
+       bip->__bli_format.blf_len = (unsigned short)bp->b_length;
        bp->b_log_item = bip;
 }
 

diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c
index 918f6025faf10224f9cd940641d08f5c71264fcb..2e0384017fa1c510706758da674fcbc19ca8e2b5 100644 (file)
--- a/libxfs/rdwr.c
+++ b/libxfs/rdwr.c
@@ -141,7 +141,7 @@ static char *next(
        struct xfs_buf  *buf = (struct xfs_buf *)private;
 
        if (buf &&
-           (buf->b_bcount < (int)(ptr - (char *)buf->b_addr) + offset))
+           (BBTOB(buf->b_length) < (int)(ptr - (char *)buf->b_addr) + offset))
                abort();
 
        return ptr + offset;
@@ -203,7 +203,7 @@ libxfs_bcompare(struct cache_node *node, cache_key_t key)
 
        if (bp->b_target->bt_bdev == bkey->buftarg->bt_bdev &&
            bp->b_bn == bkey->blkno) {
-               if (bp->b_bcount == BBTOB(bkey->bblen))
+               if (bp->b_length == bkey->bblen)
                        return CACHE_HIT;
 #ifdef IO_BCOMPARE_CHECK
                if (!(libxfs_bcache->c_flags & CACHE_MISCOMPARE_PURGE)) {
@@ -211,7 +211,8 @@ 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, (int)bp->b_bcount,
+                               (unsigned long long)bp->b_bn, 
+                               BBTOB(bp->b_length),
                                (unsigned long long)bkey->blkno,
                                BBTOB(bkey->bblen));
                }
@@ -227,7 +228,6 @@ __initbuf(xfs_buf_t *bp, struct xfs_buftarg *btp, xfs_daddr_t bno,
 {
        bp->b_flags = 0;
        bp->b_bn = bno;
-       bp->b_bcount = bytes;
        bp->b_length = BTOBB(bytes);
        bp->b_target = btp;
        bp->b_mount = btp->bt_mount;
@@ -306,7 +306,7 @@ __libxfs_getbufr(int blen)
        pthread_mutex_lock(&xfs_buf_freelist.cm_mutex);
        if (!list_empty(&xfs_buf_freelist.cm_list)) {
                list_for_each_entry(bp, &xfs_buf_freelist.cm_list, b_node.cn_mru) {
-                       if (bp->b_bcount == blen) {
+                       if (bp->b_length == BTOBB(blen)) {
                                list_del_init(&bp->b_node.cn_mru);
                                break;
                        }
@@ -581,13 +581,13 @@ libxfs_readbufr(struct xfs_buftarg *btp, xfs_daddr_t blkno, xfs_buf_t *bp,
        int     bytes = BBTOB(len);
        int     error;
 
-       ASSERT(BBTOB(len) <= bp->b_bcount);
+       ASSERT(len <= bp->b_length);
 
        error = __read_buf(fd, bp->b_addr, bytes, LIBXFS_BBTOOFF64(blkno), flags);
        if (!error &&
            bp->b_target->bt_bdev == btp->bt_bdev &&
            bp->b_bn == blkno &&
-           bp->b_bcount == bytes)
+           bp->b_length == len)
                bp->b_flags |= LIBXFS_B_UPTODATE;
        bp->b_error = error;
        return error;
@@ -824,13 +824,13 @@ 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_bcount);
+                               (long long)bp->b_bn, bp->b_length);
                        return bp->b_error;
                }
        }
 
        if (!(bp->b_flags & LIBXFS_B_DISCONTIG)) {
-               bp->b_error = __write_buf(fd, bp->b_addr, bp->b_bcount,
+               bp->b_error = __write_buf(fd, bp->b_addr, BBTOB(bp->b_length),
                                    LIBXFS_BBTOOFF64(bp->b_bn), bp->b_flags);
        } else {
                int     i;
@@ -852,7 +852,7 @@ 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_bcount, -bp->b_error);
+                       (long long)bp->b_bn, 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/trans.c b/libxfs/trans.c
index 6838b727350b0145121be74358ba13cd52d40cf1..83247582d61e7998a60a1f5331866599e01a02f4 100644 (file)
--- a/libxfs/trans.c
+++ b/libxfs/trans.c
@@ -721,7 +721,7 @@ libxfs_trans_ordered_buf(
        bool                    ret;
 
        ret = test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
-       libxfs_trans_log_buf(tp, bp, 0, bp->b_bcount);
+       libxfs_trans_log_buf(tp, bp, 0, BBTOB(bp->b_length));
        return ret;
 }
 

diff --git a/libxlog/xfs_log_recover.c b/libxlog/xfs_log_recover.c
index a7dfa7047ab91068216fe4a28a5007dd0e76e6c4..8fb439db62d52ee63444a7f9c29157e6399e8621 100644 (file)
--- a/libxlog/xfs_log_recover.c
+++ b/libxlog/xfs_log_recover.c
@@ -112,10 +112,10 @@ xlog_bread_noalign(
        nbblks = round_up(nbblks, log->l_sectBBsize);
 
        ASSERT(nbblks > 0);
-       ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
+       ASSERT(nbblks <= bp->b_length);
 
        XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
-       bp->b_bcount = BBTOB(nbblks);
+       bp->b_length = nbblks;
        bp->b_error = 0;
 
        return libxfs_readbufr(log->l_dev, XFS_BUF_ADDR(bp), bp, nbblks, 0);
@@ -152,7 +152,7 @@ xlog_bread_offset(
        char            *offset)
 {
        char            *orig_offset = bp->b_addr;
-       int             orig_len = bp->b_bcount;
+       int             orig_len = BBTOB(bp->b_length);
        int             error, error2;
 
        error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));

diff --git a/mkfs/proto.c b/mkfs/proto.c
index 20a7cc3bb5d54d88f3eb3011d34b3bd1ac75596a..0fa6ffb0107e8954b1ec03de96341a03d1b237a1 100644 (file)
--- a/mkfs/proto.c
+++ b/mkfs/proto.c
@@ -241,6 +241,8 @@ newfile(
                ip->i_df.if_format = XFS_DINODE_FMT_LOCAL;
                flags = XFS_ILOG_DDATA;
        } else if (len > 0) {
+               int     bcount;
+
                nb = XFS_B_TO_FSB(mp, len);
                nmap = 1;
                error = -libxfs_bmapi_write(tp, ip, 0, nb, 0, nb, &map, &nmap);
@@ -269,10 +271,11 @@ newfile(
                        exit(1);
                }
                memmove(bp->b_addr, buf, len);
-               if (len < bp->b_bcount)
-                       memset((char *)bp->b_addr + len, 0, bp->b_bcount - len);
+               bcount = BBTOB(bp->b_length);
+               if (len < bcount)
+                       memset((char *)bp->b_addr + len, 0, bcount - len);
                if (logit)
-                       libxfs_trans_log_buf(tp, bp, 0, bp->b_bcount - 1);
+                       libxfs_trans_log_buf(tp, bp, 0, bcount - 1);
                else {
                        libxfs_buf_mark_dirty(bp);
                        libxfs_buf_relse(bp);

diff --git a/repair/attr_repair.c b/repair/attr_repair.c
index d0c40f48ffe71ba1806ea4e0f21a6c6ac3d380ae..ba39c2b5ede48c8a9d8af1bf9457c49fa7136b2a 100644 (file)
--- a/repair/attr_repair.c
+++ b/repair/attr_repair.c
@@ -424,9 +424,9 @@ rmtval_get(xfs_mount_t *mp, xfs_ino_t ino, blkmap_t *blkmap,
                        break;
                }
 
-               ASSERT(mp->m_sb.sb_blocksize == bp->b_bcount);
+               ASSERT(mp->m_sb.sb_blocksize == BBTOB(bp->b_length));
 
-               length = min(bp->b_bcount - hdrsize, valuelen - amountdone);
+               length = min(BBTOB(bp->b_length) - hdrsize, valuelen - amountdone);
                memmove(value, bp->b_addr + hdrsize, length);
                amountdone += length;
                value += length;

diff --git a/repair/dino_chunks.c b/repair/dino_chunks.c
index e4a95ff635c810bbc81081ccd6ca73e3e8cf6469..0c60ab431e13d0660b7c792f9def6d2d4055a48c 100644 (file)
--- a/repair/dino_chunks.c
+++ b/repair/dino_chunks.c
@@ -687,7 +687,7 @@ process_inode_chunk(
 
                pftrace("readbuf %p (%llu, %d) in AG %d", bplist[bp_index],
                        (long long)XFS_BUF_ADDR(bplist[bp_index]),
-                       bplist[bp_index]->b_bcount, agno);
+                       bplist[bp_index]->b_length, agno);
 
                bplist[bp_index]->b_ops = &xfs_inode_buf_ops;
 

diff --git a/repair/prefetch.c b/repair/prefetch.c
index 88f85143f9fc3488e79c17c72e133c836342dc9e..3e63b8bea484b415eea76891c8db0f72bd862acb 100644 (file)
--- a/repair/prefetch.c
+++ b/repair/prefetch.c
@@ -411,7 +411,9 @@ pf_read_inode_dirs(
        if (error)
                return;
 
-       for (icnt = 0; icnt < (bp->b_bcount >> mp->m_sb.sb_inodelog); icnt++) {
+       for (icnt = 0;
+            icnt < (BBTOB(bp->b_length) >> mp->m_sb.sb_inodelog);
+            icnt++) {
                dino = xfs_make_iptr(mp, bp, icnt);
 
                /*
@@ -523,21 +525,21 @@ pf_batch_read(
                 */
                first_off = LIBXFS_BBTOOFF64(XFS_BUF_ADDR(bplist[0]));
                last_off = LIBXFS_BBTOOFF64(XFS_BUF_ADDR(bplist[num-1])) +
-                       XFS_BUF_SIZE(bplist[num-1]);
+                       BBTOB(bplist[num-1]->b_length);
                while (num > 1 && last_off - first_off > pf_max_bytes) {
                        num--;
                        last_off = LIBXFS_BBTOOFF64(XFS_BUF_ADDR(bplist[num-1])) +
-                               XFS_BUF_SIZE(bplist[num-1]);
+                               BBTOB(bplist[num-1]->b_length);
                }
                if (num < ((last_off - first_off) >> (mp->m_sb.sb_blocklog + 3))) {
                        /*
                         * not enough blocks for one big read, so determine
                         * the number of blocks that are close enough.
                         */
-                       last_off = first_off + XFS_BUF_SIZE(bplist[0]);
+                       last_off = first_off + BBTOB(bplist[0]->b_length);
                        for (i = 1; i < num; i++) {
                                next_off = LIBXFS_BBTOOFF64(XFS_BUF_ADDR(bplist[i])) +
-                                               XFS_BUF_SIZE(bplist[i]);
+                                               BBTOB(bplist[i]->b_length);
                                if (next_off - last_off > pf_batch_bytes)
                                        break;
                                last_off = next_off;
@@ -596,7 +598,7 @@ pf_batch_read(
                        for (i = 0; i < num; i++) {
 
                                pbuf = ((char *)buf) + (LIBXFS_BBTOOFF64(XFS_BUF_ADDR(bplist[i])) - first_off);
-                               size = XFS_BUF_SIZE(bplist[i]);
+                               size = BBTOB(bplist[i]->b_length);
                                if (len < size)
                                        break;
                                memcpy(bplist[i]->b_addr, pbuf, size);