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

10 files changed, 67 insertions, 67 deletions

diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
index 5e2765aadce1..038a6d2aced3 100644
--- a/drivers/md/bcache/btree.c
+++ b/drivers/md/bcache/btree.c
@@ -299,7 +299,7 @@ void bch_btree_node_read(struct btree *b)
 
         bio = bch_bbio_alloc(b->c);
         bio->bi_rw      = REQ_META|READ_SYNC;
-        bio->bi_size    = KEY_SIZE(&b->key) << 9;
+        bio->bi_iter.bi_size = KEY_SIZE(&b->key) << 9;
         bio->bi_end_io  = btree_node_read_endio;
         bio->bi_private = &cl;
 
@@ -395,7 +395,7 @@ static void do_btree_node_write(struct btree *b)
         b->bio->bi_end_io       = btree_node_write_endio;
         b->bio->bi_private      = cl;
         b->bio->bi_rw           = REQ_META|WRITE_SYNC|REQ_FUA;
-        b->bio->bi_size         = set_blocks(i, b->c) * block_bytes(b->c);
+        b->bio->bi_iter.bi_size = set_blocks(i, b->c) * block_bytes(b->c);
         bch_bio_map(b->bio, i);
 
         /*
diff --git a/drivers/md/bcache/debug.c b/drivers/md/bcache/debug.c
index 264fcfbd6290..92b3fd468a03 100644
--- a/drivers/md/bcache/debug.c
+++ b/drivers/md/bcache/debug.c
@@ -195,7 +195,7 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio)
                                  dc->disk.c,
                                  "verify failed at dev %s sector %llu",
                                  bdevname(dc->bdev, name),
-                                 (uint64_t) bio->bi_sector);
+                                 (uint64_t) bio->bi_iter.bi_sector);
 
                 kunmap_atomic(p1);
         }
diff --git a/drivers/md/bcache/io.c b/drivers/md/bcache/io.c
index 9056632995b1..cc4ba2da5fb6 100644
--- a/drivers/md/bcache/io.c
+++ b/drivers/md/bcache/io.c
@@ -21,18 +21,18 @@ static void bch_bi_idx_hack_endio(struct bio *bio, int error)
 
 static void bch_generic_make_request_hack(struct bio *bio)
 {
-        if (bio->bi_idx) {
+        if (bio->bi_iter.bi_idx) {
                 struct bio *clone = bio_alloc(GFP_NOIO, bio_segments(bio));
 
                 memcpy(clone->bi_io_vec,
                        bio_iovec(bio),
                        bio_segments(bio) * sizeof(struct bio_vec));
 
-                clone->bi_sector        = bio->bi_sector;
+                clone->bi_iter.bi_sector = bio->bi_iter.bi_sector;
                 clone->bi_bdev          = bio->bi_bdev;
                 clone->bi_rw            = bio->bi_rw;
                 clone->bi_vcnt          = bio_segments(bio);
-                clone->bi_size          = bio->bi_size;
+                clone->bi_iter.bi_size  = bio->bi_iter.bi_size;
 
                 clone->bi_private       = bio;
                 clone->bi_end_io        = bch_bi_idx_hack_endio;
@@ -72,7 +72,7 @@ static void bch_generic_make_request_hack(struct bio *bio)
 struct bio *bch_bio_split(struct bio *bio, int sectors,
                           gfp_t gfp, struct bio_set *bs)
 {
-        unsigned idx = bio->bi_idx, vcnt = 0, nbytes = sectors << 9;
+        unsigned idx = bio->bi_iter.bi_idx, vcnt = 0, nbytes = sectors << 9;
         struct bio_vec *bv;
         struct bio *ret = NULL;
 
@@ -90,7 +90,7 @@ struct bio *bch_bio_split(struct bio *bio, int sectors,
         }
 
         bio_for_each_segment(bv, bio, idx) {
-                vcnt = idx - bio->bi_idx;
+                vcnt = idx - bio->bi_iter.bi_idx;
 
                 if (!nbytes) {
                         ret = bio_alloc_bioset(gfp, vcnt, bs);
@@ -119,15 +119,15 @@ struct bio *bch_bio_split(struct bio *bio, int sectors,
         }
 out:
         ret->bi_bdev    = bio->bi_bdev;
-        ret->bi_sector  = bio->bi_sector;
-        ret->bi_size    = sectors << 9;
+        ret->bi_iter.bi_sector  = bio->bi_iter.bi_sector;
+        ret->bi_iter.bi_size    = sectors << 9;
         ret->bi_rw      = bio->bi_rw;
         ret->bi_vcnt    = vcnt;
         ret->bi_max_vecs = vcnt;
 
-        bio->bi_sector  += sectors;
-        bio->bi_size    -= sectors << 9;
-        bio->bi_idx      = idx;
+        bio->bi_iter.bi_sector  += sectors;
+        bio->bi_iter.bi_size    -= sectors << 9;
+        bio->bi_iter.bi_idx      = idx;
 
         if (bio_integrity(bio)) {
                 if (bio_integrity_clone(ret, bio, gfp)) {
@@ -162,7 +162,7 @@ static unsigned bch_bio_max_sectors(struct bio *bio)
                 bio_for_each_segment(bv, bio, i) {
                         struct bvec_merge_data bvm = {
                                 .bi_bdev        = bio->bi_bdev,
-                                .bi_sector      = bio->bi_sector,
+                                .bi_sector      = bio->bi_iter.bi_sector,
                                 .bi_size        = ret << 9,
                                 .bi_rw          = bio->bi_rw,
                         };
@@ -272,8 +272,8 @@ void __bch_submit_bbio(struct bio *bio, struct cache_set *c)
 {
         struct bbio *b = container_of(bio, struct bbio, bio);
 
-        bio->bi_sector  = PTR_OFFSET(&b->key, 0);
-        bio->bi_bdev    = PTR_CACHE(c, &b->key, 0)->bdev;
+        bio->bi_iter.bi_sector  = PTR_OFFSET(&b->key, 0);
+        bio->bi_bdev            = PTR_CACHE(c, &b->key, 0)->bdev;
 
         b->submit_time_us = local_clock_us();
         closure_bio_submit(bio, bio->bi_private, PTR_CACHE(c, &b->key, 0));
diff --git a/drivers/md/bcache/journal.c b/drivers/md/bcache/journal.c
index ecdaa671bd50..7eafdf09a0ae 100644
--- a/drivers/md/bcache/journal.c
+++ b/drivers/md/bcache/journal.c
@@ -51,10 +51,10 @@ reread:		left = ca->sb.bucket_size - offset;
                 len = min_t(unsigned, left, PAGE_SECTORS * 8);
 
                 bio_reset(bio);
-                bio->bi_sector  = bucket + offset;
+                bio->bi_iter.bi_sector  = bucket + offset;
                 bio->bi_bdev    = ca->bdev;
                 bio->bi_rw      = READ;
-                bio->bi_size    = len << 9;
+                bio->bi_iter.bi_size    = len << 9;
 
                 bio->bi_end_io  = journal_read_endio;
                 bio->bi_private = &cl;
@@ -437,13 +437,13 @@ static void do_journal_discard(struct cache *ca)
                 atomic_set(&ja->discard_in_flight, DISCARD_IN_FLIGHT);
 
                 bio_init(bio);
-                bio->bi_sector          = bucket_to_sector(ca->set,
+                bio->bi_iter.bi_sector  = bucket_to_sector(ca->set,
                                                 ca->sb.d[ja->discard_idx]);
                 bio->bi_bdev            = ca->bdev;
                 bio->bi_rw              = REQ_WRITE|REQ_DISCARD;
                 bio->bi_max_vecs        = 1;
                 bio->bi_io_vec          = bio->bi_inline_vecs;
-                bio->bi_size            = bucket_bytes(ca);
+                bio->bi_iter.bi_size    = bucket_bytes(ca);
                 bio->bi_end_io          = journal_discard_endio;
 
                 closure_get(&ca->set->cl);
@@ -608,10 +608,10 @@ static void journal_write_unlocked(struct closure *cl)
                 atomic_long_add(sectors, &ca->meta_sectors_written);
 
                 bio_reset(bio);
-                bio->bi_sector  = PTR_OFFSET(k, i);
+                bio->bi_iter.bi_sector  = PTR_OFFSET(k, i);
                 bio->bi_bdev    = ca->bdev;
                 bio->bi_rw      = REQ_WRITE|REQ_SYNC|REQ_META|REQ_FLUSH|REQ_FUA;
-                bio->bi_size    = sectors << 9;
+                bio->bi_iter.bi_size = sectors << 9;
 
                 bio->bi_end_io  = journal_write_endio;
                 bio->bi_private = w;
diff --git a/drivers/md/bcache/movinggc.c b/drivers/md/bcache/movinggc.c
index 7c1275e66025..581f95df8265 100644
--- a/drivers/md/bcache/movinggc.c
+++ b/drivers/md/bcache/movinggc.c
@@ -82,7 +82,7 @@ static void moving_init(struct moving_io *io)
         bio_get(bio);
         bio_set_prio(bio, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
 
-        bio->bi_size            = KEY_SIZE(&io->w->key) << 9;
+        bio->bi_iter.bi_size    = KEY_SIZE(&io->w->key) << 9;
         bio->bi_max_vecs        = DIV_ROUND_UP(KEY_SIZE(&io->w->key),
                                                PAGE_SECTORS);
         bio->bi_private         = &io->cl;
@@ -98,7 +98,7 @@ static void write_moving(struct closure *cl)
         if (!op->error) {
                 moving_init(io);
 
-                io->bio.bio.bi_sector = KEY_START(&io->w->key);
+                io->bio.bio.bi_iter.bi_sector = KEY_START(&io->w->key);
                 op->write_prio          = 1;
                 op->bio                 = &io->bio.bio;
 
diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c
index 78bab4154e97..47a9bbc75124 100644
--- a/drivers/md/bcache/request.c
+++ b/drivers/md/bcache/request.c
@@ -261,7 +261,7 @@ static void bch_data_invalidate(struct closure *cl)
         struct bio *bio = op->bio;
 
         pr_debug("invalidating %i sectors from %llu",
-                 bio_sectors(bio), (uint64_t) bio->bi_sector);
+                 bio_sectors(bio), (uint64_t) bio->bi_iter.bi_sector);
 
         while (bio_sectors(bio)) {
                 unsigned sectors = min(bio_sectors(bio),
@@ -270,11 +270,11 @@ static void bch_data_invalidate(struct closure *cl)
                 if (bch_keylist_realloc(&op->insert_keys, 0, op->c))
                         goto out;
 
-                bio->bi_sector  += sectors;
-                bio->bi_size    -= sectors << 9;
+                bio->bi_iter.bi_sector  += sectors;
+                bio->bi_iter.bi_size    -= sectors << 9;
 
                 bch_keylist_add(&op->insert_keys,
-                                &KEY(op->inode, bio->bi_sector, sectors));
+                                &KEY(op->inode, bio->bi_iter.bi_sector, sectors));
         }
 
         op->insert_data_done = true;
@@ -364,7 +364,7 @@ static void bch_data_insert_start(struct closure *cl)
                 k = op->insert_keys.top;
                 bkey_init(k);
                 SET_KEY_INODE(k, op->inode);
-                SET_KEY_OFFSET(k, bio->bi_sector);
+                SET_KEY_OFFSET(k, bio->bi_iter.bi_sector);
 
                 if (!bch_alloc_sectors(op->c, k, bio_sectors(bio),
                                        op->write_point, op->write_prio,
@@ -522,7 +522,7 @@ static bool check_should_bypass(struct cached_dev *dc, struct bio *bio)
              (bio->bi_rw & REQ_WRITE)))
                 goto skip;
 
-        if (bio->bi_sector & (c->sb.block_size - 1) ||
+        if (bio->bi_iter.bi_sector & (c->sb.block_size - 1) ||
             bio_sectors(bio) & (c->sb.block_size - 1)) {
                 pr_debug("skipping unaligned io");
                 goto skip;
@@ -546,8 +546,8 @@ static bool check_should_bypass(struct cached_dev *dc, struct bio *bio)
 
         spin_lock(&dc->io_lock);
 
-        hlist_for_each_entry(i, iohash(dc, bio->bi_sector), hash)
-                if (i->last == bio->bi_sector &&
+        hlist_for_each_entry(i, iohash(dc, bio->bi_iter.bi_sector), hash)
+                if (i->last == bio->bi_iter.bi_sector &&
                     time_before(jiffies, i->jiffies))
                         goto found;
 
@@ -556,8 +556,8 @@ static bool check_should_bypass(struct cached_dev *dc, struct bio *bio)
         add_sequential(task);
         i->sequential = 0;
 found:
-        if (i->sequential + bio->bi_size > i->sequential)
-                i->sequential   += bio->bi_size;
+        if (i->sequential + bio->bi_iter.bi_size > i->sequential)
+                i->sequential   += bio->bi_iter.bi_size;
 
         i->last                  = bio_end_sector(bio);
         i->jiffies               = jiffies + msecs_to_jiffies(5000);
@@ -650,15 +650,15 @@ static int cache_lookup_fn(struct btree_op *op, struct btree *b, struct bkey *k)
         struct bkey *bio_key;
         unsigned ptr;
 
-        if (bkey_cmp(k, &KEY(s->iop.inode, bio->bi_sector, 0)) <= 0)
+        if (bkey_cmp(k, &KEY(s->iop.inode, bio->bi_iter.bi_sector, 0)) <= 0)
                 return MAP_CONTINUE;
 
         if (KEY_INODE(k) != s->iop.inode ||
-            KEY_START(k) > bio->bi_sector) {
+            KEY_START(k) > bio->bi_iter.bi_sector) {
                 unsigned bio_sectors = bio_sectors(bio);
                 unsigned sectors = KEY_INODE(k) == s->iop.inode
                         ? min_t(uint64_t, INT_MAX,
-                                KEY_START(k) - bio->bi_sector)
+                                KEY_START(k) - bio->bi_iter.bi_sector)
                         : INT_MAX;
 
                 int ret = s->d->cache_miss(b, s, bio, sectors);
@@ -681,13 +681,13 @@ static int cache_lookup_fn(struct btree_op *op, struct btree *b, struct bkey *k)
                 s->read_dirty_data = true;
 
         n = bch_bio_split(bio, min_t(uint64_t, INT_MAX,
-                                     KEY_OFFSET(k) - bio->bi_sector),
+                                     KEY_OFFSET(k) - bio->bi_iter.bi_sector),
                           GFP_NOIO, s->d->bio_split);
 
         bio_key = &container_of(n, struct bbio, bio)->key;
         bch_bkey_copy_single_ptr(bio_key, k, ptr);
 
-        bch_cut_front(&KEY(s->iop.inode, n->bi_sector, 0), bio_key);
+        bch_cut_front(&KEY(s->iop.inode, n->bi_iter.bi_sector, 0), bio_key);
         bch_cut_back(&KEY(s->iop.inode, bio_end_sector(n), 0), bio_key);
 
         n->bi_end_io    = bch_cache_read_endio;
@@ -714,7 +714,7 @@ static void cache_lookup(struct closure *cl)
         struct bio *bio = &s->bio.bio;
 
         int ret = bch_btree_map_keys(&s->op, s->iop.c,
-                                     &KEY(s->iop.inode, bio->bi_sector, 0),
+                                     &KEY(s->iop.inode, bio->bi_iter.bi_sector, 0),
                                      cache_lookup_fn, MAP_END_KEY);
         if (ret == -EAGAIN)
                 continue_at(cl, cache_lookup, bcache_wq);
@@ -872,9 +872,9 @@ static void cached_dev_read_done(struct closure *cl)
 
         if (s->iop.bio) {
                 bio_reset(s->iop.bio);
-                s->iop.bio->bi_sector = s->cache_miss->bi_sector;
+                s->iop.bio->bi_iter.bi_sector = s->cache_miss->bi_iter.bi_sector;
                 s->iop.bio->bi_bdev = s->cache_miss->bi_bdev;
-                s->iop.bio->bi_size = s->insert_bio_sectors << 9;
+                s->iop.bio->bi_iter.bi_size = s->insert_bio_sectors << 9;
                 bch_bio_map(s->iop.bio, NULL);
 
                 bio_copy_data(s->cache_miss, s->iop.bio);
@@ -937,7 +937,7 @@ static int cached_dev_cache_miss(struct btree *b, struct search *s,
         s->insert_bio_sectors = min(sectors, bio_sectors(bio) + reada);
 
         s->iop.replace_key = KEY(s->iop.inode,
-                                 bio->bi_sector + s->insert_bio_sectors,
+                                 bio->bi_iter.bi_sector + s->insert_bio_sectors,
                                  s->insert_bio_sectors);
 
         ret = bch_btree_insert_check_key(b, &s->op, &s->iop.replace_key);
@@ -957,9 +957,9 @@ static int cached_dev_cache_miss(struct btree *b, struct search *s,
         if (!cache_bio)
                 goto out_submit;
 
-        cache_bio->bi_sector    = miss->bi_sector;
-        cache_bio->bi_bdev      = miss->bi_bdev;
-        cache_bio->bi_size      = s->insert_bio_sectors << 9;
+        cache_bio->bi_iter.bi_sector    = miss->bi_iter.bi_sector;
+        cache_bio->bi_bdev              = miss->bi_bdev;
+        cache_bio->bi_iter.bi_size      = s->insert_bio_sectors << 9;
 
         cache_bio->bi_end_io    = request_endio;
         cache_bio->bi_private   = &s->cl;
@@ -1009,7 +1009,7 @@ static void cached_dev_write(struct cached_dev *dc, struct search *s)
 {
         struct closure *cl = &s->cl;
         struct bio *bio = &s->bio.bio;
-        struct bkey start = KEY(dc->disk.id, bio->bi_sector, 0);
+        struct bkey start = KEY(dc->disk.id, bio->bi_iter.bi_sector, 0);
         struct bkey end = KEY(dc->disk.id, bio_end_sector(bio), 0);
 
         bch_keybuf_check_overlapping(&s->iop.c->moving_gc_keys, &start, &end);
@@ -1104,13 +1104,13 @@ static void cached_dev_make_request(struct request_queue *q, struct bio *bio)
         part_stat_unlock();
 
         bio->bi_bdev = dc->bdev;
-        bio->bi_sector += dc->sb.data_offset;
+        bio->bi_iter.bi_sector += dc->sb.data_offset;
 
         if (cached_dev_get(dc)) {
                 s = search_alloc(bio, d);
                 trace_bcache_request_start(s->d, bio);
 
-                if (!bio->bi_size) {
+                if (!bio->bi_iter.bi_size) {
                         /*
                          * can't call bch_journal_meta from under
                          * generic_make_request
@@ -1197,9 +1197,9 @@ static int flash_dev_cache_miss(struct btree *b, struct search *s,
                 sectors -= j;
         }
 
-        bio_advance(bio, min(sectors << 9, bio->bi_size));
+        bio_advance(bio, min(sectors << 9, bio->bi_iter.bi_size));
 
-        if (!bio->bi_size)
+        if (!bio->bi_iter.bi_size)
                 return MAP_DONE;
 
         return MAP_CONTINUE;
@@ -1233,7 +1233,7 @@ static void flash_dev_make_request(struct request_queue *q, struct bio *bio)
 
         trace_bcache_request_start(s->d, bio);
 
-        if (!bio->bi_size) {
+        if (!bio->bi_iter.bi_size) {
                 /*
                  * can't call bch_journal_meta from under
                  * generic_make_request
@@ -1243,7 +1243,7 @@ static void flash_dev_make_request(struct request_queue *q, struct bio *bio)
                                       bcache_wq);
         } else if (rw) {
                 bch_keybuf_check_overlapping(&s->iop.c->moving_gc_keys,
-                                        &KEY(d->id, bio->bi_sector, 0),
+                                        &KEY(d->id, bio->bi_iter.bi_sector, 0),
                                         &KEY(d->id, bio_end_sector(bio), 0));
 
                 s->iop.bypass           = (bio->bi_rw & REQ_DISCARD) != 0;
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 1d9ee67d14ec..60fb6044b953 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -233,9 +233,9 @@ static void __write_super(struct cache_sb *sb, struct bio *bio)
         struct cache_sb *out = page_address(bio->bi_io_vec[0].bv_page);
         unsigned i;
 
-        bio->bi_sector  = SB_SECTOR;
-        bio->bi_rw      = REQ_SYNC|REQ_META;
-        bio->bi_size    = SB_SIZE;
+        bio->bi_iter.bi_sector  = SB_SECTOR;
+        bio->bi_rw              = REQ_SYNC|REQ_META;
+        bio->bi_iter.bi_size    = SB_SIZE;
         bch_bio_map(bio, NULL);
 
         out->offset             = cpu_to_le64(sb->offset);
@@ -347,7 +347,7 @@ static void uuid_io(struct cache_set *c, unsigned long rw,
                 struct bio *bio = bch_bbio_alloc(c);
 
                 bio->bi_rw      = REQ_SYNC|REQ_META|rw;
-                bio->bi_size    = KEY_SIZE(k) << 9;
+                bio->bi_iter.bi_size = KEY_SIZE(k) << 9;
 
                 bio->bi_end_io  = uuid_endio;
                 bio->bi_private = cl;
@@ -503,10 +503,10 @@ static void prio_io(struct cache *ca, uint64_t bucket, unsigned long rw)
 
         closure_init_stack(cl);
 
-        bio->bi_sector  = bucket * ca->sb.bucket_size;
-        bio->bi_bdev    = ca->bdev;
-        bio->bi_rw      = REQ_SYNC|REQ_META|rw;
-        bio->bi_size    = bucket_bytes(ca);
+        bio->bi_iter.bi_sector  = bucket * ca->sb.bucket_size;
+        bio->bi_bdev            = ca->bdev;
+        bio->bi_rw              = REQ_SYNC|REQ_META|rw;
+        bio->bi_iter.bi_size    = bucket_bytes(ca);
 
         bio->bi_end_io  = prio_endio;
         bio->bi_private = ca;
diff --git a/drivers/md/bcache/util.c b/drivers/md/bcache/util.c
index 462214eeacbe..c57621e49dc0 100644
--- a/drivers/md/bcache/util.c
+++ b/drivers/md/bcache/util.c
@@ -218,10 +218,10 @@ uint64_t bch_next_delay(struct bch_ratelimit *d, uint64_t done)
 
 void bch_bio_map(struct bio *bio, void *base)
 {
-        size_t size = bio->bi_size;
+        size_t size = bio->bi_iter.bi_size;
         struct bio_vec *bv = bio->bi_io_vec;
 
-        BUG_ON(!bio->bi_size);
+        BUG_ON(!bio->bi_iter.bi_size);
         BUG_ON(bio->bi_vcnt);
 
         bv->bv_offset = base ? ((unsigned long) base) % PAGE_SIZE : 0;
diff --git a/drivers/md/bcache/writeback.c b/drivers/md/bcache/writeback.c
index 99053b1251be..04657e93f4fd 100644
--- a/drivers/md/bcache/writeback.c
+++ b/drivers/md/bcache/writeback.c
@@ -113,7 +113,7 @@ static void dirty_init(struct keybuf_key *w)
         if (!io->dc->writeback_percent)
                 bio_set_prio(bio, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
 
-        bio->bi_size            = KEY_SIZE(&w->key) << 9;
+        bio->bi_iter.bi_size    = KEY_SIZE(&w->key) << 9;
         bio->bi_max_vecs        = DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS);
         bio->bi_private         = w;
         bio->bi_io_vec          = bio->bi_inline_vecs;
@@ -186,7 +186,7 @@ static void write_dirty(struct closure *cl)
 
         dirty_init(w);
         io->bio.bi_rw           = WRITE;
-        io->bio.bi_sector       = KEY_START(&w->key);
+        io->bio.bi_iter.bi_sector = KEY_START(&w->key);
         io->bio.bi_bdev         = io->dc->bdev;
         io->bio.bi_end_io       = dirty_endio;
 
@@ -255,7 +255,7 @@ static void read_dirty(struct cached_dev *dc)
                 io->dc          = dc;
 
                 dirty_init(w);
-                io->bio.bi_sector       = PTR_OFFSET(&w->key, 0);
+                io->bio.bi_iter.bi_sector = PTR_OFFSET(&w->key, 0);
                 io->bio.bi_bdev         = PTR_CACHE(dc->disk.c,
                                                     &w->key, 0)->bdev;
                 io->bio.bi_rw           = READ;
diff --git a/drivers/md/bcache/writeback.h b/drivers/md/bcache/writeback.h
index c9ddcf4614b9..e2f8598937ac 100644
--- a/drivers/md/bcache/writeback.h
+++ b/drivers/md/bcache/writeback.h
@@ -50,7 +50,7 @@ static inline bool should_writeback(struct cached_dev *dc, struct bio *bio,
                 return false;
 
         if (dc->partial_stripes_expensive &&
-            bcache_dev_stripe_dirty(dc, bio->bi_sector,
+            bcache_dev_stripe_dirty(dc, bio->bi_iter.bi_sector,
                                     bio_sectors(bio)))
                 return true;