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

27 files changed, 146 insertions, 137 deletions

diff --git a/fs/bio-integrity.c b/fs/bio-integrity.c
index fc60b31453ee..08e3d1388c65 100644
--- a/fs/bio-integrity.c
+++ b/fs/bio-integrity.c
@@ -215,9 +215,9 @@ unsigned int bio_integrity_tag_size(struct bio *bio)
 {
         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 
-        BUG_ON(bio->bi_size == 0);
+        BUG_ON(bio->bi_iter.bi_size == 0);
 
-        return bi->tag_size * (bio->bi_size / bi->sector_size);
+        return bi->tag_size * (bio->bi_iter.bi_size / bi->sector_size);
 }
 EXPORT_SYMBOL(bio_integrity_tag_size);
 
@@ -300,7 +300,7 @@ static void bio_integrity_generate(struct bio *bio)
         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
         struct blk_integrity_exchg bix;
         struct bio_vec *bv;
-        sector_t sector = bio->bi_sector;
+        sector_t sector = bio->bi_iter.bi_sector;
         unsigned int i, sectors, total;
         void *prot_buf = bio->bi_integrity->bip_buf;
 
@@ -387,7 +387,7 @@ int bio_integrity_prep(struct bio *bio)
         bip->bip_owns_buf = 1;
         bip->bip_buf = buf;
         bip->bip_size = len;
-        bip->bip_sector = bio->bi_sector;
+        bip->bip_sector = bio->bi_iter.bi_sector;
 
         /* Map it */
         offset = offset_in_page(buf);
diff --git a/fs/bio.c b/fs/bio.c
index 33d79a4eb92d..a402ad6e753f 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -532,13 +532,13 @@ void __bio_clone(struct bio *bio, struct bio *bio_src)
          * most users will be overriding ->bi_bdev with a new target,
          * so we don't set nor calculate new physical/hw segment counts here
          */
-        bio->bi_sector = bio_src->bi_sector;
+        bio->bi_iter.bi_sector = bio_src->bi_iter.bi_sector;
         bio->bi_bdev = bio_src->bi_bdev;
         bio->bi_flags |= 1 << BIO_CLONED;
         bio->bi_rw = bio_src->bi_rw;
         bio->bi_vcnt = bio_src->bi_vcnt;
-        bio->bi_size = bio_src->bi_size;
-        bio->bi_idx = bio_src->bi_idx;
+        bio->bi_iter.bi_size = bio_src->bi_iter.bi_size;
+        bio->bi_iter.bi_idx = bio_src->bi_iter.bi_idx;
 }
 EXPORT_SYMBOL(__bio_clone);
 
@@ -612,7 +612,7 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
         if (unlikely(bio_flagged(bio, BIO_CLONED)))
                 return 0;
 
-        if (((bio->bi_size + len) >> 9) > max_sectors)
+        if (((bio->bi_iter.bi_size + len) >> 9) > max_sectors)
                 return 0;
 
         /*
@@ -635,8 +635,9 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
                                            simulate merging updated prev_bvec
                                            as new bvec. */
                                         .bi_bdev = bio->bi_bdev,
-                                        .bi_sector = bio->bi_sector,
-                                        .bi_size = bio->bi_size - prev_bv_len,
+                                        .bi_sector = bio->bi_iter.bi_sector,
+                                        .bi_size = bio->bi_iter.bi_size -
+                                                prev_bv_len,
                                         .bi_rw = bio->bi_rw,
                                 };
 
@@ -684,8 +685,8 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
         if (q->merge_bvec_fn) {
                 struct bvec_merge_data bvm = {
                         .bi_bdev = bio->bi_bdev,
-                        .bi_sector = bio->bi_sector,
-                        .bi_size = bio->bi_size,
+                        .bi_sector = bio->bi_iter.bi_sector,
+                        .bi_size = bio->bi_iter.bi_size,
                         .bi_rw = bio->bi_rw,
                 };
 
@@ -708,7 +709,7 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
         bio->bi_vcnt++;
         bio->bi_phys_segments++;
  done:
-        bio->bi_size += len;
+        bio->bi_iter.bi_size += len;
         return len;
 }
 
@@ -807,22 +808,22 @@ void bio_advance(struct bio *bio, unsigned bytes)
         if (bio_integrity(bio))
                 bio_integrity_advance(bio, bytes);
 
-        bio->bi_sector += bytes >> 9;
-        bio->bi_size -= bytes;
+        bio->bi_iter.bi_sector += bytes >> 9;
+        bio->bi_iter.bi_size -= bytes;
 
         if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
                 return;
 
         while (bytes) {
-                if (unlikely(bio->bi_idx >= bio->bi_vcnt)) {
+                if (unlikely(bio->bi_iter.bi_idx >= bio->bi_vcnt)) {
                         WARN_ONCE(1, "bio idx %d >= vcnt %d\n",
-                                  bio->bi_idx, bio->bi_vcnt);
+                                  bio->bi_iter.bi_idx, bio->bi_vcnt);
                         break;
                 }
 
                 if (bytes >= bio_iovec(bio)->bv_len) {
                         bytes -= bio_iovec(bio)->bv_len;
-                        bio->bi_idx++;
+                        bio->bi_iter.bi_idx++;
                 } else {
                         bio_iovec(bio)->bv_len -= bytes;
                         bio_iovec(bio)->bv_offset += bytes;
@@ -1485,7 +1486,7 @@ struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
         if (IS_ERR(bio))
                 return bio;
 
-        if (bio->bi_size == len)
+        if (bio->bi_iter.bi_size == len)
                 return bio;
 
         /*
@@ -1763,16 +1764,16 @@ struct bio_pair *bio_split(struct bio *bi, int first_sectors)
                 return bp;
 
         trace_block_split(bdev_get_queue(bi->bi_bdev), bi,
-                                bi->bi_sector + first_sectors);
+                                bi->bi_iter.bi_sector + first_sectors);
 
         BUG_ON(bio_segments(bi) > 1);
         atomic_set(&bp->cnt, 3);
         bp->error = 0;
         bp->bio1 = *bi;
         bp->bio2 = *bi;
-        bp->bio2.bi_sector += first_sectors;
-        bp->bio2.bi_size -= first_sectors << 9;
-        bp->bio1.bi_size = first_sectors << 9;
+        bp->bio2.bi_iter.bi_sector += first_sectors;
+        bp->bio2.bi_iter.bi_size -= first_sectors << 9;
+        bp->bio1.bi_iter.bi_size = first_sectors << 9;
 
         if (bi->bi_vcnt != 0) {
                 bp->bv1 = *bio_iovec(bi);
@@ -1821,21 +1822,22 @@ void bio_trim(struct bio *bio, int offset, int size)
         int sofar = 0;
 
         size <<= 9;
-        if (offset == 0 && size == bio->bi_size)
+        if (offset == 0 && size == bio->bi_iter.bi_size)
                 return;
 
         clear_bit(BIO_SEG_VALID, &bio->bi_flags);
 
         bio_advance(bio, offset << 9);
 
-        bio->bi_size = size;
+        bio->bi_iter.bi_size = size;
 
         /* avoid any complications with bi_idx being non-zero*/
-        if (bio->bi_idx) {
-                memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_idx,
-                        (bio->bi_vcnt - bio->bi_idx) * sizeof(struct bio_vec));
-                bio->bi_vcnt -= bio->bi_idx;
-                bio->bi_idx = 0;
+        if (bio->bi_iter.bi_idx) {
+                memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_iter.bi_idx,
+                        (bio->bi_vcnt - bio->bi_iter.bi_idx) *
+                        sizeof(struct bio_vec));
+                bio->bi_vcnt -= bio->bi_iter.bi_idx;
+                bio->bi_iter.bi_idx = 0;
         }
         /* Make sure vcnt and last bv are not too big */
         bio_for_each_segment(bvec, bio, i) {
@@ -1871,7 +1873,7 @@ sector_t bio_sector_offset(struct bio *bio, unsigned short index,
         sector_sz = queue_logical_block_size(bio->bi_bdev->bd_disk->queue);
         sectors = 0;
 
-        if (index >= bio->bi_idx)
+        if (index >= bio->bi_iter.bi_idx)
                 index = bio->bi_vcnt - 1;
 
         bio_for_each_segment_all(bv, bio, i) {
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 131d82800b3a..cb05e1c842c5 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -1695,7 +1695,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                         return -1;
                 }
                 bio->bi_bdev = block_ctx->dev->bdev;
-                bio->bi_sector = dev_bytenr >> 9;
+                bio->bi_iter.bi_sector = dev_bytenr >> 9;
 
                 for (j = i; j < num_pages; j++) {
                         ret = bio_add_page(bio, block_ctx->pagev[j],
@@ -3013,7 +3013,7 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
                 int bio_is_patched;
                 char **mapped_datav;
 
-                dev_bytenr = 512 * bio->bi_sector;
+                dev_bytenr = 512 * bio->bi_iter.bi_sector;
                 bio_is_patched = 0;
                 if (dev_state->state->print_mask &
                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
@@ -3021,8 +3021,8 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
                                "submit_bio(rw=0x%x, bi_vcnt=%u,"
                                " bi_sector=%llu (bytenr %llu), bi_bdev=%p)\n",
                                rw, bio->bi_vcnt,
-                               (unsigned long long)bio->bi_sector, dev_bytenr,
-                               bio->bi_bdev);
+                               (unsigned long long)bio->bi_iter.bi_sector,
+                               dev_bytenr, bio->bi_bdev);
 
                 mapped_datav = kmalloc(sizeof(*mapped_datav) * bio->bi_vcnt,
                                        GFP_NOFS);
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index eac6784e43d7..f5cdeb4b5538 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -172,7 +172,8 @@ static void end_compressed_bio_read(struct bio *bio, int err)
                 goto out;
 
         inode = cb->inode;
-        ret = check_compressed_csum(inode, cb, (u64)bio->bi_sector << 9);
+        ret = check_compressed_csum(inode, cb,
+                                    (u64)bio->bi_iter.bi_sector << 9);
         if (ret)
                 goto csum_failed;
 
@@ -370,7 +371,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {
                 page = compressed_pages[pg_index];
                 page->mapping = inode->i_mapping;
-                if (bio->bi_size)
+                if (bio->bi_iter.bi_size)
                         ret = io_tree->ops->merge_bio_hook(WRITE, page, 0,
                                                            PAGE_CACHE_SIZE,
                                                            bio, 0);
@@ -504,7 +505,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
 
                 if (!em || last_offset < em->start ||
                     (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) ||
-                    (em->block_start >> 9) != cb->orig_bio->bi_sector) {
+                    (em->block_start >> 9) != cb->orig_bio->bi_iter.bi_sector) {
                         free_extent_map(em);
                         unlock_extent(tree, last_offset, end);
                         unlock_page(page);
@@ -550,7 +551,7 @@ next:
  * in it.  We don't actually do IO on those pages but allocate new ones
  * to hold the compressed pages on disk.
  *
- * bio->bi_sector points to the compressed extent on disk
+ * bio->bi_iter.bi_sector points to the compressed extent on disk
  * bio->bi_io_vec points to all of the inode pages
  * bio->bi_vcnt is a count of pages
  *
@@ -571,7 +572,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         struct page *page;
         struct block_device *bdev;
         struct bio *comp_bio;
-        u64 cur_disk_byte = (u64)bio->bi_sector << 9;
+        u64 cur_disk_byte = (u64)bio->bi_iter.bi_sector << 9;
         u64 em_len;
         u64 em_start;
         struct extent_map *em;
@@ -657,7 +658,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                 page->mapping = inode->i_mapping;
                 page->index = em_start >> PAGE_CACHE_SHIFT;
 
-                if (comp_bio->bi_size)
+                if (comp_bio->bi_iter.bi_size)
                         ret = tree->ops->merge_bio_hook(READ, page, 0,
                                                         PAGE_CACHE_SIZE,
                                                         comp_bio, 0);
@@ -685,8 +686,8 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                                         comp_bio, sums);
                                 BUG_ON(ret); /* -ENOMEM */
                         }
-                        sums += (comp_bio->bi_size + root->sectorsize - 1) /
-                                root->sectorsize;
+                        sums += (comp_bio->bi_iter.bi_size +
+                                 root->sectorsize - 1) / root->sectorsize;
 
                         ret = btrfs_map_bio(root, READ, comp_bio,
                                             mirror_num, 0);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 8b5f9e1d1f0e..bcb6f1b780d6 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1984,7 +1984,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
         bio = btrfs_io_bio_alloc(GFP_NOFS, 1);
         if (!bio)
                 return -EIO;
-        bio->bi_size = 0;
+        bio->bi_iter.bi_size = 0;
         map_length = length;
 
         ret = btrfs_map_block(fs_info, WRITE, logical,
@@ -1995,7 +1995,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
         }
         BUG_ON(mirror_num != bbio->mirror_num);
         sector = bbio->stripes[mirror_num-1].physical >> 9;
-        bio->bi_sector = sector;
+        bio->bi_iter.bi_sector = sector;
         dev = bbio->stripes[mirror_num-1].dev;
         kfree(bbio);
         if (!dev || !dev->bdev || !dev->writeable) {
@@ -2268,9 +2268,9 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
                 return -EIO;
         }
         bio->bi_end_io = failed_bio->bi_end_io;
-        bio->bi_sector = failrec->logical >> 9;
+        bio->bi_iter.bi_sector = failrec->logical >> 9;
         bio->bi_bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
-        bio->bi_size = 0;
+        bio->bi_iter.bi_size = 0;
 
         btrfs_failed_bio = btrfs_io_bio(failed_bio);
         if (btrfs_failed_bio->csum) {
@@ -2412,7 +2412,7 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
                 struct inode *inode = page->mapping->host;
 
                 pr_debug("end_bio_extent_readpage: bi_sector=%llu, err=%d, "
-                         "mirror=%lu\n", (u64)bio->bi_sector, err,
+                         "mirror=%lu\n", (u64)bio->bi_iter.bi_sector, err,
                          io_bio->mirror_num);
                 tree = &BTRFS_I(inode)->io_tree;
 
@@ -2543,7 +2543,7 @@ btrfs_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs,
 
         if (bio) {
                 bio->bi_bdev = bdev;
-                bio->bi_sector = first_sector;
+                bio->bi_iter.bi_sector = first_sector;
                 btrfs_bio = btrfs_io_bio(bio);
                 btrfs_bio->csum = NULL;
                 btrfs_bio->csum_allocated = NULL;
@@ -2637,7 +2637,7 @@ static int submit_extent_page(int rw, struct extent_io_tree *tree,
         if (bio_ret && *bio_ret) {
                 bio = *bio_ret;
                 if (old_compressed)
-                        contig = bio->bi_sector == sector;
+                        contig = bio->bi_iter.bi_sector == sector;
                 else
                         contig = bio_end_sector(bio) == sector;
 
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 6f3848860283..84a46a42d262 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -182,7 +182,7 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
         if (!path)
                 return -ENOMEM;
 
-        nblocks = bio->bi_size >> inode->i_sb->s_blocksize_bits;
+        nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
         if (!dst) {
                 if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
                         btrfs_bio->csum_allocated = kmalloc(nblocks * csum_size,
@@ -201,7 +201,7 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
                 csum = (u8 *)dst;
         }
 
-        if (bio->bi_size > PAGE_CACHE_SIZE * 8)
+        if (bio->bi_iter.bi_size > PAGE_CACHE_SIZE * 8)
                 path->reada = 2;
 
         WARN_ON(bio->bi_vcnt <= 0);
@@ -217,7 +217,7 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
                 path->skip_locking = 1;
         }
 
-        disk_bytenr = (u64)bio->bi_sector << 9;
+        disk_bytenr = (u64)bio->bi_iter.bi_sector << 9;
         if (dio)
                 offset = logical_offset;
         while (bio_index < bio->bi_vcnt) {
@@ -302,7 +302,7 @@ int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
                               struct btrfs_dio_private *dip, struct bio *bio,
                               u64 offset)
 {
-        int len = (bio->bi_sector << 9) - dip->disk_bytenr;
+        int len = (bio->bi_iter.bi_sector << 9) - dip->disk_bytenr;
         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
         int ret;
 
@@ -447,11 +447,12 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
         u64 offset;
 
         WARN_ON(bio->bi_vcnt <= 0);
-        sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_size), GFP_NOFS);
+        sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_iter.bi_size),
+                       GFP_NOFS);
         if (!sums)
                 return -ENOMEM;
 
-        sums->len = bio->bi_size;
+        sums->len = bio->bi_iter.bi_size;
         INIT_LIST_HEAD(&sums->list);
 
         if (contig)
@@ -461,7 +462,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
 
         ordered = btrfs_lookup_ordered_extent(inode, offset);
         BUG_ON(!ordered); /* Logic error */
-        sums->bytenr = (u64)bio->bi_sector << 9;
+        sums->bytenr = (u64)bio->bi_iter.bi_sector << 9;
         index = 0;
 
         while (bio_index < bio->bi_vcnt) {
@@ -476,7 +477,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
                         btrfs_add_ordered_sum(inode, ordered, sums);
                         btrfs_put_ordered_extent(ordered);
 
-                        bytes_left = bio->bi_size - total_bytes;
+                        bytes_left = bio->bi_iter.bi_size - total_bytes;
 
                         sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left),
                                        GFP_NOFS);
@@ -484,7 +485,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
                         sums->len = bytes_left;
                         ordered = btrfs_lookup_ordered_extent(inode, offset);
                         BUG_ON(!ordered); /* Logic error */
-                        sums->bytenr = ((u64)bio->bi_sector << 9) +
+                        sums->bytenr = ((u64)bio->bi_iter.bi_sector << 9) +
                                        total_bytes;
                         index = 0;
                 }
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index d6630dc130ba..7ab0e94ad492 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1577,7 +1577,7 @@ int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
                          unsigned long bio_flags)
 {
         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
-        u64 logical = (u64)bio->bi_sector << 9;
+        u64 logical = (u64)bio->bi_iter.bi_sector << 9;
         u64 length = 0;
         u64 map_length;
         int ret;
@@ -1585,7 +1585,7 @@ int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
         if (bio_flags & EXTENT_BIO_COMPRESSED)
                 return 0;
 
-        length = bio->bi_size;
+        length = bio->bi_iter.bi_size;
         map_length = length;
         ret = btrfs_map_block(root->fs_info, rw, logical,
                               &map_length, NULL, 0);
@@ -6894,7 +6894,8 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
                 printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
                       "sector %#Lx len %u err no %d\n",
                       btrfs_ino(dip->inode), bio->bi_rw,
-                      (unsigned long long)bio->bi_sector, bio->bi_size, err);
+                      (unsigned long long)bio->bi_iter.bi_sector,
+                      bio->bi_iter.bi_size, err);
                 dip->errors = 1;
 
                 /*
@@ -6985,7 +6986,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
         struct bio *bio;
         struct bio *orig_bio = dip->orig_bio;
         struct bio_vec *bvec = orig_bio->bi_io_vec;
-        u64 start_sector = orig_bio->bi_sector;
+        u64 start_sector = orig_bio->bi_iter.bi_sector;
         u64 file_offset = dip->logical_offset;
         u64 submit_len = 0;
         u64 map_length;
@@ -6993,7 +6994,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
         int ret = 0;
         int async_submit = 0;
 
-        map_length = orig_bio->bi_size;
+        map_length = orig_bio->bi_iter.bi_size;
         ret = btrfs_map_block(root->fs_info, rw, start_sector << 9,
                               &map_length, NULL, 0);
         if (ret) {
@@ -7001,7 +7002,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                 return -EIO;
         }
 
-        if (map_length >= orig_bio->bi_size) {
+        if (map_length >= orig_bio->bi_iter.bi_size) {
                 bio = orig_bio;
                 goto submit;
         }
@@ -7053,7 +7054,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                         bio->bi_private = dip;
                         bio->bi_end_io = btrfs_end_dio_bio;
 
-                        map_length = orig_bio->bi_size;
+                        map_length = orig_bio->bi_iter.bi_size;
                         ret = btrfs_map_block(root->fs_info, rw,
                                               start_sector << 9,
                                               &map_length, NULL, 0);
@@ -7111,7 +7112,8 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
 
         if (!skip_sum && !write) {
                 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
-                sum_len = dio_bio->bi_size >> inode->i_sb->s_blocksize_bits;
+                sum_len = dio_bio->bi_iter.bi_size >>
+                        inode->i_sb->s_blocksize_bits;
                 sum_len *= csum_size;
         } else {
                 sum_len = 0;
@@ -7126,8 +7128,8 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
         dip->private = dio_bio->bi_private;
         dip->inode = inode;
         dip->logical_offset = file_offset;
-        dip->bytes = dio_bio->bi_size;
-        dip->disk_bytenr = (u64)dio_bio->bi_sector << 9;
+        dip->bytes = dio_bio->bi_iter.bi_size;
+        dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;
         io_bio->bi_private = dip;
         dip->errors = 0;
         dip->orig_bio = io_bio;
diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index 24ac21840a9a..9af0b25d991a 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -1032,8 +1032,8 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
 
         /* see if we can add this page onto our existing bio */
         if (last) {
-                last_end = (u64)last->bi_sector << 9;
-                last_end += last->bi_size;
+                last_end = (u64)last->bi_iter.bi_sector << 9;
+                last_end += last->bi_iter.bi_size;
 
                 /*
                  * we can't merge these if they are from different
@@ -1053,9 +1053,9 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
         if (!bio)
                 return -ENOMEM;
 
-        bio->bi_size = 0;
+        bio->bi_iter.bi_size = 0;
         bio->bi_bdev = stripe->dev->bdev;
-        bio->bi_sector = disk_start >> 9;
+        bio->bi_iter.bi_sector = disk_start >> 9;
         set_bit(BIO_UPTODATE, &bio->bi_flags);
 
         bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);
@@ -1111,7 +1111,7 @@ static void index_rbio_pages(struct btrfs_raid_bio *rbio)
 
         spin_lock_irq(&rbio->bio_list_lock);
         bio_list_for_each(bio, &rbio->bio_list) {
-                start = (u64)bio->bi_sector << 9;
+                start = (u64)bio->bi_iter.bi_sector << 9;
                 stripe_offset = start - rbio->raid_map[0];
                 page_index = stripe_offset >> PAGE_CACHE_SHIFT;
 
@@ -1272,7 +1272,7 @@ cleanup:
 static int find_bio_stripe(struct btrfs_raid_bio *rbio,
                            struct bio *bio)
 {
-        u64 physical = bio->bi_sector;
+        u64 physical = bio->bi_iter.bi_sector;
         u64 stripe_start;
         int i;
         struct btrfs_bio_stripe *stripe;
@@ -1298,7 +1298,7 @@ static int find_bio_stripe(struct btrfs_raid_bio *rbio,
 static int find_logical_bio_stripe(struct btrfs_raid_bio *rbio,
                                    struct bio *bio)
 {
-        u64 logical = bio->bi_sector;
+        u64 logical = bio->bi_iter.bi_sector;
         u64 stripe_start;
         int i;
 
@@ -1602,8 +1602,8 @@ static int plug_cmp(void *priv, struct list_head *a, struct list_head *b)
                                                  plug_list);
         struct btrfs_raid_bio *rb = container_of(b, struct btrfs_raid_bio,
                                                  plug_list);
-        u64 a_sector = ra->bio_list.head->bi_sector;
-        u64 b_sector = rb->bio_list.head->bi_sector;
+        u64 a_sector = ra->bio_list.head->bi_iter.bi_sector;
+        u64 b_sector = rb->bio_list.head->bi_iter.bi_sector;
 
         if (a_sector < b_sector)
                 return -1;
@@ -1691,7 +1691,7 @@ int raid56_parity_write(struct btrfs_root *root, struct bio *bio,
         if (IS_ERR(rbio))
                 return PTR_ERR(rbio);
         bio_list_add(&rbio->bio_list, bio);
-        rbio->bio_list_bytes = bio->bi_size;
+        rbio->bio_list_bytes = bio->bi_iter.bi_size;
 
         /*
          * don't plug on full rbios, just get them out the door
@@ -2044,7 +2044,7 @@ int raid56_parity_recover(struct btrfs_root *root, struct bio *bio,
 
         rbio->read_rebuild = 1;
         bio_list_add(&rbio->bio_list, bio);
-        rbio->bio_list_bytes = bio->bi_size;
+        rbio->bio_list_bytes = bio->bi_iter.bi_size;
 
         rbio->faila = find_logical_bio_stripe(rbio, bio);
         if (rbio->faila == -1) {
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 1fd3f33c330a..bb9a928fa3a8 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -1308,7 +1308,7 @@ static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
                         continue;
                 }
                 bio->bi_bdev = page->dev->bdev;
-                bio->bi_sector = page->physical >> 9;
+                bio->bi_iter.bi_sector = page->physical >> 9;
 
                 bio_add_page(bio, page->page, PAGE_SIZE, 0);
                 if (btrfsic_submit_bio_wait(READ, bio))
@@ -1427,7 +1427,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                 if (!bio)
                         return -EIO;
                 bio->bi_bdev = page_bad->dev->bdev;
-                bio->bi_sector = page_bad->physical >> 9;
+                bio->bi_iter.bi_sector = page_bad->physical >> 9;
 
                 ret = bio_add_page(bio, page_good->page, PAGE_SIZE, 0);
                 if (PAGE_SIZE != ret) {
@@ -1520,7 +1520,7 @@ again:
                 bio->bi_private = sbio;
                 bio->bi_end_io = scrub_wr_bio_end_io;
                 bio->bi_bdev = sbio->dev->bdev;
-                bio->bi_sector = sbio->physical >> 9;
+                bio->bi_iter.bi_sector = sbio->physical >> 9;
                 sbio->err = 0;
         } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                    spage->physical_for_dev_replace ||
@@ -1926,7 +1926,7 @@ again:
                 bio->bi_private = sbio;
                 bio->bi_end_io = scrub_bio_end_io;
                 bio->bi_bdev = sbio->dev->bdev;
-                bio->bi_sector = sbio->physical >> 9;
+                bio->bi_iter.bi_sector = sbio->physical >> 9;
                 sbio->err = 0;
         } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                    spage->physical ||
@@ -3371,8 +3371,8 @@ static int write_page_nocow(struct scrub_ctx *sctx,
                 spin_unlock(&sctx->stat_lock);
                 return -ENOMEM;
         }
-        bio->bi_size = 0;
-        bio->bi_sector = physical_for_dev_replace >> 9;
+        bio->bi_iter.bi_size = 0;
+        bio->bi_iter.bi_sector = physical_for_dev_replace >> 9;
         bio->bi_bdev = dev->bdev;
         ret = bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);
         if (ret != PAGE_CACHE_SIZE) {
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 92303f42baaa..f2130de0ddc2 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5411,7 +5411,7 @@ static int bio_size_ok(struct block_device *bdev, struct bio *bio,
         if (!q->merge_bvec_fn)
                 return 1;
 
-        bvm.bi_size = bio->bi_size - prev->bv_len;
+        bvm.bi_size = bio->bi_iter.bi_size - prev->bv_len;
         if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len)
                 return 0;
         return 1;
@@ -5426,7 +5426,7 @@ static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
         bio->bi_private = bbio;
         btrfs_io_bio(bio)->stripe_index = dev_nr;
         bio->bi_end_io = btrfs_end_bio;
-        bio->bi_sector = physical >> 9;
+        bio->bi_iter.bi_sector = physical >> 9;
 #ifdef DEBUG
         {
                 struct rcu_string *name;
@@ -5464,7 +5464,7 @@ again:
         while (bvec <= (first_bio->bi_io_vec + first_bio->bi_vcnt - 1)) {
                 if (bio_add_page(bio, bvec->bv_page, bvec->bv_len,
                                  bvec->bv_offset) < bvec->bv_len) {
-                        u64 len = bio->bi_size;
+                        u64 len = bio->bi_iter.bi_size;
 
                         atomic_inc(&bbio->stripes_pending);
                         submit_stripe_bio(root, bbio, bio, physical, dev_nr,
@@ -5486,7 +5486,7 @@ static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
                 bio->bi_private = bbio->private;
                 bio->bi_end_io = bbio->end_io;
                 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
-                bio->bi_sector = logical >> 9;
+                bio->bi_iter.bi_sector = logical >> 9;
                 kfree(bbio);
                 bio_endio(bio, -EIO);
         }
@@ -5497,7 +5497,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
 {
         struct btrfs_device *dev;
         struct bio *first_bio = bio;
-        u64 logical = (u64)bio->bi_sector << 9;
+        u64 logical = (u64)bio->bi_iter.bi_sector << 9;
         u64 length = 0;
         u64 map_length;
         u64 *raid_map = NULL;
@@ -5506,7 +5506,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
         int total_devs = 1;
         struct btrfs_bio *bbio = NULL;
 
-        length = bio->bi_size;
+        length = bio->bi_iter.bi_size;
         map_length = length;
 
         ret = __btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
diff --git a/fs/buffer.c b/fs/buffer.c
index 6024877335ca..1c04ec66974e 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2982,11 +2982,11 @@ static void guard_bh_eod(int rw, struct bio *bio, struct buffer_head *bh)
          * let it through, and the IO layer will turn it into
          * an EIO.
          */
-        if (unlikely(bio->bi_sector >= maxsector))
+        if (unlikely(bio->bi_iter.bi_sector >= maxsector))
                 return;
 
-        maxsector -= bio->bi_sector;
-        bytes = bio->bi_size;
+        maxsector -= bio->bi_iter.bi_sector;
+        bytes = bio->bi_iter.bi_size;
         if (likely((bytes >> 9) <= maxsector))
                 return;
 
@@ -2994,7 +2994,7 @@ static void guard_bh_eod(int rw, struct bio *bio, struct buffer_head *bh)
         bytes = maxsector << 9;
 
         /* Truncate the bio.. */
-        bio->bi_size = bytes;
+        bio->bi_iter.bi_size = bytes;
         bio->bi_io_vec[0].bv_len = bytes;
 
         /* ..and clear the end of the buffer for reads */
@@ -3029,14 +3029,14 @@ int _submit_bh(int rw, struct buffer_head *bh, unsigned long bio_flags)
          */
         bio = bio_alloc(GFP_NOIO, 1);
 
-        bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
+        bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
         bio->bi_bdev = bh->b_bdev;
         bio->bi_io_vec[0].bv_page = bh->b_page;
         bio->bi_io_vec[0].bv_len = bh->b_size;
         bio->bi_io_vec[0].bv_offset = bh_offset(bh);
 
         bio->bi_vcnt = 1;
-        bio->bi_size = bh->b_size;
+        bio->bi_iter.bi_size = bh->b_size;
 
         bio->bi_end_io = end_bio_bh_io_sync;
         bio->bi_private = bh;
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 0e04142d5962..160a5489a939 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -375,7 +375,7 @@ dio_bio_alloc(struct dio *dio, struct dio_submit *sdio,
         bio = bio_alloc(GFP_KERNEL, nr_vecs);
 
         bio->bi_bdev = bdev;
-        bio->bi_sector = first_sector;
+        bio->bi_iter.bi_sector = first_sector;
         if (dio->is_async)
                 bio->bi_end_io = dio_bio_end_aio;
         else
@@ -719,7 +719,7 @@ static inline int dio_send_cur_page(struct dio *dio, struct dio_submit *sdio,
         if (sdio->bio) {
                 loff_t cur_offset = sdio->cur_page_fs_offset;
                 loff_t bio_next_offset = sdio->logical_offset_in_bio +
-                        sdio->bio->bi_size;
+                        sdio->bio->bi_iter.bi_size;
 
                 /*
                  * See whether this new request is contiguous with the old.
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index a31e4da14508..ab95508e3d40 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -298,7 +298,7 @@ ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end)
 static void ext4_end_bio(struct bio *bio, int error)
 {
         ext4_io_end_t *io_end = bio->bi_private;
-        sector_t bi_sector = bio->bi_sector;
+        sector_t bi_sector = bio->bi_iter.bi_sector;
 
         BUG_ON(!io_end);
         bio->bi_end_io = NULL;
@@ -366,7 +366,7 @@ static int io_submit_init_bio(struct ext4_io_submit *io,
         bio = bio_alloc(GFP_NOIO, min(nvecs, BIO_MAX_PAGES));
         if (!bio)
                 return -ENOMEM;
-        bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
+        bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
         bio->bi_bdev = bh->b_bdev;
         bio->bi_end_io = ext4_end_bio;
         bio->bi_private = ext4_get_io_end(io->io_end);
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a4949096cf4c..a2c8de8ba6ce 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -386,7 +386,7 @@ int f2fs_readpage(struct f2fs_sb_info *sbi, struct page *page,
         bio = f2fs_bio_alloc(bdev, 1);
 
         /* Initialize the bio */
-        bio->bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
+        bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
         bio->bi_end_io = read_end_io;
 
         if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index a90c6bc0d129..36e8afd8e1e4 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -682,7 +682,7 @@ retry:
 
                 bio_blocks = MAX_BIO_BLOCKS(max_hw_blocks(sbi));
                 sbi->bio[type] = f2fs_bio_alloc(bdev, bio_blocks);
-                sbi->bio[type]->bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
+                sbi->bio[type]->bi_iter.bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
                 sbi->bio[type]->bi_private = priv;
                 /*
                  * The end_io will be assigned at the sumbission phase.
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 010b9fb9fec6..985da945f0b5 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -272,7 +272,7 @@ static struct bio *gfs2_log_alloc_bio(struct gfs2_sbd *sdp, u64 blkno)
                 nrvecs = max(nrvecs/2, 1U);
         }
 
-        bio->bi_sector = blkno * (sb->s_blocksize >> 9);
+        bio->bi_iter.bi_sector = blkno * (sb->s_blocksize >> 9);
         bio->bi_bdev = sb->s_bdev;
         bio->bi_end_io = gfs2_end_log_write;
         bio->bi_private = sdp;
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 82303b474958..16194da91652 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -224,7 +224,7 @@ static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
         lock_page(page);
 
         bio = bio_alloc(GFP_NOFS, 1);
-        bio->bi_sector = sector * (sb->s_blocksize >> 9);
+        bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
         bio->bi_bdev = sb->s_bdev;
         bio_add_page(bio, page, PAGE_SIZE, 0);
 
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index e9a97a0d4314..3f999649587f 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -63,7 +63,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
         sector &= ~((io_size >> HFSPLUS_SECTOR_SHIFT) - 1);
 
         bio = bio_alloc(GFP_NOIO, 1);
-        bio->bi_sector = sector;
+        bio->bi_iter.bi_sector = sector;
         bio->bi_bdev = sb->s_bdev;
 
         if (!(rw & WRITE) && data)
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 360d27c48887..8d811e02b4b9 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -1998,20 +1998,20 @@ static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp)
 
         bio = bio_alloc(GFP_NOFS, 1);
 
-        bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
+        bio->bi_iter.bi_sector = bp->l_blkno << (log->l2bsize - 9);
         bio->bi_bdev = log->bdev;
         bio->bi_io_vec[0].bv_page = bp->l_page;
         bio->bi_io_vec[0].bv_len = LOGPSIZE;
         bio->bi_io_vec[0].bv_offset = bp->l_offset;
 
         bio->bi_vcnt = 1;
-        bio->bi_size = LOGPSIZE;
+        bio->bi_iter.bi_size = LOGPSIZE;
 
         bio->bi_end_io = lbmIODone;
         bio->bi_private = bp;
         /*check if journaling to disk has been disabled*/
         if (log->no_integrity) {
-                bio->bi_size = 0;
+                bio->bi_iter.bi_size = 0;
                 lbmIODone(bio, 0);
         } else {
                 submit_bio(READ_SYNC, bio);
@@ -2144,21 +2144,21 @@ static void lbmStartIO(struct lbuf * bp)
         jfs_info("lbmStartIO\n");
 
         bio = bio_alloc(GFP_NOFS, 1);
-        bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
+        bio->bi_iter.bi_sector = bp->l_blkno << (log->l2bsize - 9);
         bio->bi_bdev = log->bdev;
         bio->bi_io_vec[0].bv_page = bp->l_page;
         bio->bi_io_vec[0].bv_len = LOGPSIZE;
         bio->bi_io_vec[0].bv_offset = bp->l_offset;
 
         bio->bi_vcnt = 1;
-        bio->bi_size = LOGPSIZE;
+        bio->bi_iter.bi_size = LOGPSIZE;
 
         bio->bi_end_io = lbmIODone;
         bio->bi_private = bp;
 
         /* check if journaling to disk has been disabled */
         if (log->no_integrity) {
-                bio->bi_size = 0;
+                bio->bi_iter.bi_size = 0;
                 lbmIODone(bio, 0);
         } else {
                 submit_bio(WRITE_SYNC, bio);
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index d165cde0c68d..49ba7ff1bbb9 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -416,7 +416,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
                          * count from hitting zero before we're through
                          */
                         inc_io(page);
-                        if (!bio->bi_size)
+                        if (!bio->bi_iter.bi_size)
                                 goto dump_bio;
                         submit_bio(WRITE, bio);
                         nr_underway++;
@@ -438,7 +438,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
 
                 bio = bio_alloc(GFP_NOFS, 1);
                 bio->bi_bdev = inode->i_sb->s_bdev;
-                bio->bi_sector = pblock << (inode->i_blkbits - 9);
+                bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9);
                 bio->bi_end_io = metapage_write_end_io;
                 bio->bi_private = page;
 
@@ -452,7 +452,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
         if (bio) {
                 if (bio_add_page(bio, page, bio_bytes, bio_offset) < bio_bytes)
                                 goto add_failed;
-                if (!bio->bi_size)
+                if (!bio->bi_iter.bi_size)
                         goto dump_bio;
 
                 submit_bio(WRITE, bio);
@@ -517,7 +517,8 @@ static int metapage_readpage(struct file *fp, struct page *page)
 
                         bio = bio_alloc(GFP_NOFS, 1);
                         bio->bi_bdev = inode->i_sb->s_bdev;
-                        bio->bi_sector = pblock << (inode->i_blkbits - 9);
+                        bio->bi_iter.bi_sector =
+                                pblock << (inode->i_blkbits - 9);
                         bio->bi_end_io = metapage_read_end_io;
                         bio->bi_private = page;
                         len = xlen << inode->i_blkbits;
diff --git a/fs/logfs/dev_bdev.c b/fs/logfs/dev_bdev.c
index e6df3be3b31b..76279e11982d 100644
--- a/fs/logfs/dev_bdev.c
+++ b/fs/logfs/dev_bdev.c
@@ -26,9 +26,9 @@ static int sync_request(struct page *page, struct block_device *bdev, int rw)
         bio_vec.bv_len = PAGE_SIZE;
         bio_vec.bv_offset = 0;
         bio.bi_vcnt = 1;
-        bio.bi_size = PAGE_SIZE;
         bio.bi_bdev = bdev;
-        bio.bi_sector = page->index * (PAGE_SIZE >> 9);
+        bio.bi_iter.bi_sector = page->index * (PAGE_SIZE >> 9);
+        bio.bi_iter.bi_size = PAGE_SIZE;
 
         return submit_bio_wait(rw, &bio);
 }
@@ -92,9 +92,9 @@ static int __bdev_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
                 if (i >= max_pages) {
                         /* Block layer cannot split bios :( */
                         bio->bi_vcnt = i;
-                        bio->bi_size = i * PAGE_SIZE;
+                        bio->bi_iter.bi_size = i * PAGE_SIZE;
                         bio->bi_bdev = super->s_bdev;
-                        bio->bi_sector = ofs >> 9;
+                        bio->bi_iter.bi_sector = ofs >> 9;
                         bio->bi_private = sb;
                         bio->bi_end_io = writeseg_end_io;
                         atomic_inc(&super->s_pending_writes);
@@ -119,9 +119,9 @@ static int __bdev_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
                 unlock_page(page);
         }
         bio->bi_vcnt = nr_pages;
-        bio->bi_size = nr_pages * PAGE_SIZE;
+        bio->bi_iter.bi_size = nr_pages * PAGE_SIZE;
         bio->bi_bdev = super->s_bdev;
-        bio->bi_sector = ofs >> 9;
+        bio->bi_iter.bi_sector = ofs >> 9;
         bio->bi_private = sb;
         bio->bi_end_io = writeseg_end_io;
         atomic_inc(&super->s_pending_writes);
@@ -184,9 +184,9 @@ static int do_erase(struct super_block *sb, u64 ofs, pgoff_t index,
                 if (i >= max_pages) {
                         /* Block layer cannot split bios :( */
                         bio->bi_vcnt = i;
-                        bio->bi_size = i * PAGE_SIZE;
+                        bio->bi_iter.bi_size = i * PAGE_SIZE;
                         bio->bi_bdev = super->s_bdev;
-                        bio->bi_sector = ofs >> 9;
+                        bio->bi_iter.bi_sector = ofs >> 9;
                         bio->bi_private = sb;
                         bio->bi_end_io = erase_end_io;
                         atomic_inc(&super->s_pending_writes);
@@ -205,9 +205,9 @@ static int do_erase(struct super_block *sb, u64 ofs, pgoff_t index,
                 bio->bi_io_vec[i].bv_offset = 0;
         }
         bio->bi_vcnt = nr_pages;
-        bio->bi_size = nr_pages * PAGE_SIZE;
+        bio->bi_iter.bi_size = nr_pages * PAGE_SIZE;
         bio->bi_bdev = super->s_bdev;
-        bio->bi_sector = ofs >> 9;
+        bio->bi_iter.bi_sector = ofs >> 9;
         bio->bi_private = sb;
         bio->bi_end_io = erase_end_io;
         atomic_inc(&super->s_pending_writes);
diff --git a/fs/mpage.c b/fs/mpage.c
index dd6d5878f4d9..4979ffa60aaa 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -93,7 +93,7 @@ mpage_alloc(struct block_device *bdev,
 
         if (bio) {
                 bio->bi_bdev = bdev;
-                bio->bi_sector = first_sector;
+                bio->bi_iter.bi_sector = first_sector;
         }
         return bio;
 }
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index da768923bf7c..56ff823ca82e 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -134,8 +134,8 @@ bl_submit_bio(int rw, struct bio *bio)
         if (bio) {
                 get_parallel(bio->bi_private);
                 dprintk("%s submitting %s bio %u@%llu\n", __func__,
-                        rw == READ ? "read" : "write",
-                        bio->bi_size, (unsigned long long)bio->bi_sector);
+                        rw == READ ? "read" : "write", bio->bi_iter.bi_size,
+                        (unsigned long long)bio->bi_iter.bi_sector);
                 submit_bio(rw, bio);
         }
         return NULL;
@@ -156,7 +156,8 @@ static struct bio *bl_alloc_init_bio(int npg, sector_t isect,
         }
 
         if (bio) {
-                bio->bi_sector = isect - be->be_f_offset + be->be_v_offset;
+                bio->bi_iter.bi_sector = isect - be->be_f_offset +
+                        be->be_v_offset;
                 bio->bi_bdev = be->be_mdev;
                 bio->bi_end_io = end_io;
                 bio->bi_private = par;
@@ -511,7 +512,7 @@ bl_do_readpage_sync(struct page *page, struct pnfs_block_extent *be,
         isect = (page->index << PAGE_CACHE_SECTOR_SHIFT) +
                 (offset / SECTOR_SIZE);
 
-        bio->bi_sector = isect - be->be_f_offset + be->be_v_offset;
+        bio->bi_iter.bi_sector = isect - be->be_f_offset + be->be_v_offset;
         bio->bi_bdev = be->be_mdev;
         bio->bi_end_io = bl_read_single_end_io;
 
diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index 2d8be51f90dc..dc3a9efdaab8 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -416,7 +416,8 @@ static struct bio *nilfs_alloc_seg_bio(struct the_nilfs *nilfs, sector_t start,
         }
         if (likely(bio)) {
                 bio->bi_bdev = nilfs->ns_bdev;
-                bio->bi_sector = start << (nilfs->ns_blocksize_bits - 9);
+                bio->bi_iter.bi_sector =
+                        start << (nilfs->ns_blocksize_bits - 9);
         }
         return bio;
 }
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 73920ffda05b..bf482dfed14f 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -413,7 +413,7 @@ static struct bio *o2hb_setup_one_bio(struct o2hb_region *reg,
         }
 
         /* Must put everything in 512 byte sectors for the bio... */
-        bio->bi_sector = (reg->hr_start_block + cs) << (bits - 9);
+        bio->bi_iter.bi_sector = (reg->hr_start_block + cs) << (bits - 9);
         bio->bi_bdev = reg->hr_bdev;
         bio->bi_private = wc;
         bio->bi_end_io = o2hb_bio_end_io;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 71c8c9d2b882..1b19b9cd692a 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -407,7 +407,7 @@ xfs_alloc_ioend_bio(
         struct bio              *bio = bio_alloc(GFP_NOIO, nvecs);
 
         ASSERT(bio->bi_private == NULL);
-        bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
+        bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
         bio->bi_bdev = bh->b_bdev;
         return bio;
 }
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index c7f0b77dcb00..5f3ea443ebbe 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1255,7 +1255,7 @@ next_chunk:
 
         bio = bio_alloc(GFP_NOIO, nr_pages);
         bio->bi_bdev = bp->b_target->bt_bdev;
-        bio->bi_sector = sector;
+        bio->bi_iter.bi_sector = sector;
         bio->bi_end_io = xfs_buf_bio_end_io;
         bio->bi_private = bp;
 
@@ -1277,7 +1277,7 @@ next_chunk:
                 total_nr_pages--;
         }
 
-        if (likely(bio->bi_size)) {
+        if (likely(bio->bi_iter.bi_size)) {
                 if (xfs_buf_is_vmapped(bp)) {
                         flush_kernel_vmap_range(bp->b_addr,
                                                 xfs_buf_vmap_len(bp));