7 files changed, 41 insertions, 41 deletions

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 382c49a42ac2..ab3c4491777b 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -198,12 +198,12 @@ xfs_buf_alloc(
         bp->b_target = target;
 
         /*
-         * Set length and count_desired to the same value initially.
-         * I/O routines should use count_desired, which will be the same in
+         * Set length and io_length to the same value initially.
+         * I/O routines should use io_length, which will be the same in
          * most cases but may be reset (e.g. XFS recovery).
          */
         bp->b_length = numblks;
-        bp->b_count_desired = numblks << BBSHIFT;
+        bp->b_io_length = numblks;
         bp->b_flags = flags;
 
         /*
@@ -302,7 +302,7 @@ xfs_buf_allocate_memory(
         xfs_buf_t               *bp,
         uint                    flags)
 {
-        size_t                  size = bp->b_count_desired;
+        size_t                  size;
         size_t                  nbytes, offset;
         gfp_t                   gfp_mask = xb_to_gfp(flags);
         unsigned short          page_count, i;
@@ -345,6 +345,7 @@ use_alloc_page:
                 return error;
 
         offset = bp->b_offset;
+        size = BBTOB(bp->b_length);
         bp->b_flags |= _XBF_PAGES;
 
         for (i = 0; i < bp->b_page_count; i++) {
@@ -575,7 +576,7 @@ xfs_buf_get(
          * that we can do IO on it.
          */
         bp->b_bn = blkno;
-        bp->b_count_desired = BBTOB(bp->b_length);
+        bp->b_io_length = bp->b_length;
 
 found:
         if (!(bp->b_flags & XBF_MAPPED)) {
@@ -718,7 +719,7 @@ xfs_buf_set_empty(
         bp->b_page_count = 0;
         bp->b_addr = NULL;
         bp->b_length = numblks;
-        bp->b_count_desired = numblks << BBSHIFT;
+        bp->b_io_length = numblks;
         bp->b_bn = XFS_BUF_DADDR_NULL;
         bp->b_flags &= ~XBF_MAPPED;
 }
@@ -770,7 +771,7 @@ xfs_buf_associate_memory(
                 pageaddr += PAGE_SIZE;
         }
 
-        bp->b_count_desired = len;
+        bp->b_io_length = BTOBB(len);
         bp->b_length = BTOBB(buflen);
         bp->b_flags |= XBF_MAPPED;
 
@@ -1012,9 +1013,8 @@ xfs_buf_ioerror_alert(
         const char              *func)
 {
         xfs_alert(bp->b_target->bt_mount,
-"metadata I/O error: block 0x%llx (\"%s\") error %d buf count %zd",
-                (__uint64_t)XFS_BUF_ADDR(bp), func,
-                bp->b_error, XFS_BUF_COUNT(bp));
+"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
+                (__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);
 }
 
 int
@@ -1186,7 +1186,7 @@ _xfs_buf_ioapply(
         int                     rw, map_i, total_nr_pages, nr_pages;
         struct bio              *bio;
         int                     offset = bp->b_offset;
-        int                     size = bp->b_count_desired;
+        int                     size = BBTOB(bp->b_io_length);
         sector_t                sector = bp->b_bn;
 
         total_nr_pages = bp->b_page_count;
@@ -1234,7 +1234,7 @@ next_chunk:
                         break;
 
                 offset = 0;
-                sector += nbytes >> BBSHIFT;
+                sector += BTOBB(nbytes);
                 size -= nbytes;
                 total_nr_pages--;
         }
@@ -1328,7 +1328,7 @@ xfs_buf_iomove(
                 page = bp->b_pages[xfs_buf_btoct(boff + bp->b_offset)];
                 cpoff = xfs_buf_poff(boff + bp->b_offset);
                 csize = min_t(size_t,
-                              PAGE_SIZE-cpoff, bp->b_count_desired-boff);
+                              PAGE_SIZE - cpoff, BBTOB(bp->b_io_length) - boff);
 
                 ASSERT(((csize + cpoff) <= PAGE_SIZE));
 
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 3dab208686a4..9787645fa54c 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -128,7 +128,6 @@ typedef struct xfs_buf {
         struct list_head        b_list;
         struct xfs_perag        *b_pag;         /* contains rbtree root */
         xfs_buftarg_t           *b_target;      /* buffer target (device) */
-        size_t                  b_count_desired;/* desired transfer size */
         void                    *b_addr;        /* virtual address of buffer */
         struct work_struct      b_iodone_work;
         xfs_buf_iodone_t        b_iodone;       /* I/O completion function */
@@ -137,6 +136,7 @@ typedef struct xfs_buf {
         struct xfs_trans        *b_transp;
         struct page             **b_pages;      /* array of page pointers */
         struct page             *b_page_array[XB_PAGES]; /* inline pages */
+        int                     b_io_length;    /* IO size in BBs */
         atomic_t                b_pin_count;    /* pin count */
         atomic_t                b_io_remaining; /* #outstanding I/O requests */
         unsigned int            b_page_count;   /* size of page array */
@@ -244,8 +244,6 @@ void xfs_buf_stale(struct xfs_buf *bp);
 
 #define XFS_BUF_ADDR(bp)                ((bp)->b_bn)
 #define XFS_BUF_SET_ADDR(bp, bno)       ((bp)->b_bn = (xfs_daddr_t)(bno))
-#define XFS_BUF_COUNT(bp)               ((bp)->b_count_desired)
-#define XFS_BUF_SET_COUNT(bp, cnt)      ((bp)->b_count_desired = (cnt))
 
 static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)
 {
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 7f0abeaf919c..a25206c84cf9 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -123,11 +123,11 @@ xfs_buf_item_log_check(
         ASSERT(bip->bli_logged != NULL);
 
         bp = bip->bli_buf;
-        ASSERT(XFS_BUF_COUNT(bp) > 0);
+        ASSERT(bp->b_length > 0);
         ASSERT(bp->b_addr != NULL);
         orig = bip->bli_orig;
         buffer = bp->b_addr;
-        for (x = 0; x < XFS_BUF_COUNT(bp); x++) {
+        for (x = 0; x < BBTOB(bp->b_length); x++) {
                 if (orig[x] != buffer[x] && !btst(bip->bli_logged, x)) {
                         xfs_emerg(bp->b_mount,
                                 "%s: bip %x buffer %x orig %x index %d",
@@ -657,7 +657,8 @@ xfs_buf_item_init(
          * truncate any pieces.  map_size is the size of the
          * bitmap needed to describe the chunks of the buffer.
          */
-        chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLF_CHUNK - 1)) >> XFS_BLF_SHIFT);
+        chunks = (int)((BBTOB(bp->b_length) + (XFS_BLF_CHUNK - 1)) >>
+                                                                XFS_BLF_SHIFT);
         map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);
 
         bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
@@ -667,7 +668,7 @@ xfs_buf_item_init(
         xfs_buf_hold(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 = (ushort)BTOBB(XFS_BUF_COUNT(bp));
+        bip->bli_format.blf_len = (ushort)bp->b_length;
         bip->bli_format.blf_map_size = map_size;
 
 #ifdef XFS_TRANS_DEBUG
@@ -679,9 +680,9 @@ xfs_buf_item_init(
          * the buffer to indicate which bytes the callers have asked
          * to have logged.
          */
-        bip->bli_orig = (char *)kmem_alloc(XFS_BUF_COUNT(bp), KM_SLEEP);
-        memcpy(bip->bli_orig, bp->b_addr, XFS_BUF_COUNT(bp));
-        bip->bli_logged = (char *)kmem_zalloc(XFS_BUF_COUNT(bp) / NBBY, KM_SLEEP);
+        bip->bli_orig = kmem_alloc(BBTOB(bp->b_length), KM_SLEEP);
+        memcpy(bip->bli_orig, bp->b_addr, BBTOB(bp->b_length));
+        bip->bli_logged = kmem_zalloc(BBTOB(bp->b_length) / NBBY, KM_SLEEP);
 #endif
 
         /*
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 7f1a6f5b05a6..b8adc79f0d88 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -2277,20 +2277,20 @@ xfs_da_buf_make(int nbuf, xfs_buf_t **bps)
         if (nbuf == 1) {
                 dabuf->nbuf = 1;
                 bp = bps[0];
-                dabuf->bbcount = (short)BTOBB(XFS_BUF_COUNT(bp));
+                dabuf->bbcount = bp->b_length;
                 dabuf->data = bp->b_addr;
                 dabuf->bps[0] = bp;
         } else {
                 dabuf->nbuf = nbuf;
                 for (i = 0, dabuf->bbcount = 0; i < nbuf; i++) {
                         dabuf->bps[i] = bp = bps[i];
-                        dabuf->bbcount += BTOBB(XFS_BUF_COUNT(bp));
+                        dabuf->bbcount += bp->b_length;
                 }
                 dabuf->data = kmem_alloc(BBTOB(dabuf->bbcount), KM_SLEEP);
-                for (i = off = 0; i < nbuf; i++, off += XFS_BUF_COUNT(bp)) {
+                for (i = off = 0; i < nbuf; i++, off += BBTOB(bp->b_length)) {
                         bp = bps[i];
                         memcpy((char *)dabuf->data + off, bp->b_addr,
-                                XFS_BUF_COUNT(bp));
+                                BBTOB(bp->b_length));
                 }
         }
         return dabuf;
@@ -2310,10 +2310,10 @@ xfs_da_buf_clean(xfs_dabuf_t *dabuf)
                 ASSERT(dabuf->nbuf > 1);
                 dabuf->dirty = 0;
                 for (i = off = 0; i < dabuf->nbuf;
-                                i++, off += XFS_BUF_COUNT(bp)) {
+                                i++, off += BBTOB(bp->b_length)) {
                         bp = dabuf->bps[i];
                         memcpy(bp->b_addr, dabuf->data + off,
-                                                XFS_BUF_COUNT(bp));
+                                                BBTOB(bp->b_length));
                 }
         }
 }
@@ -2356,10 +2356,10 @@ xfs_da_log_buf(xfs_trans_t *tp, xfs_dabuf_t *dabuf, uint first, uint last)
         }
         dabuf->dirty = 1;
         ASSERT(first <= last);
-        for (i = off = 0; i < dabuf->nbuf; i++, off += XFS_BUF_COUNT(bp)) {
+        for (i = off = 0; i < dabuf->nbuf; i++, off += BBTOB(bp->b_length)) {
                 bp = dabuf->bps[i];
                 f = off;
-                l = f + XFS_BUF_COUNT(bp) - 1;
+                l = f + BBTOB(bp->b_length) - 1;
                 if (f < first)
                         f = first;
                 if (l > last)
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index f9d8355ffae2..5e2aa526e058 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1487,7 +1487,7 @@ xlog_sync(xlog_t		*log,
         } else {
                 iclog->ic_bwritecnt = 1;
         }
-        XFS_BUF_SET_COUNT(bp, count);
+        bp->b_io_length = BTOBB(count);
         bp->b_fspriv = iclog;
         XFS_BUF_ZEROFLAGS(bp);
         XFS_BUF_ASYNC(bp);
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 24f59a25ecdd..8c826b00aac1 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -178,7 +178,7 @@ xlog_bread_noalign(
 
         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
         XFS_BUF_READ(bp);
-        XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
+        bp->b_io_length = nbblks;
         bp->b_error = 0;
 
         xfsbdstrat(log->l_mp, bp);
@@ -266,7 +266,7 @@ xlog_bwrite(
         XFS_BUF_ZEROFLAGS(bp);
         xfs_buf_hold(bp);
         xfs_buf_lock(bp);
-        XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
+        bp->b_io_length = nbblks;
         bp->b_error = 0;
 
         error = xfs_bwrite(bp);
@@ -1778,7 +1778,7 @@ xlog_recover_do_inode_buffer(
 
         trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
 
-        inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
+        inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
         for (i = 0; i < inodes_per_buf; i++) {
                 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
                         offsetof(xfs_dinode_t, di_next_unlinked);
@@ -1820,7 +1820,8 @@ xlog_recover_do_inode_buffer(
 
                 ASSERT(item->ri_buf[item_index].i_addr != NULL);
                 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
-                ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
+                ASSERT((reg_buf_offset + reg_buf_bytes) <=
+                                                        BBTOB(bp->b_io_length));
 
                 /*
                  * The current logged region contains a copy of the
@@ -1879,8 +1880,8 @@ xlog_recover_do_reg_buffer(
                 ASSERT(nbits > 0);
                 ASSERT(item->ri_buf[i].i_addr != NULL);
                 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
-                ASSERT(XFS_BUF_COUNT(bp) >=
-                       ((uint)bit << XFS_BLF_SHIFT)+(nbits<<XFS_BLF_SHIFT));
+                ASSERT(BBTOB(bp->b_io_length) >=
+                       ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));
 
                 /*
                  * Do a sanity check if this is a dquot buffer. Just checking
@@ -2173,7 +2174,7 @@ xlog_recover_buffer_pass2(
          */
         if (XFS_DINODE_MAGIC ==
             be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
-            (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
+            (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
                         (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
                 xfs_buf_stale(bp);
                 error = xfs_bwrite(bp);
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 9132d162c4b8..2ec196b6c079 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -56,7 +56,7 @@ xfs_trans_buf_item_match(
                 if (blip->bli_item.li_type == XFS_LI_BUF &&
                     blip->bli_buf->b_target == target &&
                     XFS_BUF_ADDR(blip->bli_buf) == blkno &&
-                    XFS_BUF_COUNT(blip->bli_buf) == len)
+                    BBTOB(blip->bli_buf->b_length) == len)
                         return blip->bli_buf;
         }
 
@@ -585,7 +585,7 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
 
         ASSERT(bp->b_transp == tp);
         ASSERT(bip != NULL);
-        ASSERT((first <= last) && (last < XFS_BUF_COUNT(bp)));
+        ASSERT(first <= last && last < BBTOB(bp->b_length));
         ASSERT(bp->b_iodone == NULL ||
                bp->b_iodone == xfs_buf_iodone_callbacks);