}
 }
 
-void bio_init(struct bio *bio)
+void bio_init(struct bio *bio, struct bio_vec *table,
+             unsigned short max_vecs)
 {
        memset(bio, 0, sizeof(*bio));
        atomic_set(&bio->__bi_remaining, 1);
        atomic_set(&bio->__bi_cnt, 1);
+
+       bio->bi_io_vec = table;
+       bio->bi_max_vecs = max_vecs;
 }
 EXPORT_SYMBOL(bio_init);
 
                return NULL;
 
        bio = p + front_pad;
-       bio_init(bio);
+       bio_init(bio, NULL, 0);
 
        if (nr_iovecs > inline_vecs) {
                unsigned long idx = 0;
 
 
        cbdata.drive = drive;
 
-       bio_init(&bio);
-       bio.bi_io_vec = &bio_vec;
+       bio_init(&bio, &bio_vec, 1);
        bio_vec.bv_page = page;
        bio_vec.bv_len = size;
        bio_vec.bv_offset = 0;
 
        struct bbio *b = mempool_alloc(c->bio_meta, GFP_NOIO);
        struct bio *bio = &b->bio;
 
-       bio_init(bio);
-       bio->bi_max_vecs         = bucket_pages(c);
-       bio->bi_io_vec           = bio->bi_inline_vecs;
+       bio_init(bio, bio->bi_inline_vecs, bucket_pages(c));
 
        return bio;
 }
 
 
                atomic_set(&ja->discard_in_flight, DISCARD_IN_FLIGHT);
 
-               bio_init(bio);
+               bio_init(bio, bio->bi_inline_vecs, 1);
                bio_set_op_attrs(bio, REQ_OP_DISCARD, 0);
                bio->bi_iter.bi_sector  = bucket_to_sector(ca->set,
                                                ca->sb.d[ja->discard_idx]);
                bio->bi_bdev            = ca->bdev;
-               bio->bi_max_vecs        = 1;
-               bio->bi_io_vec          = bio->bi_inline_vecs;
                bio->bi_iter.bi_size    = bucket_bytes(ca);
                bio->bi_end_io          = journal_discard_endio;
 
 
 {
        struct bio *bio = &io->bio.bio;
 
-       bio_init(bio);
+       bio_init(bio, bio->bi_inline_vecs,
+                DIV_ROUND_UP(KEY_SIZE(&io->w->key), PAGE_SECTORS));
        bio_get(bio);
        bio_set_prio(bio, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
 
        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;
-       bio->bi_io_vec          = bio->bi_inline_vecs;
        bch_bio_map(bio, NULL);
 }
 
 
 {
        struct bio *bio = &s->bio.bio;
 
-       bio_init(bio);
+       bio_init(bio, NULL, 0);
        __bio_clone_fast(bio, orig_bio);
        bio->bi_end_io          = request_endio;
        bio->bi_private         = &s->cl;
 
        dc->bdev = bdev;
        dc->bdev->bd_holder = dc;
 
-       bio_init(&dc->sb_bio);
-       dc->sb_bio.bi_max_vecs  = 1;
-       dc->sb_bio.bi_io_vec    = dc->sb_bio.bi_inline_vecs;
+       bio_init(&dc->sb_bio, dc->sb_bio.bi_inline_vecs, 1);
        dc->sb_bio.bi_io_vec[0].bv_page = sb_page;
        get_page(sb_page);
 
        __module_get(THIS_MODULE);
        kobject_init(&ca->kobj, &bch_cache_ktype);
 
-       bio_init(&ca->journal.bio);
-       ca->journal.bio.bi_max_vecs = 8;
-       ca->journal.bio.bi_io_vec = ca->journal.bio.bi_inline_vecs;
+       bio_init(&ca->journal.bio, ca->journal.bio.bi_inline_vecs, 8);
 
        free = roundup_pow_of_two(ca->sb.nbuckets) >> 10;
 
        ca->bdev = bdev;
        ca->bdev->bd_holder = ca;
 
-       bio_init(&ca->sb_bio);
-       ca->sb_bio.bi_max_vecs  = 1;
-       ca->sb_bio.bi_io_vec    = ca->sb_bio.bi_inline_vecs;
+       bio_init(&ca->sb_bio, ca->sb_bio.bi_inline_vecs, 1);
        ca->sb_bio.bi_io_vec[0].bv_page = sb_page;
        get_page(sb_page);
 
 
        struct dirty_io *io = w->private;
        struct bio *bio = &io->bio;
 
-       bio_init(bio);
+       bio_init(bio, bio->bi_inline_vecs,
+                DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS));
        if (!io->dc->writeback_percent)
                bio_set_prio(bio, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
 
        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;
        bch_bio_map(bio, NULL);
 }
 
 
        char *ptr;
        int len;
 
-       bio_init(&b->bio);
-       b->bio.bi_io_vec = b->bio_vec;
-       b->bio.bi_max_vecs = DM_BUFIO_INLINE_VECS;
+       bio_init(&b->bio, b->bio_vec, DM_BUFIO_INLINE_VECS);
        b->bio.bi_iter.bi_sector = block << b->c->sectors_per_block_bits;
        b->bio.bi_bdev = b->c->bdev;
        b->bio.bi_end_io = inline_endio;
 
        if (!md->bdev)
                goto bad;
 
-       bio_init(&md->flush_bio);
+       bio_init(&md->flush_bio, NULL, 0);
        md->flush_bio.bi_bdev = md->bdev;
        md->flush_bio.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
 
 
        }
        multipath = conf->multipaths + mp_bh->path;
 
-       bio_init(&mp_bh->bio);
+       bio_init(&mp_bh->bio, NULL, 0);
        __bio_clone_fast(&mp_bh->bio, bio);
 
        mp_bh->bio.bi_iter.bi_sector += multipath->rdev->data_offset;
 
        INIT_LIST_HEAD(&log->io_end_ios);
        INIT_LIST_HEAD(&log->flushing_ios);
        INIT_LIST_HEAD(&log->finished_ios);
-       bio_init(&log->flush_bio);
+       bio_init(&log->flush_bio, NULL, 0);
 
        log->io_kc = KMEM_CACHE(r5l_io_unit, 0);
        if (!log->io_kc)
 
                for (i = 0; i < disks; i++) {
                        struct r5dev *dev = &sh->dev[i];
 
-                       bio_init(&dev->req);
-                       dev->req.bi_io_vec = &dev->vec;
-                       dev->req.bi_max_vecs = 1;
-
-                       bio_init(&dev->rreq);
-                       dev->rreq.bi_io_vec = &dev->rvec;
-                       dev->rreq.bi_max_vecs = 1;
+                       bio_init(&dev->req, &dev->vec, 1);
+                       bio_init(&dev->rreq, &dev->rvec, 1);
                }
        }
        return sh;
 
 {
        struct bio *bio = &req->inline_bio;
 
-       bio_init(bio);
-       bio->bi_max_vecs = NVMET_MAX_INLINE_BIOVEC;
-       bio->bi_io_vec = req->inline_bvec;
+       bio_init(bio, req->inline_bvec, NVMET_MAX_INLINE_BIOVEC);
 }
 
 static void nvmet_execute_rw(struct nvmet_req *req)
 
                        return -ENOMEM;
        }
 
-       bio_init(&bio);
-       bio.bi_max_vecs = nr_pages;
-       bio.bi_io_vec = vecs;
+       bio_init(&bio, vecs, nr_pages);
        bio.bi_bdev = bdev;
        bio.bi_iter.bi_sector = pos >> 9;
        bio.bi_private = current;
 
        struct bio bio;
        struct bio_vec bio_vec;
 
-       bio_init(&bio);
-       bio.bi_max_vecs = 1;
-       bio.bi_io_vec = &bio_vec;
+       bio_init(&bio, &bio_vec, 1);
        bio_vec.bv_page = page;
        bio_vec.bv_len = PAGE_SIZE;
        bio_vec.bv_offset = 0;
 
 extern int submit_bio_wait(struct bio *bio);
 extern void bio_advance(struct bio *, unsigned);
 
-extern void bio_init(struct bio *);
+extern void bio_init(struct bio *bio, struct bio_vec *table,
+                    unsigned short max_vecs);
 extern void bio_reset(struct bio *);
 void bio_chain(struct bio *, struct bio *);