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

Pull core block updates from Jens Axboe:
 "This first core part of the block IO changes contains:

   - Cleanup of the bio IO error signaling from Christoph.  We used to
     rely on the uptodate bit and passing around of an error, now we
     store the error in the bio itself.

   - Improvement of the above from myself, by shrinking the bio size
     down again to fit in two cachelines on x86-64.

   - Revert of the max_hw_sectors cap removal from a revision again,
     from Jeff Moyer.  This caused performance regressions in various
     tests.  Reinstate the limit, bump it to a more reasonable size
     instead.

   - Make /sys/block/<dev>/queue/discard_max_bytes writeable, by me.
     Most devices have huge trim limits, which can cause nasty latencies
     when deleting files.  Enable the admin to configure the size down.
     We will look into having a more sane default instead of UINT_MAX
     sectors.

   - Improvement of the SGP gaps logic from Keith Busch.

   - Enable the block core to handle arbitrarily sized bios, which
     enables a nice simplification of bio_add_page() (which is an IO hot
     path).  From Kent.

   - Improvements to the partition io stats accounting, making it
     faster.  From Ming Lei.

   - Also from Ming Lei, a basic fixup for overflow of the sysfs pending
     file in blk-mq, as well as a fix for a blk-mq timeout race
     condition.

   - Ming Lin has been carrying Kents above mentioned patches forward
     for a while, and testing them.  Ming also did a few fixes around
     that.

   - Sasha Levin found and fixed a use-after-free problem introduced by
     the bio->bi_error changes from Christoph.

   - Small blk cgroup cleanup from Viresh Kumar"

* 'for-4.3/core' of git://git.kernel.dk/linux-block: (26 commits)
  blk: Fix bio_io_vec index when checking bvec gaps
  block: Replace SG_GAPS with new queue limits mask
  block: bump BLK_DEF_MAX_SECTORS to 2560
  Revert "block: remove artifical max_hw_sectors cap"
  blk-mq: fix race between timeout and freeing request
  blk-mq: fix buffer overflow when reading sysfs file of 'pending'
  Documentation: update notes in biovecs about arbitrarily sized bios
  block: remove bio_get_nr_vecs()
  fs: use helper bio_add_page() instead of open coding on bi_io_vec
  block: kill merge_bvec_fn() completely
  md/raid5: get rid of bio_fits_rdev()
  md/raid5: split bio for chunk_aligned_read
  block: remove split code in blkdev_issue_{discard,write_same}
  btrfs: remove bio splitting and merge_bvec_fn() calls
  bcache: remove driver private bio splitting code
  block: simplify bio_add_page()
  block: make generic_make_request handle arbitrarily sized bios
  blk-cgroup: Drop unlikely before IS_ERR(_OR_NULL)
  block: don't access bio->bi_error after bio_put()
  block: shrink struct bio down to 2 cache lines again
  ...

1 files changed, 11 insertions, 126 deletions

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 0d7ab20c58df..6ffc01bb85f2 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -124,9 +124,8 @@ EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
 #define DMF_FREEING 3
 #define DMF_DELETING 4
 #define DMF_NOFLUSH_SUSPENDING 5
-#define DMF_MERGE_IS_OPTIONAL 6
-#define DMF_DEFERRED_REMOVE 7
-#define DMF_SUSPENDED_INTERNALLY 8
+#define DMF_DEFERRED_REMOVE 6
+#define DMF_SUSPENDED_INTERNALLY 7
 
 /*
  * A dummy definition to make RCU happy.
@@ -944,7 +943,8 @@ static void dec_pending(struct dm_io *io, int error)
                 } else {
                         /* done with normal IO or empty flush */
                         trace_block_bio_complete(md->queue, bio, io_error);
-                        bio_endio(bio, io_error);
+                        bio->bi_error = io_error;
+                        bio_endio(bio);
                 }
         }
 }
@@ -957,17 +957,15 @@ static void disable_write_same(struct mapped_device *md)
         limits->max_write_same_sectors = 0;
 }
 
-static void clone_endio(struct bio *bio, int error)
+static void clone_endio(struct bio *bio)
 {
+        int error = bio->bi_error;
         int r = error;
         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
         struct dm_io *io = tio->io;
         struct mapped_device *md = tio->io->md;
         dm_endio_fn endio = tio->ti->type->end_io;
 
-        if (!bio_flagged(bio, BIO_UPTODATE) && !error)
-                error = -EIO;
-
         if (endio) {
                 r = endio(tio->ti, bio, error);
                 if (r < 0 || r == DM_ENDIO_REQUEUE)
@@ -996,7 +994,7 @@ static void clone_endio(struct bio *bio, int error)
 /*
  * Partial completion handling for request-based dm
  */
-static void end_clone_bio(struct bio *clone, int error)
+static void end_clone_bio(struct bio *clone)
 {
         struct dm_rq_clone_bio_info *info =
                 container_of(clone, struct dm_rq_clone_bio_info, clone);
@@ -1013,13 +1011,13 @@ static void end_clone_bio(struct bio *clone, int error)
                  * the remainder.
                  */
                 return;
-        else if (error) {
+        else if (bio->bi_error) {
                 /*
                  * Don't notice the error to the upper layer yet.
                  * The error handling decision is made by the target driver,
                  * when the request is completed.
                  */
-                tio->error = error;
+                tio->error = bio->bi_error;
                 return;
         }
 
@@ -1722,60 +1720,6 @@ static void __split_and_process_bio(struct mapped_device *md,
  * CRUD END
  *---------------------------------------------------------------*/
 
-static int dm_merge_bvec(struct request_queue *q,
-                         struct bvec_merge_data *bvm,
-                         struct bio_vec *biovec)
-{
-        struct mapped_device *md = q->queuedata;
-        struct dm_table *map = dm_get_live_table_fast(md);
-        struct dm_target *ti;
-        sector_t max_sectors;
-        int max_size = 0;
-
-        if (unlikely(!map))
-                goto out;
-
-        ti = dm_table_find_target(map, bvm->bi_sector);
-        if (!dm_target_is_valid(ti))
-                goto out;
-
-        /*
-         * Find maximum amount of I/O that won't need splitting
-         */
-        max_sectors = min(max_io_len(bvm->bi_sector, ti),
-                          (sector_t) BIO_MAX_SECTORS);
-        max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
-        if (max_size < 0)
-                max_size = 0;
-
-        /*
-         * merge_bvec_fn() returns number of bytes
-         * it can accept at this offset
-         * max is precomputed maximal io size
-         */
-        if (max_size && ti->type->merge)
-                max_size = ti->type->merge(ti, bvm, biovec, max_size);
-        /*
-         * If the target doesn't support merge method and some of the devices
-         * provided their merge_bvec method (we know this by looking at
-         * queue_max_hw_sectors), then we can't allow bios with multiple vector
-         * entries.  So always set max_size to 0, and the code below allows
-         * just one page.
-         */
-        else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
-                max_size = 0;
-
-out:
-        dm_put_live_table_fast(md);
-        /*
-         * Always allow an entire first page
-         */
-        if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
-                max_size = biovec->bv_len;
-
-        return max_size;
-}
-
 /*
  * The request function that just remaps the bio built up by
  * dm_merge_bvec.
@@ -1789,6 +1733,8 @@ static void dm_make_request(struct request_queue *q, struct bio *bio)
 
         map = dm_get_live_table(md, &srcu_idx);
 
+        blk_queue_split(q, &bio, q->bio_split);
+
         generic_start_io_acct(rw, bio_sectors(bio), &dm_disk(md)->part0);
 
         /* if we're suspended, we have to queue this io for later */
@@ -2496,59 +2442,6 @@ static void __set_size(struct mapped_device *md, sector_t size)
 }
 
 /*
- * Return 1 if the queue has a compulsory merge_bvec_fn function.
- *
- * If this function returns 0, then the device is either a non-dm
- * device without a merge_bvec_fn, or it is a dm device that is
- * able to split any bios it receives that are too big.
- */
-int dm_queue_merge_is_compulsory(struct request_queue *q)
-{
-        struct mapped_device *dev_md;
-
-        if (!q->merge_bvec_fn)
-                return 0;
-
-        if (q->make_request_fn == dm_make_request) {
-                dev_md = q->queuedata;
-                if (test_bit(DMF_MERGE_IS_OPTIONAL, &dev_md->flags))
-                        return 0;
-        }
-
-        return 1;
-}
-
-static int dm_device_merge_is_compulsory(struct dm_target *ti,
-                                         struct dm_dev *dev, sector_t start,
-                                         sector_t len, void *data)
-{
-        struct block_device *bdev = dev->bdev;
-        struct request_queue *q = bdev_get_queue(bdev);
-
-        return dm_queue_merge_is_compulsory(q);
-}
-
-/*
- * Return 1 if it is acceptable to ignore merge_bvec_fn based
- * on the properties of the underlying devices.
- */
-static int dm_table_merge_is_optional(struct dm_table *table)
-{
-        unsigned i = 0;
-        struct dm_target *ti;
-
-        while (i < dm_table_get_num_targets(table)) {
-                ti = dm_table_get_target(table, i++);
-
-                if (ti->type->iterate_devices &&
-                    ti->type->iterate_devices(ti, dm_device_merge_is_compulsory, NULL))
-                        return 0;
-        }
-
-        return 1;
-}
-
-/*
  * Returns old map, which caller must destroy.
  */
 static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
@@ -2557,7 +2450,6 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
         struct dm_table *old_map;
         struct request_queue *q = md->queue;
         sector_t size;
-        int merge_is_optional;
 
         size = dm_table_get_size(t);
 
@@ -2583,17 +2475,11 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
 
         __bind_mempools(md, t);
 
-        merge_is_optional = dm_table_merge_is_optional(t);
-
         old_map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
         rcu_assign_pointer(md->map, t);
         md->immutable_target_type = dm_table_get_immutable_target_type(t);
 
         dm_table_set_restrictions(t, q, limits);
-        if (merge_is_optional)
-                set_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
-        else
-                clear_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
         if (old_map)
                 dm_sync_table(md);
 
@@ -2874,7 +2760,6 @@ int dm_setup_md_queue(struct mapped_device *md)
         case DM_TYPE_BIO_BASED:
                 dm_init_old_md_queue(md);
                 blk_queue_make_request(md->queue, dm_make_request);
-                blk_queue_merge_bvec(md->queue, dm_merge_bvec);
                 break;
         }