Merge branch 'for-3.14/core' of git://git.kernel.dk/linux-block

Pull core block IO changes from Jens Axboe:
 "The major piece in here is the immutable bio_ve series from Kent, the
  rest is fairly minor.  It was supposed to go in last round, but
  various issues pushed it to this release instead.  The pull request
  contains:

   - Various smaller blk-mq fixes from different folks.  Nothing major
     here, just minor fixes and cleanups.

   - Fix for a memory leak in the error path in the block ioctl code
     from Christian Engelmayer.

   - Header export fix from CaiZhiyong.

   - Finally the immutable biovec changes from Kent Overstreet.  This
     enables some nice future work on making arbitrarily sized bios
     possible, and splitting more efficient.  Related fixes to immutable
     bio_vecs:

        - dm-cache immutable fixup from Mike Snitzer.
        - btrfs immutable fixup from Muthu Kumar.

  - bio-integrity fix from Nic Bellinger, which is also going to stable"

* 'for-3.14/core' of git://git.kernel.dk/linux-block: (44 commits)
  xtensa: fixup simdisk driver to work with immutable bio_vecs
  block/blk-mq-cpu.c: use hotcpu_notifier()
  blk-mq: for_each_* macro correctness
  block: Fix memory leak in rw_copy_check_uvector() handling
  bio-integrity: Fix bio_integrity_verify segment start bug
  block: remove unrelated header files and export symbol
  blk-mq: uses page->list incorrectly
  blk-mq: use __smp_call_function_single directly
  btrfs: fix missing increment of bi_remaining
  Revert "block: Warn and free bio if bi_end_io is not set"
  block: Warn and free bio if bi_end_io is not set
  blk-mq: fix initializing request's start time
  block: blk-mq: don't export blk_mq_free_queue()
  block: blk-mq: make blk_sync_queue support mq
  block: blk-mq: support draining mq queue
  dm cache: increment bi_remaining when bi_end_io is restored
  block: fixup for generic bio chaining
  block: Really silence spurious compiler warnings
  block: Silence spurious compiler warnings
  block: Kill bio_pair_split()
  ...

11 files changed, 118 insertions, 288 deletions

diff --git a/drivers/md/bcache/bcache.h b/drivers/md/bcache/bcache.h
index 754f43177483..dbdbca5a9591 100644
--- a/drivers/md/bcache/bcache.h
+++ b/drivers/md/bcache/bcache.h
@@ -280,7 +280,6 @@ struct bcache_device {
         unsigned long           sectors_dirty_last;
         long                    sectors_dirty_derivative;
 
-        mempool_t               *unaligned_bvec;
         struct bio_set          *bio_split;
 
         unsigned                data_csum:1;
@@ -902,7 +901,6 @@ void bch_bbio_endio(struct cache_set *, struct bio *, int, const char *);
 void bch_bbio_free(struct bio *, struct cache_set *);
 struct bio *bch_bbio_alloc(struct cache_set *);
 
-struct bio *bch_bio_split(struct bio *, int, gfp_t, struct bio_set *);
 void bch_generic_make_request(struct bio *, struct bio_split_pool *);
 void __bch_submit_bbio(struct bio *, struct cache_set *);
 void bch_submit_bbio(struct bio *, struct cache_set *, struct bkey *, unsigned);
diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
index 31bb53fcc67a..946ecd3b048b 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;
 
@@ -362,7 +362,7 @@ static void btree_node_write_done(struct closure *cl)
         struct bio_vec *bv;
         int n;
 
-        __bio_for_each_segment(bv, b->bio, n, 0)
+        bio_for_each_segment_all(bv, b->bio, n)
                 __free_page(bv->bv_page);
 
         __btree_node_write_done(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);
 
         /*
@@ -421,7 +421,7 @@ static void do_btree_node_write(struct btree *b)
                 struct bio_vec *bv;
                 void *base = (void *) ((unsigned long) i & ~(PAGE_SIZE - 1));
 
-                bio_for_each_segment(bv, b->bio, j)
+                bio_for_each_segment_all(bv, b->bio, j)
                         memcpy(page_address(bv->bv_page),
                                base + j * PAGE_SIZE, PAGE_SIZE);
 
diff --git a/drivers/md/bcache/debug.c b/drivers/md/bcache/debug.c
index 264fcfbd6290..03cb4d114e16 100644
--- a/drivers/md/bcache/debug.c
+++ b/drivers/md/bcache/debug.c
@@ -173,7 +173,8 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio)
 {
         char name[BDEVNAME_SIZE];
         struct bio *check;
-        struct bio_vec *bv;
+        struct bio_vec bv, *bv2;
+        struct bvec_iter iter;
         int i;
 
         check = bio_clone(bio, GFP_NOIO);
@@ -185,23 +186,23 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio)
 
         submit_bio_wait(READ_SYNC, check);
 
-        bio_for_each_segment(bv, bio, i) {
-                void *p1 = kmap_atomic(bv->bv_page);
-                void *p2 = page_address(check->bi_io_vec[i].bv_page);
+        bio_for_each_segment(bv, bio, iter) {
+                void *p1 = kmap_atomic(bv.bv_page);
+                void *p2 = page_address(check->bi_io_vec[iter.bi_idx].bv_page);
 
-                cache_set_err_on(memcmp(p1 + bv->bv_offset,
-                                        p2 + bv->bv_offset,
-                                        bv->bv_len),
+                cache_set_err_on(memcmp(p1 + bv.bv_offset,
+                                        p2 + bv.bv_offset,
+                                        bv.bv_len),
                                  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);
         }
 
-        bio_for_each_segment_all(bv, check, i)
-                __free_page(bv->bv_page);
+        bio_for_each_segment_all(bv2, check, i)
+                __free_page(bv2->bv_page);
 out_put:
         bio_put(check);
 }
diff --git a/drivers/md/bcache/io.c b/drivers/md/bcache/io.c
index 9056632995b1..fa028fa82df4 100644
--- a/drivers/md/bcache/io.c
+++ b/drivers/md/bcache/io.c
@@ -11,178 +11,40 @@
 
 #include <linux/blkdev.h>
 
-static void bch_bi_idx_hack_endio(struct bio *bio, int error)
-{
-        struct bio *p = bio->bi_private;
-
-        bio_endio(p, error);
-        bio_put(bio);
-}
-
-static void bch_generic_make_request_hack(struct bio *bio)
-{
-        if (bio->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_bdev          = bio->bi_bdev;
-                clone->bi_rw            = bio->bi_rw;
-                clone->bi_vcnt          = bio_segments(bio);
-                clone->bi_size          = bio->bi_size;
-
-                clone->bi_private       = bio;
-                clone->bi_end_io        = bch_bi_idx_hack_endio;
-
-                bio = clone;
-        }
-
-        /*
-         * Hack, since drivers that clone bios clone up to bi_max_vecs, but our
-         * bios might have had more than that (before we split them per device
-         * limitations).
-         *
-         * To be taken out once immutable bvec stuff is in.
-         */
-        bio->bi_max_vecs = bio->bi_vcnt;
-
-        generic_make_request(bio);
-}
-
-/**
- * bch_bio_split - split a bio
- * @bio:        bio to split
- * @sectors:    number of sectors to split from the front of @bio
- * @gfp:        gfp mask
- * @bs:         bio set to allocate from
- *
- * Allocates and returns a new bio which represents @sectors from the start of
- * @bio, and updates @bio to represent the remaining sectors.
- *
- * If bio_sectors(@bio) was less than or equal to @sectors, returns @bio
- * unchanged.
- *
- * The newly allocated bio will point to @bio's bi_io_vec, if the split was on a
- * bvec boundry; it is the caller's responsibility to ensure that @bio is not
- * freed before the split.
- */
-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;
-        struct bio_vec *bv;
-        struct bio *ret = NULL;
-
-        BUG_ON(sectors <= 0);
-
-        if (sectors >= bio_sectors(bio))
-                return bio;
-
-        if (bio->bi_rw & REQ_DISCARD) {
-                ret = bio_alloc_bioset(gfp, 1, bs);
-                if (!ret)
-                        return NULL;
-                idx = 0;
-                goto out;
-        }
-
-        bio_for_each_segment(bv, bio, idx) {
-                vcnt = idx - bio->bi_idx;
-
-                if (!nbytes) {
-                        ret = bio_alloc_bioset(gfp, vcnt, bs);
-                        if (!ret)
-                                return NULL;
-
-                        memcpy(ret->bi_io_vec, bio_iovec(bio),
-                               sizeof(struct bio_vec) * vcnt);
-
-                        break;
-                } else if (nbytes < bv->bv_len) {
-                        ret = bio_alloc_bioset(gfp, ++vcnt, bs);
-                        if (!ret)
-                                return NULL;
-
-                        memcpy(ret->bi_io_vec, bio_iovec(bio),
-                               sizeof(struct bio_vec) * vcnt);
-
-                        ret->bi_io_vec[vcnt - 1].bv_len = nbytes;
-                        bv->bv_offset   += nbytes;
-                        bv->bv_len      -= nbytes;
-                        break;
-                }
-
-                nbytes -= bv->bv_len;
-        }
-out:
-        ret->bi_bdev    = bio->bi_bdev;
-        ret->bi_sector  = bio->bi_sector;
-        ret->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;
-
-        if (bio_integrity(bio)) {
-                if (bio_integrity_clone(ret, bio, gfp)) {
-                        bio_put(ret);
-                        return NULL;
-                }
-
-                bio_integrity_trim(ret, 0, bio_sectors(ret));
-                bio_integrity_trim(bio, bio_sectors(ret), bio_sectors(bio));
-        }
-
-        return ret;
-}
-
 static unsigned bch_bio_max_sectors(struct bio *bio)
 {
-        unsigned ret = bio_sectors(bio);
         struct request_queue *q = bdev_get_queue(bio->bi_bdev);
-        unsigned max_segments = min_t(unsigned, BIO_MAX_PAGES,
-                                      queue_max_segments(q));
+        struct bio_vec bv;
+        struct bvec_iter iter;
+        unsigned ret = 0, seg = 0;
 
         if (bio->bi_rw & REQ_DISCARD)
-                return min(ret, q->limits.max_discard_sectors);
-
-        if (bio_segments(bio) > max_segments ||
-            q->merge_bvec_fn) {
-                struct bio_vec *bv;
-                int i, seg = 0;
-
-                ret = 0;
-
-                bio_for_each_segment(bv, bio, i) {
-                        struct bvec_merge_data bvm = {
-                                .bi_bdev        = bio->bi_bdev,
-                                .bi_sector      = bio->bi_sector,
-                                .bi_size        = ret << 9,
-                                .bi_rw          = bio->bi_rw,
-                        };
-
-                        if (seg == max_segments)
-                                break;
+                return min(bio_sectors(bio), q->limits.max_discard_sectors);
+
+        bio_for_each_segment(bv, bio, iter) {
+                struct bvec_merge_data bvm = {
+                        .bi_bdev        = bio->bi_bdev,
+                        .bi_sector      = bio->bi_iter.bi_sector,
+                        .bi_size        = ret << 9,
+                        .bi_rw          = bio->bi_rw,
+                };
+
+                if (seg == min_t(unsigned, BIO_MAX_PAGES,
+                                 queue_max_segments(q)))
+                        break;
 
-                        if (q->merge_bvec_fn &&
-                            q->merge_bvec_fn(q, &bvm, bv) < (int) bv->bv_len)
-                                break;
+                if (q->merge_bvec_fn &&
+                    q->merge_bvec_fn(q, &bvm, &bv) < (int) bv.bv_len)
+                        break;
 
-                        seg++;
-                        ret += bv->bv_len >> 9;
-                }
+                seg++;
+                ret += bv.bv_len >> 9;
         }
 
         ret = min(ret, queue_max_sectors(q));
 
         WARN_ON(!ret);
-        ret = max_t(int, ret, bio_iovec(bio)->bv_len >> 9);
+        ret = max_t(int, ret, bio_iovec(bio).bv_len >> 9);
 
         return ret;
 }
@@ -193,7 +55,7 @@ static void bch_bio_submit_split_done(struct closure *cl)
 
         s->bio->bi_end_io = s->bi_end_io;
         s->bio->bi_private = s->bi_private;
-        bio_endio(s->bio, 0);
+        bio_endio_nodec(s->bio, 0);
 
         closure_debug_destroy(&s->cl);
         mempool_free(s, s->p->bio_split_hook);
@@ -232,19 +94,19 @@ void bch_generic_make_request(struct bio *bio, struct bio_split_pool *p)
         bio_get(bio);
 
         do {
-                n = bch_bio_split(bio, bch_bio_max_sectors(bio),
-                                  GFP_NOIO, s->p->bio_split);
+                n = bio_next_split(bio, bch_bio_max_sectors(bio),
+                                   GFP_NOIO, s->p->bio_split);
 
                 n->bi_end_io    = bch_bio_submit_split_endio;
                 n->bi_private   = &s->cl;
 
                 closure_get(&s->cl);
-                bch_generic_make_request_hack(n);
+                generic_make_request(n);
         } while (n != bio);
 
         continue_at(&s->cl, bch_bio_submit_split_done, NULL);
 submit:
-        bch_generic_make_request_hack(bio);
+        generic_make_request(bio);
 }
 
 /* Bios with headers */
@@ -272,8 +134,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 f2f0998c4a91..052bd24d24b4 100644
--- a/drivers/md/bcache/movinggc.c
+++ b/drivers/md/bcache/movinggc.c
@@ -86,7 +86,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;
@@ -102,7 +102,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 61bcfc21d2a0..c906571997d7 100644
--- a/drivers/md/bcache/request.c
+++ b/drivers/md/bcache/request.c
@@ -197,14 +197,14 @@ static bool verify(struct cached_dev *dc, struct bio *bio)
 
 static void bio_csum(struct bio *bio, struct bkey *k)
 {
-        struct bio_vec *bv;
+        struct bio_vec bv;
+        struct bvec_iter iter;
         uint64_t csum = 0;
-        int i;
 
-        bio_for_each_segment(bv, bio, i) {
-                void *d = kmap(bv->bv_page) + bv->bv_offset;
-                csum = bch_crc64_update(csum, d, bv->bv_len);
-                kunmap(bv->bv_page);
+        bio_for_each_segment(bv, bio, iter) {
+                void *d = kmap(bv.bv_page) + bv.bv_offset;
+                csum = bch_crc64_update(csum, d, bv.bv_len);
+                kunmap(bv.bv_page);
         }
 
         k->ptr[KEY_PTRS(k)] = csum & (~0ULL >> 1);
@@ -260,7 +260,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),
@@ -269,11 +269,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;
@@ -363,14 +363,14 @@ 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,
                                        op->writeback))
                         goto err;
 
-                n = bch_bio_split(bio, KEY_SIZE(k), GFP_NOIO, split);
+                n = bio_next_split(bio, KEY_SIZE(k), GFP_NOIO, split);
 
                 n->bi_end_io    = bch_data_insert_endio;
                 n->bi_private   = cl;
@@ -521,7 +521,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;
@@ -545,8 +545,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;
 
@@ -555,8 +555,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);
@@ -605,7 +605,6 @@ struct search {
         unsigned                insert_bio_sectors;
 
         unsigned                recoverable:1;
-        unsigned                unaligned_bvec:1;
         unsigned                write:1;
         unsigned                read_dirty_data:1;
 
@@ -649,15 +648,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);
@@ -679,14 +678,14 @@ static int cache_lookup_fn(struct btree_op *op, struct btree *b, struct bkey *k)
         if (KEY_DIRTY(k))
                 s->read_dirty_data = true;
 
-        n = bch_bio_split(bio, min_t(uint64_t, INT_MAX,
-                                     KEY_OFFSET(k) - bio->bi_sector),
-                          GFP_NOIO, s->d->bio_split);
+        n = bio_next_split(bio, min_t(uint64_t, INT_MAX,
+                                      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;
@@ -713,7 +712,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);
@@ -758,10 +757,12 @@ static void bio_complete(struct search *s)
 static void do_bio_hook(struct search *s)
 {
         struct bio *bio = &s->bio.bio;
-        memcpy(bio, s->orig_bio, sizeof(struct bio));
 
+        bio_init(bio);
+        __bio_clone_fast(bio, s->orig_bio);
         bio->bi_end_io          = request_endio;
         bio->bi_private         = &s->cl;
+
         atomic_set(&bio->bi_cnt, 3);
 }
 
@@ -773,9 +774,6 @@ static void search_free(struct closure *cl)
         if (s->iop.bio)
                 bio_put(s->iop.bio);
 
-        if (s->unaligned_bvec)
-                mempool_free(s->bio.bio.bi_io_vec, s->d->unaligned_bvec);
-
         closure_debug_destroy(cl);
         mempool_free(s, s->d->c->search);
 }
@@ -783,7 +781,6 @@ static void search_free(struct closure *cl)
 static struct search *search_alloc(struct bio *bio, struct bcache_device *d)
 {
         struct search *s;
-        struct bio_vec *bv;
 
         s = mempool_alloc(d->c->search, GFP_NOIO);
         memset(s, 0, offsetof(struct search, iop.insert_keys));
@@ -802,15 +799,6 @@ static struct search *search_alloc(struct bio *bio, struct bcache_device *d)
         s->start_time           = jiffies;
         do_bio_hook(s);
 
-        if (bio->bi_size != bio_segments(bio) * PAGE_SIZE) {
-                bv = mempool_alloc(d->unaligned_bvec, GFP_NOIO);
-                memcpy(bv, bio_iovec(bio),
-                       sizeof(struct bio_vec) * bio_segments(bio));
-
-                s->bio.bio.bi_io_vec    = bv;
-                s->unaligned_bvec       = 1;
-        }
-
         return s;
 }
 
@@ -849,26 +837,13 @@ static void cached_dev_read_error(struct closure *cl)
 {
         struct search *s = container_of(cl, struct search, cl);
         struct bio *bio = &s->bio.bio;
-        struct bio_vec *bv;
-        int i;
 
         if (s->recoverable) {
                 /* Retry from the backing device: */
                 trace_bcache_read_retry(s->orig_bio);
 
                 s->iop.error = 0;
-                bv = s->bio.bio.bi_io_vec;
                 do_bio_hook(s);
-                s->bio.bio.bi_io_vec = bv;
-
-                if (!s->unaligned_bvec)
-                        bio_for_each_segment(bv, s->orig_bio, i)
-                                bv->bv_offset = 0, bv->bv_len = PAGE_SIZE;
-                else
-                        memcpy(s->bio.bio.bi_io_vec,
-                               bio_iovec(s->orig_bio),
-                               sizeof(struct bio_vec) *
-                               bio_segments(s->orig_bio));
 
                 /* XXX: invalidate cache */
 
@@ -893,9 +868,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);
@@ -904,8 +879,7 @@ static void cached_dev_read_done(struct closure *cl)
                 s->cache_miss = NULL;
         }
 
-        if (verify(dc, &s->bio.bio) && s->recoverable &&
-            !s->unaligned_bvec && !s->read_dirty_data)
+        if (verify(dc, &s->bio.bio) && s->recoverable && !s->read_dirty_data)
                 bch_data_verify(dc, s->orig_bio);
 
         bio_complete(s);
@@ -945,7 +919,7 @@ static int cached_dev_cache_miss(struct btree *b, struct search *s,
         struct bio *miss, *cache_bio;
 
         if (s->cache_miss || s->iop.bypass) {
-                miss = bch_bio_split(bio, sectors, GFP_NOIO, s->d->bio_split);
+                miss = bio_next_split(bio, sectors, GFP_NOIO, s->d->bio_split);
                 ret = miss == bio ? MAP_DONE : MAP_CONTINUE;
                 goto out_submit;
         }
@@ -959,7 +933,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);
@@ -968,7 +942,7 @@ static int cached_dev_cache_miss(struct btree *b, struct search *s,
 
         s->iop.replace = true;
 
-        miss = bch_bio_split(bio, sectors, GFP_NOIO, s->d->bio_split);
+        miss = bio_next_split(bio, sectors, GFP_NOIO, s->d->bio_split);
 
         /* btree_search_recurse()'s btree iterator is no good anymore */
         ret = miss == bio ? MAP_DONE : -EINTR;
@@ -979,9 +953,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;
@@ -1031,7 +1005,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);
@@ -1087,8 +1061,7 @@ static void cached_dev_write(struct cached_dev *dc, struct search *s)
                         closure_bio_submit(flush, cl, s->d);
                 }
         } else {
-                s->iop.bio = bio_clone_bioset(bio, GFP_NOIO,
-                                              dc->disk.bio_split);
+                s->iop.bio = bio_clone_fast(bio, GFP_NOIO, dc->disk.bio_split);
 
                 closure_bio_submit(bio, cl, s->d);
         }
@@ -1126,13 +1099,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
@@ -1204,24 +1177,24 @@ void bch_cached_dev_request_init(struct cached_dev *dc)
 static int flash_dev_cache_miss(struct btree *b, struct search *s,
                                 struct bio *bio, unsigned sectors)
 {
-        struct bio_vec *bv;
-        int i;
+        struct bio_vec bv;
+        struct bvec_iter iter;
 
         /* Zero fill bio */
 
-        bio_for_each_segment(bv, bio, i) {
-                unsigned j = min(bv->bv_len >> 9, sectors);
+        bio_for_each_segment(bv, bio, iter) {
+                unsigned j = min(bv.bv_len >> 9, sectors);
 
-                void *p = kmap(bv->bv_page);
-                memset(p + bv->bv_offset, 0, j << 9);
-                kunmap(bv->bv_page);
+                void *p = kmap(bv.bv_page);
+                memset(p + bv.bv_offset, 0, j << 9);
+                kunmap(bv.bv_page);
 
                 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;
@@ -1255,7 +1228,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
@@ -1265,7 +1238,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 c57bfa071a57..93d593f957f6 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;
@@ -739,8 +739,6 @@ static void bcache_device_free(struct bcache_device *d)
         }
 
         bio_split_pool_free(&d->bio_split_hook);
-        if (d->unaligned_bvec)
-                mempool_destroy(d->unaligned_bvec);
         if (d->bio_split)
                 bioset_free(d->bio_split);
         if (is_vmalloc_addr(d->full_dirty_stripes))
@@ -793,8 +791,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned block_size,
                 return minor;
 
         if (!(d->bio_split = bioset_create(4, offsetof(struct bbio, bio))) ||
-            !(d->unaligned_bvec = mempool_create_kmalloc_pool(1,
-                                sizeof(struct bio_vec) * BIO_MAX_PAGES)) ||
             bio_split_pool_init(&d->bio_split_hook) ||
             !(d->disk = alloc_disk(1))) {
                 ida_simple_remove(&bcache_minor, minor);
diff --git a/drivers/md/bcache/util.c b/drivers/md/bcache/util.c
index bb37618e7664..db3ae4c2b223 100644
--- a/drivers/md/bcache/util.c
+++ b/drivers/md/bcache/util.c
@@ -224,10 +224,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 6c44fe059c27..f4300e4c0114 100644
--- a/drivers/md/bcache/writeback.c
+++ b/drivers/md/bcache/writeback.c
@@ -111,7 +111,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;
@@ -184,7 +184,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;
 
@@ -253,7 +253,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;