10 files changed, 37 insertions, 188 deletions

diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index f93a0320e952..f55683ad4ffa 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -162,23 +162,12 @@ static const struct block_device_operations drbd_ops = {
         .release = drbd_release,
 };
 
-static void bio_destructor_drbd(struct bio *bio)
-{
-        bio_free(bio, drbd_md_io_bio_set);
-}
-
 struct bio *bio_alloc_drbd(gfp_t gfp_mask)
 {
-        struct bio *bio;
-
         if (!drbd_md_io_bio_set)
                 return bio_alloc(gfp_mask, 1);
 
-        bio = bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
-        if (!bio)
-                return NULL;
-        bio->bi_destructor = bio_destructor_drbd;
-        return bio;
+        return bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
 }
 
 #ifdef __CHECKER__
diff --git a/drivers/block/osdblk.c b/drivers/block/osdblk.c
index 87311ebac0db..1bbc681688e4 100644
--- a/drivers/block/osdblk.c
+++ b/drivers/block/osdblk.c
@@ -266,11 +266,10 @@ static struct bio *bio_chain_clone(struct bio *old_chain, gfp_t gfpmask)
         struct bio *tmp, *new_chain = NULL, *tail = NULL;
 
         while (old_chain) {
-                tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs);
+                tmp = bio_clone_kmalloc(old_chain, gfpmask);
                 if (!tmp)
                         goto err_out;
 
-                __bio_clone(tmp, old_chain);
                 tmp->bi_bdev = NULL;
                 gfpmask &= ~__GFP_WAIT;
                 tmp->bi_next = NULL;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index ba66e4445f41..2e7de7a59bfc 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -522,38 +522,6 @@ static void pkt_bio_finished(struct pktcdvd_device *pd)
         }
 }
 
-static void pkt_bio_destructor(struct bio *bio)
-{
-        kfree(bio->bi_io_vec);
-        kfree(bio);
-}
-
-static struct bio *pkt_bio_alloc(int nr_iovecs)
-{
-        struct bio_vec *bvl = NULL;
-        struct bio *bio;
-
-        bio = kmalloc(sizeof(struct bio), GFP_KERNEL);
-        if (!bio)
-                goto no_bio;
-        bio_init(bio);
-
-        bvl = kcalloc(nr_iovecs, sizeof(struct bio_vec), GFP_KERNEL);
-        if (!bvl)
-                goto no_bvl;
-
-        bio->bi_max_vecs = nr_iovecs;
-        bio->bi_io_vec = bvl;
-        bio->bi_destructor = pkt_bio_destructor;
-
-        return bio;
-
- no_bvl:
-        kfree(bio);
- no_bio:
-        return NULL;
-}
-
 /*
  * Allocate a packet_data struct
  */
@@ -567,7 +535,7 @@ static struct packet_data *pkt_alloc_packet_data(int frames)
                 goto no_pkt;
 
         pkt->frames = frames;
-        pkt->w_bio = pkt_bio_alloc(frames);
+        pkt->w_bio = bio_kmalloc(GFP_KERNEL, frames);
         if (!pkt->w_bio)
                 goto no_bio;
 
@@ -581,9 +549,10 @@ static struct packet_data *pkt_alloc_packet_data(int frames)
         bio_list_init(&pkt->orig_bios);
 
         for (i = 0; i < frames; i++) {
-                struct bio *bio = pkt_bio_alloc(1);
+                struct bio *bio = bio_kmalloc(GFP_KERNEL, 1);
                 if (!bio)
                         goto no_rd_bio;
+
                 pkt->r_bios[i] = bio;
         }
 
@@ -1111,21 +1080,17 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
          * Schedule reads for missing parts of the packet.
          */
         for (f = 0; f < pkt->frames; f++) {
-                struct bio_vec *vec;
-
                 int p, offset;
+
                 if (written[f])
                         continue;
+
                 bio = pkt->r_bios[f];
-                vec = bio->bi_io_vec;
-                bio_init(bio);
-                bio->bi_max_vecs = 1;
+                bio_reset(bio);
                 bio->bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
                 bio->bi_bdev = pd->bdev;
                 bio->bi_end_io = pkt_end_io_read;
                 bio->bi_private = pkt;
-                bio->bi_io_vec = vec;
-                bio->bi_destructor = pkt_bio_destructor;
 
                 p = (f * CD_FRAMESIZE) / PAGE_SIZE;
                 offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
@@ -1418,14 +1383,11 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
         }
 
         /* Start the write request */
-        bio_init(pkt->w_bio);
-        pkt->w_bio->bi_max_vecs = PACKET_MAX_SIZE;
+        bio_reset(pkt->w_bio);
         pkt->w_bio->bi_sector = pkt->sector;
         pkt->w_bio->bi_bdev = pd->bdev;
         pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
         pkt->w_bio->bi_private = pkt;
-        pkt->w_bio->bi_io_vec = bvec;
-        pkt->w_bio->bi_destructor = pkt_bio_destructor;
         for (f = 0; f < pkt->frames; f++)
                 if (!bio_add_page(pkt->w_bio, bvec[f].bv_page, CD_FRAMESIZE, bvec[f].bv_offset))
                         BUG();
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 54a3a6d09819..0bb207eaef2f 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -285,7 +285,7 @@ static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd,
 
 static const struct file_operations raw_fops = {
         .read           = do_sync_read,
-        .aio_read       = generic_file_aio_read,
+        .aio_read       = blkdev_aio_read,
         .write          = do_sync_write,
         .aio_write      = blkdev_aio_write,
         .fsync          = blkdev_fsync,
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 664743d6a6cd..bbf459bca61d 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -798,14 +798,6 @@ static int crypt_convert(struct crypt_config *cc,
         return 0;
 }
 
-static void dm_crypt_bio_destructor(struct bio *bio)
-{
-        struct dm_crypt_io *io = bio->bi_private;
-        struct crypt_config *cc = io->cc;
-
-        bio_free(bio, cc->bs);
-}
-
 /*
  * Generate a new unfragmented bio with the given size
  * This should never violate the device limitations
@@ -974,7 +966,6 @@ static void clone_init(struct dm_crypt_io *io, struct bio *clone)
         clone->bi_end_io  = crypt_endio;
         clone->bi_bdev    = cc->dev->bdev;
         clone->bi_rw      = io->base_bio->bi_rw;
-        clone->bi_destructor = dm_crypt_bio_destructor;
 }
 
 static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
@@ -988,19 +979,14 @@ static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
          * copy the required bvecs because we need the original
          * one in order to decrypt the whole bio data *afterwards*.
          */
-        clone = bio_alloc_bioset(gfp, bio_segments(base_bio), cc->bs);
+        clone = bio_clone_bioset(base_bio, gfp, cc->bs);
         if (!clone)
                 return 1;
 
         crypt_inc_pending(io);
 
         clone_init(io, clone);
-        clone->bi_idx = 0;
-        clone->bi_vcnt = bio_segments(base_bio);
-        clone->bi_size = base_bio->bi_size;
         clone->bi_sector = cc->start + io->sector;
-        memcpy(clone->bi_io_vec, bio_iovec(base_bio),
-               sizeof(struct bio_vec) * clone->bi_vcnt);
 
         generic_make_request(clone);
         return 0;
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index ea5dd289fe2a..1c46f97d6664 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -249,16 +249,6 @@ static void vm_dp_init(struct dpages *dp, void *data)
         dp->context_ptr = data;
 }
 
-static void dm_bio_destructor(struct bio *bio)
-{
-        unsigned region;
-        struct io *io;
-
-        retrieve_io_and_region_from_bio(bio, &io, &region);
-
-        bio_free(bio, io->client->bios);
-}
-
 /*
  * Functions for getting the pages from kernel memory.
  */
@@ -317,7 +307,6 @@ static void do_region(int rw, unsigned region, struct dm_io_region *where,
                 bio->bi_sector = where->sector + (where->count - remaining);
                 bio->bi_bdev = where->bdev;
                 bio->bi_end_io = endio;
-                bio->bi_destructor = dm_bio_destructor;
                 store_io_and_region_in_bio(bio, io, region);
 
                 if (rw & REQ_DISCARD) {
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 67ffa391edcf..66ceaff6455c 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -86,12 +86,17 @@ struct dm_rq_target_io {
 };
 
 /*
- * For request-based dm.
- * One of these is allocated per bio.
+ * For request-based dm - the bio clones we allocate are embedded in these
+ * structs.
+ *
+ * We allocate these with bio_alloc_bioset, using the front_pad parameter when
+ * the bioset is created - this means the bio has to come at the end of the
+ * struct.
  */
 struct dm_rq_clone_bio_info {
         struct bio *orig;
         struct dm_rq_target_io *tio;
+        struct bio clone;
 };
 
 union map_info *dm_get_mapinfo(struct bio *bio)
@@ -211,6 +216,11 @@ struct dm_md_mempools {
 static struct kmem_cache *_io_cache;
 static struct kmem_cache *_tio_cache;
 static struct kmem_cache *_rq_tio_cache;
+
+/*
+ * Unused now, and needs to be deleted. But since io_pool is overloaded and it's
+ * still used for _io_cache, I'm leaving this for a later cleanup
+ */
 static struct kmem_cache *_rq_bio_info_cache;
 
 static int __init local_init(void)
@@ -467,16 +477,6 @@ static void free_rq_tio(struct dm_rq_target_io *tio)
         mempool_free(tio, tio->md->tio_pool);
 }
 
-static struct dm_rq_clone_bio_info *alloc_bio_info(struct mapped_device *md)
-{
-        return mempool_alloc(md->io_pool, GFP_ATOMIC);
-}
-
-static void free_bio_info(struct dm_rq_clone_bio_info *info)
-{
-        mempool_free(info, info->tio->md->io_pool);
-}
-
 static int md_in_flight(struct mapped_device *md)
 {
         return atomic_read(&md->pending[READ]) +
@@ -681,11 +681,6 @@ static void clone_endio(struct bio *bio, int error)
                 }
         }
 
-        /*
-         * Store md for cleanup instead of tio which is about to get freed.
-         */
-        bio->bi_private = md->bs;
-
         free_tio(md, tio);
         bio_put(bio);
         dec_pending(io, error);
@@ -1036,11 +1031,6 @@ static void __map_bio(struct dm_target *ti, struct bio *clone,
                 /* error the io and bail out, or requeue it if needed */
                 md = tio->io->md;
                 dec_pending(tio->io, r);
-                /*
-                 * Store bio_set for cleanup.
-                 */
-                clone->bi_end_io = NULL;
-                clone->bi_private = md->bs;
                 bio_put(clone);
                 free_tio(md, tio);
         } else if (r) {
@@ -1059,13 +1049,6 @@ struct clone_info {
         unsigned short idx;
 };
 
-static void dm_bio_destructor(struct bio *bio)
-{
-        struct bio_set *bs = bio->bi_private;
-
-        bio_free(bio, bs);
-}
-
 /*
  * Creates a little bio that just does part of a bvec.
  */
@@ -1077,7 +1060,6 @@ static struct bio *split_bvec(struct bio *bio, sector_t sector,
         struct bio_vec *bv = bio->bi_io_vec + idx;
 
         clone = bio_alloc_bioset(GFP_NOIO, 1, bs);
-        clone->bi_destructor = dm_bio_destructor;
         *clone->bi_io_vec = *bv;
 
         clone->bi_sector = sector;
@@ -1090,7 +1072,7 @@ static struct bio *split_bvec(struct bio *bio, sector_t sector,
         clone->bi_flags |= 1 << BIO_CLONED;
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
+                bio_integrity_clone(clone, bio, GFP_NOIO);
                 bio_integrity_trim(clone,
                                    bio_sector_offset(bio, idx, offset), len);
         }
@@ -1109,7 +1091,6 @@ static struct bio *clone_bio(struct bio *bio, sector_t sector,
 
         clone = bio_alloc_bioset(GFP_NOIO, bio->bi_max_vecs, bs);
         __bio_clone(clone, bio);
-        clone->bi_destructor = dm_bio_destructor;
         clone->bi_sector = sector;
         clone->bi_idx = idx;
         clone->bi_vcnt = idx + bv_count;
@@ -1117,7 +1098,7 @@ static struct bio *clone_bio(struct bio *bio, sector_t sector,
         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
+                bio_integrity_clone(clone, bio, GFP_NOIO);
 
                 if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
                         bio_integrity_trim(clone,
@@ -1152,9 +1133,8 @@ static void __issue_target_request(struct clone_info *ci, struct dm_target *ti,
          * ci->bio->bi_max_vecs is BIO_INLINE_VECS anyway, for both flush
          * and discard, so no need for concern about wasted bvec allocations.
          */
-        clone = bio_alloc_bioset(GFP_NOIO, ci->bio->bi_max_vecs, ci->md->bs);
-        __bio_clone(clone, ci->bio);
-        clone->bi_destructor = dm_bio_destructor;
+        clone = bio_clone_bioset(ci->bio, GFP_NOIO, ci->md->bs);
+
         if (len) {
                 clone->bi_sector = ci->sector;
                 clone->bi_size = to_bytes(len);
@@ -1484,30 +1464,17 @@ void dm_dispatch_request(struct request *rq)
 }
 EXPORT_SYMBOL_GPL(dm_dispatch_request);
 
-static void dm_rq_bio_destructor(struct bio *bio)
-{
-        struct dm_rq_clone_bio_info *info = bio->bi_private;
-        struct mapped_device *md = info->tio->md;
-
-        free_bio_info(info);
-        bio_free(bio, md->bs);
-}
-
 static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
                                  void *data)
 {
         struct dm_rq_target_io *tio = data;
-        struct mapped_device *md = tio->md;
-        struct dm_rq_clone_bio_info *info = alloc_bio_info(md);
-
-        if (!info)
-                return -ENOMEM;
+        struct dm_rq_clone_bio_info *info =
+                container_of(bio, struct dm_rq_clone_bio_info, clone);
 
         info->orig = bio_orig;
         info->tio = tio;
         bio->bi_end_io = end_clone_bio;
         bio->bi_private = info;
-        bio->bi_destructor = dm_rq_bio_destructor;
 
         return 0;
 }
@@ -2771,7 +2738,10 @@ struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity)
         if (!pools->tio_pool)
                 goto free_io_pool_and_out;
 
-        pools->bs = bioset_create(pool_size, 0);
+        pools->bs = (type == DM_TYPE_BIO_BASED) ?
+                bioset_create(pool_size, 0) :
+                bioset_create(pool_size,
+                              offsetof(struct dm_rq_clone_bio_info, clone));
         if (!pools->bs)
                 goto free_tio_pool_and_out;
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 308e87b417e0..95c88012a3b9 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -155,32 +155,17 @@ static int start_readonly;
  * like bio_clone, but with a local bio set
  */
 
-static void mddev_bio_destructor(struct bio *bio)
-{
-        struct mddev *mddev, **mddevp;
-
-        mddevp = (void*)bio;
-        mddev = mddevp[-1];
-
-        bio_free(bio, mddev->bio_set);
-}
-
 struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
                             struct mddev *mddev)
 {
         struct bio *b;
-        struct mddev **mddevp;
 
         if (!mddev || !mddev->bio_set)
                 return bio_alloc(gfp_mask, nr_iovecs);
 
-        b = bio_alloc_bioset(gfp_mask, nr_iovecs,
-                             mddev->bio_set);
+        b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
         if (!b)
                 return NULL;
-        mddevp = (void*)b;
-        mddevp[-1] = mddev;
-        b->bi_destructor = mddev_bio_destructor;
         return b;
 }
 EXPORT_SYMBOL_GPL(bio_alloc_mddev);
@@ -188,32 +173,10 @@ EXPORT_SYMBOL_GPL(bio_alloc_mddev);
 struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
                             struct mddev *mddev)
 {
-        struct bio *b;
-        struct mddev **mddevp;
-
         if (!mddev || !mddev->bio_set)
                 return bio_clone(bio, gfp_mask);
 
-        b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs,
-                             mddev->bio_set);
-        if (!b)
-                return NULL;
-        mddevp = (void*)b;
-        mddevp[-1] = mddev;
-        b->bi_destructor = mddev_bio_destructor;
-        __bio_clone(b, bio);
-        if (bio_integrity(bio)) {
-                int ret;
-
-                ret = bio_integrity_clone(b, bio, gfp_mask, mddev->bio_set);
-
-                if (ret < 0) {
-                        bio_put(b);
-                        return NULL;
-                }
-        }
-
-        return b;
+        return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
 }
 EXPORT_SYMBOL_GPL(bio_clone_mddev);
 
@@ -5006,8 +4969,7 @@ int md_run(struct mddev *mddev)
         }
 
         if (mddev->bio_set == NULL)
-                mddev->bio_set = bioset_create(BIO_POOL_SIZE,
-                                               sizeof(struct mddev *));
+                mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
 
         spin_lock(&pers_lock);
         pers = find_pers(mddev->level, mddev->clevel);
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index de63a1fc3737..a9e4fa95dfaa 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -422,6 +422,7 @@ static int raid0_run(struct mddev *mddev)
         if (md_check_no_bitmap(mddev))
                 return -EINVAL;
         blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
+        blk_queue_max_write_same_sectors(mddev->queue, mddev->chunk_sectors);
 
         /* if private is not null, we are here after takeover */
         if (mddev->private == NULL) {
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 29408d46a6d9..57d7674c5013 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -553,14 +553,6 @@ static void iblock_complete_cmd(struct se_cmd *cmd)
         kfree(ibr);
 }
 
-static void iblock_bio_destructor(struct bio *bio)
-{
-        struct se_cmd *cmd = bio->bi_private;
-        struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
-
-        bio_free(bio, ib_dev->ibd_bio_set);
-}
-
 static struct bio *
 iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
 {
@@ -582,7 +574,6 @@ iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
 
         bio->bi_bdev = ib_dev->ibd_bd;
         bio->bi_private = cmd;
-        bio->bi_destructor = iblock_bio_destructor;
         bio->bi_end_io = &iblock_bio_done;
         bio->bi_sector = lba;
         return bio;