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, 29 insertions, 86 deletions

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 967a4ed73929..f39d69f884de 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -255,9 +255,10 @@ static void call_bio_endio(struct r1bio *r1_bio)
                 done = 1;
 
         if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
+                bio->bi_error = -EIO;
+
         if (done) {
-                bio_endio(bio, 0);
+                bio_endio(bio);
                 /*
                  * Wake up any possible resync thread that waits for the device
                  * to go idle.
@@ -312,9 +313,9 @@ static int find_bio_disk(struct r1bio *r1_bio, struct bio *bio)
         return mirror;
 }
 
-static void raid1_end_read_request(struct bio *bio, int error)
+static void raid1_end_read_request(struct bio *bio)
 {
-        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
+        int uptodate = !bio->bi_error;
         struct r1bio *r1_bio = bio->bi_private;
         int mirror;
         struct r1conf *conf = r1_bio->mddev->private;
@@ -397,9 +398,8 @@ static void r1_bio_write_done(struct r1bio *r1_bio)
         }
 }
 
-static void raid1_end_write_request(struct bio *bio, int error)
+static void raid1_end_write_request(struct bio *bio)
 {
-        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct r1bio *r1_bio = bio->bi_private;
         int mirror, behind = test_bit(R1BIO_BehindIO, &r1_bio->state);
         struct r1conf *conf = r1_bio->mddev->private;
@@ -410,7 +410,7 @@ static void raid1_end_write_request(struct bio *bio, int error)
         /*
          * 'one mirror IO has finished' event handler:
          */
-        if (!uptodate) {
+        if (bio->bi_error) {
                 set_bit(WriteErrorSeen,
                         &conf->mirrors[mirror].rdev->flags);
                 if (!test_and_set_bit(WantReplacement,
@@ -557,7 +557,6 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                 rdev = rcu_dereference(conf->mirrors[disk].rdev);
                 if (r1_bio->bios[disk] == IO_BLOCKED
                     || rdev == NULL
-                    || test_bit(Unmerged, &rdev->flags)
                     || test_bit(Faulty, &rdev->flags))
                         continue;
                 if (!test_bit(In_sync, &rdev->flags) &&
@@ -708,38 +707,6 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
         return best_disk;
 }
 
-static int raid1_mergeable_bvec(struct mddev *mddev,
-                                struct bvec_merge_data *bvm,
-                                struct bio_vec *biovec)
-{
-        struct r1conf *conf = mddev->private;
-        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
-        int max = biovec->bv_len;
-
-        if (mddev->merge_check_needed) {
-                int disk;
-                rcu_read_lock();
-                for (disk = 0; disk < conf->raid_disks * 2; disk++) {
-                        struct md_rdev *rdev = rcu_dereference(
-                                conf->mirrors[disk].rdev);
-                        if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                                struct request_queue *q =
-                                        bdev_get_queue(rdev->bdev);
-                                if (q->merge_bvec_fn) {
-                                        bvm->bi_sector = sector +
-                                                rdev->data_offset;
-                                        bvm->bi_bdev = rdev->bdev;
-                                        max = min(max, q->merge_bvec_fn(
-                                                          q, bvm, biovec));
-                                }
-                        }
-                }
-                rcu_read_unlock();
-        }
-        return max;
-
-}
-
 static int raid1_congested(struct mddev *mddev, int bits)
 {
         struct r1conf *conf = mddev->private;
@@ -793,7 +760,7 @@ static void flush_pending_writes(struct r1conf *conf)
                         if (unlikely((bio->bi_rw & REQ_DISCARD) &&
                             !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
                                 /* Just ignore it */
-                                bio_endio(bio, 0);
+                                bio_endio(bio);
                         else
                                 generic_make_request(bio);
                         bio = next;
@@ -1068,7 +1035,7 @@ static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule)
                 if (unlikely((bio->bi_rw & REQ_DISCARD) &&
                     !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
                         /* Just ignore it */
-                        bio_endio(bio, 0);
+                        bio_endio(bio);
                 else
                         generic_make_request(bio);
                 bio = next;
@@ -1158,7 +1125,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
          * non-zero, then it is the number of not-completed requests.
          */
         bio->bi_phys_segments = 0;
-        clear_bit(BIO_SEG_VALID, &bio->bi_flags);
+        bio_clear_flag(bio, BIO_SEG_VALID);
 
         if (rw == READ) {
                 /*
@@ -1269,8 +1236,7 @@ read_again:
                         break;
                 }
                 r1_bio->bios[i] = NULL;
-                if (!rdev || test_bit(Faulty, &rdev->flags)
-                    || test_bit(Unmerged, &rdev->flags)) {
+                if (!rdev || test_bit(Faulty, &rdev->flags)) {
                         if (i < conf->raid_disks)
                                 set_bit(R1BIO_Degraded, &r1_bio->state);
                         continue;
@@ -1617,7 +1583,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
         struct raid1_info *p;
         int first = 0;
         int last = conf->raid_disks - 1;
-        struct request_queue *q = bdev_get_queue(rdev->bdev);
 
         if (mddev->recovery_disabled == conf->recovery_disabled)
                 return -EBUSY;
@@ -1625,11 +1590,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
         if (rdev->raid_disk >= 0)
                 first = last = rdev->raid_disk;
 
-        if (q->merge_bvec_fn) {
-                set_bit(Unmerged, &rdev->flags);
-                mddev->merge_check_needed = 1;
-        }
-
         for (mirror = first; mirror <= last; mirror++) {
                 p = conf->mirrors+mirror;
                 if (!p->rdev) {
@@ -1661,19 +1621,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                         break;
                 }
         }
-        if (err == 0 && test_bit(Unmerged, &rdev->flags)) {
-                /* Some requests might not have seen this new
-                 * merge_bvec_fn.  We must wait for them to complete
-                 * before merging the device fully.
-                 * First we make sure any code which has tested
-                 * our function has submitted the request, then
-                 * we wait for all outstanding requests to complete.
-                 */
-                synchronize_sched();
-                freeze_array(conf, 0);
-                unfreeze_array(conf);
-                clear_bit(Unmerged, &rdev->flags);
-        }
         md_integrity_add_rdev(rdev, mddev);
         if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
                 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
@@ -1737,7 +1684,7 @@ abort:
         return err;
 }
 
-static void end_sync_read(struct bio *bio, int error)
+static void end_sync_read(struct bio *bio)
 {
         struct r1bio *r1_bio = bio->bi_private;
 
@@ -1748,16 +1695,16 @@ static void end_sync_read(struct bio *bio, int error)
          * or re-read if the read failed.
          * We don't do much here, just schedule handling by raid1d
          */
-        if (test_bit(BIO_UPTODATE, &bio->bi_flags))
+        if (!bio->bi_error)
                 set_bit(R1BIO_Uptodate, &r1_bio->state);
 
         if (atomic_dec_and_test(&r1_bio->remaining))
                 reschedule_retry(r1_bio);
 }
 
-static void end_sync_write(struct bio *bio, int error)
+static void end_sync_write(struct bio *bio)
 {
-        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
+        int uptodate = !bio->bi_error;
         struct r1bio *r1_bio = bio->bi_private;
         struct mddev *mddev = r1_bio->mddev;
         struct r1conf *conf = mddev->private;
@@ -1944,7 +1891,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio)
                 idx ++;
         }
         set_bit(R1BIO_Uptodate, &r1_bio->state);
-        set_bit(BIO_UPTODATE, &bio->bi_flags);
+        bio->bi_error = 0;
         return 1;
 }
 
@@ -1968,15 +1915,14 @@ static void process_checks(struct r1bio *r1_bio)
         for (i = 0; i < conf->raid_disks * 2; i++) {
                 int j;
                 int size;
-                int uptodate;
+                int error;
                 struct bio *b = r1_bio->bios[i];
                 if (b->bi_end_io != end_sync_read)
                         continue;
-                /* fixup the bio for reuse, but preserve BIO_UPTODATE */
-                uptodate = test_bit(BIO_UPTODATE, &b->bi_flags);
+                /* fixup the bio for reuse, but preserve errno */
+                error = b->bi_error;
                 bio_reset(b);
-                if (!uptodate)
-                        clear_bit(BIO_UPTODATE, &b->bi_flags);
+                b->bi_error = error;
                 b->bi_vcnt = vcnt;
                 b->bi_iter.bi_size = r1_bio->sectors << 9;
                 b->bi_iter.bi_sector = r1_bio->sector +
@@ -1999,7 +1945,7 @@ static void process_checks(struct r1bio *r1_bio)
         }
         for (primary = 0; primary < conf->raid_disks * 2; primary++)
                 if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
-                    test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
+                    !r1_bio->bios[primary]->bi_error) {
                         r1_bio->bios[primary]->bi_end_io = NULL;
                         rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
                         break;
@@ -2009,14 +1955,14 @@ static void process_checks(struct r1bio *r1_bio)
                 int j;
                 struct bio *pbio = r1_bio->bios[primary];
                 struct bio *sbio = r1_bio->bios[i];
-                int uptodate = test_bit(BIO_UPTODATE, &sbio->bi_flags);
+                int error = sbio->bi_error;
 
                 if (sbio->bi_end_io != end_sync_read)
                         continue;
-                /* Now we can 'fixup' the BIO_UPTODATE flag */
-                set_bit(BIO_UPTODATE, &sbio->bi_flags);
+                /* Now we can 'fixup' the error value */
+                sbio->bi_error = 0;
 
-                if (uptodate) {
+                if (!error) {
                         for (j = vcnt; j-- ; ) {
                                 struct page *p, *s;
                                 p = pbio->bi_io_vec[j].bv_page;
@@ -2031,7 +1977,7 @@ static void process_checks(struct r1bio *r1_bio)
                 if (j >= 0)
                         atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);
                 if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
-                              && uptodate)) {
+                              && !error)) {
                         /* No need to write to this device. */
                         sbio->bi_end_io = NULL;
                         rdev_dec_pending(conf->mirrors[i].rdev, mddev);
@@ -2272,11 +2218,11 @@ static void handle_sync_write_finished(struct r1conf *conf, struct r1bio *r1_bio
                 struct bio *bio = r1_bio->bios[m];
                 if (bio->bi_end_io == NULL)
                         continue;
-                if (test_bit(BIO_UPTODATE, &bio->bi_flags) &&
+                if (!bio->bi_error &&
                     test_bit(R1BIO_MadeGood, &r1_bio->state)) {
                         rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);
                 }
-                if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
+                if (bio->bi_error &&
                     test_bit(R1BIO_WriteError, &r1_bio->state)) {
                         if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))
                                 md_error(conf->mddev, rdev);
@@ -2715,7 +2661,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                                                 /* remove last page from this bio */
                                                 bio->bi_vcnt--;
                                                 bio->bi_iter.bi_size -= len;
-                                                __clear_bit(BIO_SEG_VALID, &bio->bi_flags);
+                                                bio_clear_flag(bio, BIO_SEG_VALID);
                                         }
                                         goto bio_full;
                                 }
@@ -2810,8 +2756,6 @@ static struct r1conf *setup_conf(struct mddev *mddev)
                         goto abort;
                 disk->rdev = rdev;
                 q = bdev_get_queue(rdev->bdev);
-                if (q->merge_bvec_fn)
-                        mddev->merge_check_needed = 1;
 
                 disk->head_position = 0;
                 disk->seq_start = MaxSector;
@@ -3176,7 +3120,6 @@ static struct md_personality raid1_personality =
         .quiesce        = raid1_quiesce,
         .takeover       = raid1_takeover,
         .congested      = raid1_congested,
-        .mergeable_bvec = raid1_mergeable_bvec,
 };
 
 static int __init raid_init(void)