block: Abstract out bvec iterator

Immutable biovecs are going to require an explicit iterator. To
implement immutable bvecs, a later patch is going to add a bi_bvec_done
member to this struct; for now, this patch effectively just renames
things.

Signed-off-by: Kent Overstreet <kmo@daterainc.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: "Ed L. Cashin" <ecashin@coraid.com>
Cc: Nick Piggin <npiggin@kernel.dk>
Cc: Lars Ellenberg <drbd-dev@lists.linbit.com>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Matthew Wilcox <willy@linux.intel.com>
Cc: Geoff Levand <geoff@infradead.org>
Cc: Yehuda Sadeh <yehuda@inktank.com>
Cc: Sage Weil <sage@inktank.com>
Cc: Alex Elder <elder@inktank.com>
Cc: ceph-devel@vger.kernel.org
Cc: Joshua Morris <josh.h.morris@us.ibm.com>
Cc: Philip Kelleher <pjk1939@linux.vnet.ibm.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: Jeremy Fitzhardinge <jeremy@goop.org>
Cc: Neil Brown <neilb@suse.de>
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@redhat.com>
Cc: dm-devel@redhat.com
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: linux390@de.ibm.com
Cc: Boaz Harrosh <bharrosh@panasas.com>
Cc: Benny Halevy <bhalevy@tonian.com>
Cc: "James E.J. Bottomley" <JBottomley@parallels.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Nicholas A. Bellinger" <nab@linux-iscsi.org>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Chris Mason <chris.mason@fusionio.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@kernel.org>
Cc: Joern Engel <joern@logfs.org>
Cc: Prasad Joshi <prasadjoshi.linux@gmail.com>
Cc: Trond Myklebust <Trond.Myklebust@netapp.com>
Cc: KONISHI Ryusuke <konishi.ryusuke@lab.ntt.co.jp>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Ben Myers <bpm@sgi.com>
Cc: xfs@oss.sgi.com
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Len Brown <len.brown@intel.com>
Cc: Pavel Machek <pavel@ucw.cz>
Cc: "Rafael J. Wysocki" <rjw@sisk.pl>
Cc: Herton Ronaldo Krzesinski <herton.krzesinski@canonical.com>
Cc: Ben Hutchings <ben@decadent.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Guo Chao <yan@linux.vnet.ibm.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Asai Thambi S P <asamymuthupa@micron.com>
Cc: Selvan Mani <smani@micron.com>
Cc: Sam Bradshaw <sbradshaw@micron.com>
Cc: Wei Yongjun <yongjun_wei@trendmicro.com.cn>
Cc: "Roger Pau Monné" <roger.pau@citrix.com>
Cc: Jan Beulich <jbeulich@suse.com>
Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
Cc: Ian Campbell <Ian.Campbell@citrix.com>
Cc: Sebastian Ott <sebott@linux.vnet.ibm.com>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Jiang Liu <jiang.liu@huawei.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchand@redhat.com>
Cc: Joe Perches <joe@perches.com>
Cc: Peng Tao <tao.peng@emc.com>
Cc: Andy Adamson <andros@netapp.com>
Cc: fanchaoting <fanchaoting@cn.fujitsu.com>
Cc: Jie Liu <jeff.liu@oracle.com>
Cc: Sunil Mushran <sunil.mushran@gmail.com>
Cc: "Martin K. Petersen" <martin.petersen@oracle.com>
Cc: Namjae Jeon <namjae.jeon@samsung.com>
Cc: Pankaj Kumar <pankaj.km@samsung.com>
Cc: Dan Magenheimer <dan.magenheimer@oracle.com>
Cc: Mel Gorman <mgorman@suse.de>6

20 files changed, 89 insertions, 81 deletions

diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index d2515435e23f..877ba119b3f8 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -929,8 +929,8 @@ bufinit(struct buf *buf, struct request *rq, struct bio *bio)
         memset(buf, 0, sizeof(*buf));
         buf->rq = rq;
         buf->bio = bio;
-        buf->resid = bio->bi_size;
-        buf->sector = bio->bi_sector;
+        buf->resid = bio->bi_iter.bi_size;
+        buf->sector = bio->bi_iter.bi_sector;
         bio_pageinc(bio);
         buf->bv = bio_iovec(bio);
         buf->bv_resid = buf->bv->bv_len;
@@ -1152,7 +1152,7 @@ aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
         do {
                 bio = rq->bio;
                 bok = !fastfail && test_bit(BIO_UPTODATE, &bio->bi_flags);
-        } while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_size));
+        } while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_iter.bi_size));
 
         /* cf. http://lkml.org/lkml/2006/10/31/28 */
         if (!fastfail)
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index d91f1a56e861..66f5aaae15a2 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -333,13 +333,13 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
         int i;
         int err = -EIO;
 
-        sector = bio->bi_sector;
+        sector = bio->bi_iter.bi_sector;
         if (bio_end_sector(bio) > get_capacity(bdev->bd_disk))
                 goto out;
 
         if (unlikely(bio->bi_rw & REQ_DISCARD)) {
                 err = 0;
-                discard_from_brd(brd, sector, bio->bi_size);
+                discard_from_brd(brd, sector, bio->bi_iter.bi_size);
                 goto out;
         }
 
diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
index 28c73ca320a8..a9b13f2cc420 100644
--- a/drivers/block/drbd/drbd_actlog.c
+++ b/drivers/block/drbd/drbd_actlog.c
@@ -159,7 +159,7 @@ static int _drbd_md_sync_page_io(struct drbd_conf *mdev,
 
         bio = bio_alloc_drbd(GFP_NOIO);
         bio->bi_bdev = bdev->md_bdev;
-        bio->bi_sector = sector;
+        bio->bi_iter.bi_sector = sector;
         err = -EIO;
         if (bio_add_page(bio, page, size, 0) != size)
                 goto out;
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index b12c11ec4bd2..597f111df67b 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -1028,7 +1028,7 @@ static void bm_page_io_async(struct bm_aio_ctx *ctx, int page_nr, int rw) __must
         } else
                 page = b->bm_pages[page_nr];
         bio->bi_bdev = mdev->ldev->md_bdev;
-        bio->bi_sector = on_disk_sector;
+        bio->bi_iter.bi_sector = on_disk_sector;
         /* bio_add_page of a single page to an empty bio will always succeed,
          * according to api.  Do we want to assert that? */
         bio_add_page(bio, page, len, 0);
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 6fa6673b36b3..5326c22cdb9d 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -1333,7 +1333,7 @@ next_bio:
                 goto fail;
         }
         /* > peer_req->i.sector, unless this is the first bio */
-        bio->bi_sector = sector;
+        bio->bi_iter.bi_sector = sector;
         bio->bi_bdev = mdev->ldev->backing_bdev;
         bio->bi_rw = rw;
         bio->bi_private = peer_req;
@@ -1353,7 +1353,7 @@ next_bio:
                                 dev_err(DEV,
                                         "bio_add_page failed for len=%u, "
                                         "bi_vcnt=0 (bi_sector=%llu)\n",
-                                        len, (unsigned long long)bio->bi_sector);
+                                        len, (uint64_t)bio->bi_iter.bi_sector);
                                 err = -ENOSPC;
                                 goto fail;
                         }
@@ -1615,7 +1615,7 @@ static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req,
         mdev->recv_cnt += data_size>>9;
 
         bio = req->master_bio;
-        D_ASSERT(sector == bio->bi_sector);
+        D_ASSERT(sector == bio->bi_iter.bi_sector);
 
         bio_for_each_segment(bvec, bio, i) {
                 void *mapped = kmap(bvec->bv_page) + bvec->bv_offset;
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index fec7bef44994..104a040f24de 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -77,8 +77,8 @@ static struct drbd_request *drbd_req_new(struct drbd_conf *mdev,
         req->epoch       = 0;
 
         drbd_clear_interval(&req->i);
-        req->i.sector     = bio_src->bi_sector;
-        req->i.size      = bio_src->bi_size;
+        req->i.sector     = bio_src->bi_iter.bi_sector;
+        req->i.size      = bio_src->bi_iter.bi_size;
         req->i.local = true;
         req->i.waiting = false;
 
@@ -1280,7 +1280,7 @@ void drbd_make_request(struct request_queue *q, struct bio *bio)
         /*
          * what we "blindly" assume:
          */
-        D_ASSERT(IS_ALIGNED(bio->bi_size, 512));
+        D_ASSERT(IS_ALIGNED(bio->bi_iter.bi_size, 512));
 
         inc_ap_bio(mdev);
         __drbd_make_request(mdev, bio, start_time);
diff --git a/drivers/block/drbd/drbd_req.h b/drivers/block/drbd/drbd_req.h
index 978cb1addc98..28e15d91197a 100644
--- a/drivers/block/drbd/drbd_req.h
+++ b/drivers/block/drbd/drbd_req.h
@@ -269,7 +269,7 @@ static inline void drbd_req_make_private_bio(struct drbd_request *req, struct bi
 
 /* Short lived temporary struct on the stack.
  * We could squirrel the error to be returned into
- * bio->bi_size, or similar. But that would be too ugly. */
+ * bio->bi_iter.bi_size, or similar. But that would be too ugly. */
 struct bio_and_error {
         struct bio *bio;
         int error;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 000abe2f105c..6a86fe7b730f 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3775,9 +3775,9 @@ static int __floppy_read_block_0(struct block_device *bdev)
         bio_vec.bv_len = size;
         bio_vec.bv_offset = 0;
         bio.bi_vcnt = 1;
-        bio.bi_size = size;
+        bio.bi_iter.bi_size = size;
         bio.bi_bdev = bdev;
-        bio.bi_sector = 0;
+        bio.bi_iter.bi_sector = 0;
         bio.bi_flags = (1 << BIO_QUIET);
         init_completion(&complete);
         bio.bi_private = &complete;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index c8dac7305244..f5e39989adde 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -415,7 +415,7 @@ static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
         loff_t pos;
         int ret;
 
-        pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset;
+        pos = ((loff_t) bio->bi_iter.bi_sector << 9) + lo->lo_offset;
 
         if (bio_rw(bio) == WRITE) {
                 struct file *file = lo->lo_backing_file;
@@ -444,7 +444,7 @@ static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
                                 goto out;
                         }
                         ret = file->f_op->fallocate(file, mode, pos,
-                                                    bio->bi_size);
+                                                    bio->bi_iter.bi_size);
                         if (unlikely(ret && ret != -EINVAL &&
                                      ret != -EOPNOTSUPP))
                                 ret = -EIO;
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 050c71267f14..69e9eb5a6b34 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -3993,7 +3993,7 @@ static void mtip_make_request(struct request_queue *queue, struct bio *bio)
         }
 
         if (unlikely(bio->bi_rw & REQ_DISCARD)) {
-                bio_endio(bio, mtip_send_trim(dd, bio->bi_sector,
+                bio_endio(bio, mtip_send_trim(dd, bio->bi_iter.bi_sector,
                                                 bio_sectors(bio)));
                 return;
         }
@@ -4006,7 +4006,8 @@ static void mtip_make_request(struct request_queue *queue, struct bio *bio)
 
         if (bio_data_dir(bio) == WRITE && bio_sectors(bio) <= 64 &&
                                                         dd->unal_qdepth) {
-                if (bio->bi_sector % 8 != 0) /* Unaligned on 4k boundaries */
+                if (bio->bi_iter.bi_sector % 8 != 0)
+                        /* Unaligned on 4k boundaries */
                         unaligned = 1;
                 else if (bio_sectors(bio) % 8 != 0) /* Aligned but not 4k/8k */
                         unaligned = 1;
@@ -4035,7 +4036,7 @@ static void mtip_make_request(struct request_queue *queue, struct bio *bio)
 
                 /* Issue the read/write. */
                 mtip_hw_submit_io(dd,
-                                bio->bi_sector,
+                                bio->bi_iter.bi_sector,
                                 bio_sectors(bio),
                                 nents,
                                 tag,
diff --git a/drivers/block/nvme-core.c b/drivers/block/nvme-core.c
index 26d03fa0bf26..53d217381873 100644
--- a/drivers/block/nvme-core.c
+++ b/drivers/block/nvme-core.c
@@ -468,7 +468,7 @@ static struct nvme_bio_pair *nvme_bio_split(struct bio *bio, int idx,
 {
         struct nvme_bio_pair *bp;
 
-        BUG_ON(len > bio->bi_size);
+        BUG_ON(len > bio->bi_iter.bi_size);
         BUG_ON(idx > bio->bi_vcnt);
 
         bp = kmalloc(sizeof(*bp), GFP_ATOMIC);
@@ -479,11 +479,11 @@ static struct nvme_bio_pair *nvme_bio_split(struct bio *bio, int idx,
         bp->b1 = *bio;
         bp->b2 = *bio;
 
-        bp->b1.bi_size = len;
-        bp->b2.bi_size -= len;
+        bp->b1.bi_iter.bi_size = len;
+        bp->b2.bi_iter.bi_size -= len;
         bp->b1.bi_vcnt = idx;
-        bp->b2.bi_idx = idx;
-        bp->b2.bi_sector += len >> 9;
+        bp->b2.bi_iter.bi_idx = idx;
+        bp->b2.bi_iter.bi_sector += len >> 9;
 
         if (offset) {
                 bp->bv1 = kmalloc(bio->bi_max_vecs * sizeof(struct bio_vec),
@@ -552,11 +552,12 @@ static int nvme_map_bio(struct nvme_queue *nvmeq, struct nvme_iod *iod,
 {
         struct bio_vec *bvec, *bvprv = NULL;
         struct scatterlist *sg = NULL;
-        int i, length = 0, nsegs = 0, split_len = bio->bi_size;
+        int i, length = 0, nsegs = 0, split_len = bio->bi_iter.bi_size;
 
         if (nvmeq->dev->stripe_size)
                 split_len = nvmeq->dev->stripe_size -
-                        ((bio->bi_sector << 9) & (nvmeq->dev->stripe_size - 1));
+                        ((bio->bi_iter.bi_sector << 9) &
+                         (nvmeq->dev->stripe_size - 1));
 
         sg_init_table(iod->sg, psegs);
         bio_for_each_segment(bvec, bio, i) {
@@ -584,7 +585,7 @@ static int nvme_map_bio(struct nvme_queue *nvmeq, struct nvme_iod *iod,
         if (dma_map_sg(nvmeq->q_dmadev, iod->sg, iod->nents, dma_dir) == 0)
                 return -ENOMEM;
 
-        BUG_ON(length != bio->bi_size);
+        BUG_ON(length != bio->bi_iter.bi_size);
         return length;
 }
 
@@ -608,8 +609,8 @@ static int nvme_submit_discard(struct nvme_queue *nvmeq, struct nvme_ns *ns,
         iod->npages = 0;
 
         range->cattr = cpu_to_le32(0);
-        range->nlb = cpu_to_le32(bio->bi_size >> ns->lba_shift);
-        range->slba = cpu_to_le64(nvme_block_nr(ns, bio->bi_sector));
+        range->nlb = cpu_to_le32(bio->bi_iter.bi_size >> ns->lba_shift);
+        range->slba = cpu_to_le64(nvme_block_nr(ns, bio->bi_iter.bi_sector));
 
         memset(cmnd, 0, sizeof(*cmnd));
         cmnd->dsm.opcode = nvme_cmd_dsm;
@@ -674,7 +675,7 @@ static int nvme_submit_bio_queue(struct nvme_queue *nvmeq, struct nvme_ns *ns,
         }
 
         result = -ENOMEM;
-        iod = nvme_alloc_iod(psegs, bio->bi_size, GFP_ATOMIC);
+        iod = nvme_alloc_iod(psegs, bio->bi_iter.bi_size, GFP_ATOMIC);
         if (!iod)
                 goto nomem;
         iod->private = bio;
@@ -723,7 +724,7 @@ static int nvme_submit_bio_queue(struct nvme_queue *nvmeq, struct nvme_ns *ns,
         cmnd->rw.nsid = cpu_to_le32(ns->ns_id);
         length = nvme_setup_prps(nvmeq->dev, &cmnd->common, iod, length,
                                                                 GFP_ATOMIC);
-        cmnd->rw.slba = cpu_to_le64(nvme_block_nr(ns, bio->bi_sector));
+        cmnd->rw.slba = cpu_to_le64(nvme_block_nr(ns, bio->bi_iter.bi_sector));
         cmnd->rw.length = cpu_to_le16((length >> ns->lba_shift) - 1);
         cmnd->rw.control = cpu_to_le16(control);
         cmnd->rw.dsmgmt = cpu_to_le32(dsmgmt);
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index ff8668c5efb1..ce986bacf7b7 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -651,7 +651,7 @@ static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s
 
         for (;;) {
                 tmp = rb_entry(n, struct pkt_rb_node, rb_node);
-                if (s <= tmp->bio->bi_sector)
+                if (s <= tmp->bio->bi_iter.bi_sector)
                         next = n->rb_left;
                 else
                         next = n->rb_right;
@@ -660,12 +660,12 @@ static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s
                 n = next;
         }
 
-        if (s > tmp->bio->bi_sector) {
+        if (s > tmp->bio->bi_iter.bi_sector) {
                 tmp = pkt_rbtree_next(tmp);
                 if (!tmp)
                         return NULL;
         }
-        BUG_ON(s > tmp->bio->bi_sector);
+        BUG_ON(s > tmp->bio->bi_iter.bi_sector);
         return tmp;
 }
 
@@ -676,13 +676,13 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod
 {
         struct rb_node **p = &pd->bio_queue.rb_node;
         struct rb_node *parent = NULL;
-        sector_t s = node->bio->bi_sector;
+        sector_t s = node->bio->bi_iter.bi_sector;
         struct pkt_rb_node *tmp;
 
         while (*p) {
                 parent = *p;
                 tmp = rb_entry(parent, struct pkt_rb_node, rb_node);
-                if (s < tmp->bio->bi_sector)
+                if (s < tmp->bio->bi_iter.bi_sector)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -857,7 +857,8 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                         spin_lock(&pd->iosched.lock);
                         bio = bio_list_peek(&pd->iosched.write_queue);
                         spin_unlock(&pd->iosched.lock);
-                        if (bio && (bio->bi_sector == pd->iosched.last_write))
+                        if (bio && (bio->bi_iter.bi_sector ==
+                                    pd->iosched.last_write))
                                 need_write_seek = 0;
                         if (need_write_seek && reads_queued) {
                                 if (atomic_read(&pd->cdrw.pending_bios) > 0) {
@@ -888,7 +889,8 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                         continue;
 
                 if (bio_data_dir(bio) == READ)
-                        pd->iosched.successive_reads += bio->bi_size >> 10;
+                        pd->iosched.successive_reads +=
+                                bio->bi_iter.bi_size >> 10;
                 else {
                         pd->iosched.successive_reads = 0;
                         pd->iosched.last_write = bio_end_sector(bio);
@@ -978,7 +980,7 @@ static void pkt_end_io_read(struct bio *bio, int err)
 
         pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
                 bio, (unsigned long long)pkt->sector,
-                (unsigned long long)bio->bi_sector, err);
+                (unsigned long long)bio->bi_iter.bi_sector, err);
 
         if (err)
                 atomic_inc(&pkt->io_errors);
@@ -1026,8 +1028,9 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
         memset(written, 0, sizeof(written));
         spin_lock(&pkt->lock);
         bio_list_for_each(bio, &pkt->orig_bios) {
-                int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
-                int num_frames = bio->bi_size / CD_FRAMESIZE;
+                int first_frame = (bio->bi_iter.bi_sector - pkt->sector) /
+                        (CD_FRAMESIZE >> 9);
+                int num_frames = bio->bi_iter.bi_size / CD_FRAMESIZE;
                 pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9);
                 BUG_ON(first_frame < 0);
                 BUG_ON(first_frame + num_frames > pkt->frames);
@@ -1053,7 +1056,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
 
                 bio = pkt->r_bios[f];
                 bio_reset(bio);
-                bio->bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
+                bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
                 bio->bi_bdev = pd->bdev;
                 bio->bi_end_io = pkt_end_io_read;
                 bio->bi_private = pkt;
@@ -1150,8 +1153,8 @@ static int pkt_start_recovery(struct packet_data *pkt)
         bio_reset(pkt->bio);
         pkt->bio->bi_bdev = pd->bdev;
         pkt->bio->bi_rw = REQ_WRITE;
-        pkt->bio->bi_sector = new_sector;
-        pkt->bio->bi_size = pkt->frames * CD_FRAMESIZE;
+        pkt->bio->bi_iter.bi_sector = new_sector;
+        pkt->bio->bi_iter.bi_size = pkt->frames * CD_FRAMESIZE;
         pkt->bio->bi_vcnt = pkt->frames;
 
         pkt->bio->bi_end_io = pkt_end_io_packet_write;
@@ -1213,7 +1216,7 @@ static int pkt_handle_queue(struct pktcdvd_device *pd)
         node = first_node;
         while (node) {
                 bio = node->bio;
-                zone = get_zone(bio->bi_sector, pd);
+                zone = get_zone(bio->bi_iter.bi_sector, pd);
                 list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) {
                         if (p->sector == zone) {
                                 bio = NULL;
@@ -1252,14 +1255,14 @@ try_next_bio:
         pkt_dbg(2, pd, "looking for zone %llx\n", (unsigned long long)zone);
         while ((node = pkt_rbtree_find(pd, zone)) != NULL) {
                 bio = node->bio;
-                pkt_dbg(2, pd, "found zone=%llx\n",
-                        (unsigned long long)get_zone(bio->bi_sector, pd));
-                if (get_zone(bio->bi_sector, pd) != zone)
+                pkt_dbg(2, pd, "found zone=%llx\n", (unsigned long long)
+                        get_zone(bio->bi_iter.bi_sector, pd));
+                if (get_zone(bio->bi_iter.bi_sector, pd) != zone)
                         break;
                 pkt_rbtree_erase(pd, node);
                 spin_lock(&pkt->lock);
                 bio_list_add(&pkt->orig_bios, bio);
-                pkt->write_size += bio->bi_size / CD_FRAMESIZE;
+                pkt->write_size += bio->bi_iter.bi_size / CD_FRAMESIZE;
                 spin_unlock(&pkt->lock);
         }
         /* check write congestion marks, and if bio_queue_size is
@@ -1293,7 +1296,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
         struct bio_vec *bvec = pkt->w_bio->bi_io_vec;
 
         bio_reset(pkt->w_bio);
-        pkt->w_bio->bi_sector = pkt->sector;
+        pkt->w_bio->bi_iter.bi_sector = pkt->sector;
         pkt->w_bio->bi_bdev = pd->bdev;
         pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
         pkt->w_bio->bi_private = pkt;
@@ -2370,20 +2373,20 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
 
         if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
                 pkt_notice(pd, "WRITE for ro device (%llu)\n",
-                           (unsigned long long)bio->bi_sector);
+                           (unsigned long long)bio->bi_iter.bi_sector);
                 goto end_io;
         }
 
-        if (!bio->bi_size || (bio->bi_size % CD_FRAMESIZE)) {
+        if (!bio->bi_iter.bi_size || (bio->bi_iter.bi_size % CD_FRAMESIZE)) {
                 pkt_err(pd, "wrong bio size\n");
                 goto end_io;
         }
 
         blk_queue_bounce(q, &bio);
 
-        zone = get_zone(bio->bi_sector, pd);
+        zone = get_zone(bio->bi_iter.bi_sector, pd);
         pkt_dbg(2, pd, "start = %6llx stop = %6llx\n",
-                (unsigned long long)bio->bi_sector,
+                (unsigned long long)bio->bi_iter.bi_sector,
                 (unsigned long long)bio_end_sector(bio));
 
         /* Check if we have to split the bio */
@@ -2395,7 +2398,7 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                 last_zone = get_zone(bio_end_sector(bio) - 1, pd);
                 if (last_zone != zone) {
                         BUG_ON(last_zone != zone + pd->settings.size);
-                        first_sectors = last_zone - bio->bi_sector;
+                        first_sectors = last_zone - bio->bi_iter.bi_sector;
                         bp = bio_split(bio, first_sectors);
                         BUG_ON(!bp);
                         pkt_make_request(q, &bp->bio1);
@@ -2417,7 +2420,8 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                         if ((pkt->state == PACKET_WAITING_STATE) ||
                             (pkt->state == PACKET_READ_WAIT_STATE)) {
                                 bio_list_add(&pkt->orig_bios, bio);
-                                pkt->write_size += bio->bi_size / CD_FRAMESIZE;
+                                pkt->write_size +=
+                                        bio->bi_iter.bi_size / CD_FRAMESIZE;
                                 if ((pkt->write_size >= pkt->frames) &&
                                     (pkt->state == PACKET_WAITING_STATE)) {
                                         atomic_inc(&pkt->run_sm);
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index d754a88d7585..464be78a0836 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -104,7 +104,7 @@ static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
                 dev_dbg(&dev->sbd.core,
                         "%s:%u: bio %u: %u segs %u sectors from %lu\n",
                         __func__, __LINE__, i, bio_segments(iter.bio),
-                        bio_sectors(iter.bio), iter.bio->bi_sector);
+                        bio_sectors(iter.bio), iter.bio->bi_iter.bi_sector);
 
                 size = bvec->bv_len;
                 buf = bvec_kmap_irq(bvec, &flags);
diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
index 06a2e53e5f37..320bbfc9b902 100644
--- a/drivers/block/ps3vram.c
+++ b/drivers/block/ps3vram.c
@@ -553,7 +553,7 @@ static struct bio *ps3vram_do_bio(struct ps3_system_bus_device *dev,
         struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
         int write = bio_data_dir(bio) == WRITE;
         const char *op = write ? "write" : "read";
-        loff_t offset = bio->bi_sector << 9;
+        loff_t offset = bio->bi_iter.bi_sector << 9;
         int error = 0;
         struct bio_vec *bvec;
         unsigned int i;
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index cb1db2979d3d..a8f4fe2d4d1b 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -1183,14 +1183,14 @@ static struct bio *bio_clone_range(struct bio *bio_src,
 
         /* Handle the easy case for the caller */
 
-        if (!offset && len == bio_src->bi_size)
+        if (!offset && len == bio_src->bi_iter.bi_size)
                 return bio_clone(bio_src, gfpmask);
 
         if (WARN_ON_ONCE(!len))
                 return NULL;
-        if (WARN_ON_ONCE(len > bio_src->bi_size))
+        if (WARN_ON_ONCE(len > bio_src->bi_iter.bi_size))
                 return NULL;
-        if (WARN_ON_ONCE(offset > bio_src->bi_size - len))
+        if (WARN_ON_ONCE(offset > bio_src->bi_iter.bi_size - len))
                 return NULL;
 
         /* Find first affected segment... */
@@ -1220,7 +1220,8 @@ static struct bio *bio_clone_range(struct bio *bio_src,
                 return NULL;    /* ENOMEM */
 
         bio->bi_bdev = bio_src->bi_bdev;
-        bio->bi_sector = bio_src->bi_sector + (offset >> SECTOR_SHIFT);
+        bio->bi_iter.bi_sector = bio_src->bi_iter.bi_sector +
+                (offset >> SECTOR_SHIFT);
         bio->bi_rw = bio_src->bi_rw;
         bio->bi_flags |= 1 << BIO_CLONED;
 
@@ -1239,8 +1240,7 @@ static struct bio *bio_clone_range(struct bio *bio_src,
         }
 
         bio->bi_vcnt = vcnt;
-        bio->bi_size = len;
-        bio->bi_idx = 0;
+        bio->bi_iter.bi_size = len;
 
         return bio;
 }
@@ -1271,7 +1271,7 @@ static struct bio *bio_chain_clone_range(struct bio **bio_src,
 
         /* Build up a chain of clone bios up to the limit */
 
-        if (!bi || off >= bi->bi_size || !len)
+        if (!bi || off >= bi->bi_iter.bi_size || !len)
                 return NULL;            /* Nothing to clone */
 
         end = &chain;
@@ -1283,7 +1283,7 @@ static struct bio *bio_chain_clone_range(struct bio **bio_src,
                         rbd_warn(NULL, "bio_chain exhausted with %u left", len);
                         goto out_err;   /* EINVAL; ran out of bio's */
                 }
-                bi_size = min_t(unsigned int, bi->bi_size - off, len);
+                bi_size = min_t(unsigned int, bi->bi_iter.bi_size - off, len);
                 bio = bio_clone_range(bi, off, bi_size, gfpmask);
                 if (!bio)
                         goto out_err;   /* ENOMEM */
@@ -1292,7 +1292,7 @@ static struct bio *bio_chain_clone_range(struct bio **bio_src,
                 end = &bio->bi_next;
 
                 off += bi_size;
-                if (off == bi->bi_size) {
+                if (off == bi->bi_iter.bi_size) {
                         bi = bi->bi_next;
                         off = 0;
                 }
@@ -2186,7 +2186,8 @@ static int rbd_img_request_fill(struct rbd_img_request *img_request,
 
         if (type == OBJ_REQUEST_BIO) {
                 bio_list = data_desc;
-                rbd_assert(img_offset == bio_list->bi_sector << SECTOR_SHIFT);
+                rbd_assert(img_offset ==
+                           bio_list->bi_iter.bi_sector << SECTOR_SHIFT);
         } else {
                 rbd_assert(type == OBJ_REQUEST_PAGES);
                 pages = data_desc;
diff --git a/drivers/block/rsxx/dev.c b/drivers/block/rsxx/dev.c
index 2284f5d3a54a..2839d37e5af7 100644
--- a/drivers/block/rsxx/dev.c
+++ b/drivers/block/rsxx/dev.c
@@ -174,7 +174,7 @@ static void rsxx_make_request(struct request_queue *q, struct bio *bio)
         if (!card)
                 goto req_err;
 
-        if (bio->bi_sector + (bio->bi_size >> 9) > get_capacity(card->gendisk))
+        if (bio_end_sector(bio) > get_capacity(card->gendisk))
                 goto req_err;
 
         if (unlikely(card->halt)) {
@@ -187,7 +187,7 @@ static void rsxx_make_request(struct request_queue *q, struct bio *bio)
                 goto req_err;
         }
 
-        if (bio->bi_size == 0) {
+        if (bio->bi_iter.bi_size == 0) {
                 dev_err(CARD_TO_DEV(card), "size zero BIO!\n");
                 goto req_err;
         }
@@ -208,7 +208,7 @@ static void rsxx_make_request(struct request_queue *q, struct bio *bio)
 
         dev_dbg(CARD_TO_DEV(card), "BIO[%c]: meta: %p addr8: x%llx size: %d\n",
                  bio_data_dir(bio) ? 'W' : 'R', bio_meta,
-                 (u64)bio->bi_sector << 9, bio->bi_size);
+                 (u64)bio->bi_iter.bi_sector << 9, bio->bi_iter.bi_size);
 
         st = rsxx_dma_queue_bio(card, bio, &bio_meta->pending_dmas,
                                     bio_dma_done_cb, bio_meta);
diff --git a/drivers/block/rsxx/dma.c b/drivers/block/rsxx/dma.c
index fc88ba3e1bd2..3716633be3c2 100644
--- a/drivers/block/rsxx/dma.c
+++ b/drivers/block/rsxx/dma.c
@@ -696,7 +696,7 @@ int rsxx_dma_queue_bio(struct rsxx_cardinfo *card,
         int st;
         int i;
 
-        addr8 = bio->bi_sector << 9; /* sectors are 512 bytes */
+        addr8 = bio->bi_iter.bi_sector << 9; /* sectors are 512 bytes */
         atomic_set(n_dmas, 0);
 
         for (i = 0; i < card->n_targets; i++) {
@@ -705,7 +705,7 @@ int rsxx_dma_queue_bio(struct rsxx_cardinfo *card,
         }
 
         if (bio->bi_rw & REQ_DISCARD) {
-                bv_len = bio->bi_size;
+                bv_len = bio->bi_iter.bi_size;
 
                 while (bv_len > 0) {
                         tgt   = rsxx_get_dma_tgt(card, addr8);
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index ad70868f8a96..dab4f1afeae9 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -352,8 +352,8 @@ static int add_bio(struct cardinfo *card)
         bio = card->currentbio;
         if (!bio && card->bio) {
                 card->currentbio = card->bio;
-                card->current_idx = card->bio->bi_idx;
-                card->current_sector = card->bio->bi_sector;
+                card->current_idx = card->bio->bi_iter.bi_idx;
+                card->current_sector = card->bio->bi_iter.bi_sector;
                 card->bio = card->bio->bi_next;
                 if (card->bio == NULL)
                         card->biotail = &card->bio;
@@ -451,7 +451,7 @@ static void process_page(unsigned long data)
                 if (page->idx >= bio->bi_vcnt) {
                         page->bio = bio->bi_next;
                         if (page->bio)
-                                page->idx = page->bio->bi_idx;
+                                page->idx = page->bio->bi_iter.bi_idx;
                 }
 
                 pci_unmap_page(card->dev, desc->data_dma_handle,
@@ -532,7 +532,8 @@ static void mm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct cardinfo *card = q->queuedata;
         pr_debug("mm_make_request %llu %u\n",
-                 (unsigned long long)bio->bi_sector, bio->bi_size);
+                 (unsigned long long)bio->bi_iter.bi_sector,
+                 bio->bi_iter.bi_size);
 
         spin_lock_irq(&card->lock);
         *card->biotail = bio;
diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
index 6620b73d0490..4b97b86da926 100644
--- a/drivers/block/xen-blkback/blkback.c
+++ b/drivers/block/xen-blkback/blkback.c
@@ -1257,7 +1257,7 @@ static int dispatch_rw_block_io(struct xen_blkif *blkif,
                         bio->bi_bdev    = preq.bdev;
                         bio->bi_private = pending_req;
                         bio->bi_end_io  = end_block_io_op;
-                        bio->bi_sector  = preq.sector_number;
+                        bio->bi_iter.bi_sector  = preq.sector_number;
                 }
 
                 preq.sector_number += seg[i].nsec;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 432db1b59b00..80e86307dd4b 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -1547,7 +1547,7 @@ static int blkif_recover(struct blkfront_info *info)
                         for (i = 0; i < pending; i++) {
                                 offset = (i * segs * PAGE_SIZE) >> 9;
                                 size = min((unsigned int)(segs * PAGE_SIZE) >> 9,
-                                           (unsigned int)(bio->bi_size >> 9) - offset);
+                                           (unsigned int)bio_sectors(bio) - offset);
                                 cloned_bio = bio_clone(bio, GFP_NOIO);
                                 BUG_ON(cloned_bio == NULL);
                                 bio_trim(cloned_bio, offset, size);