Merge tag 'for-linus-20190104' of git://git.kernel.dk/linux-block

Pull block updates and fixes from Jens Axboe:

 - Pulled in MD changes that Shaohua had queued up for 4.21.

   Unfortunately we lost Shaohua late 2018, I'm sending these in on his
   behalf.

 - In conjunction with the above, I added a CREDITS entry for Shaoua.

 - sunvdc queue restart fix (Ming)

* tag 'for-linus-20190104' of git://git.kernel.dk/linux-block:
  Add CREDITS entry for Shaohua Li
  block: sunvdc: don't run hw queue synchronously from irq context
  md: fix raid10 hang issue caused by barrier
  raid10: refactor common wait code from regular read/write request
  md: remvoe redundant condition check
  lib/raid6: add option to skip algo benchmarking
  lib/raid6: sort algos in rough performance order
  lib/raid6: check for assembler SSSE3 support
  lib/raid6: avoid __attribute_const__ redefinition
  lib/raid6: add missing include for raid6test
  md: remove set but not used variable 'bi_rdev'

3 files changed, 34 insertions, 58 deletions

diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 0ff27e2d98c4..26937ba28f78 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -181,7 +181,7 @@ static void vdc_blk_queue_start(struct vdc_port *port)
          * allocated a disk.
          */
         if (port->disk && vdc_tx_dring_avail(dr) * 100 / VDC_TX_RING_SIZE >= 50)
-                blk_mq_start_hw_queues(port->disk->queue);
+                blk_mq_start_stopped_hw_queues(port->disk->queue, true);
 }
 
 static void vdc_finish(struct vio_driver_state *vio, int err, int waiting_for)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 9a0a1e0934d5..fd4af4de03b4 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2147,14 +2147,12 @@ EXPORT_SYMBOL(md_integrity_register);
  */
 int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
 {
-        struct blk_integrity *bi_rdev;
         struct blk_integrity *bi_mddev;
         char name[BDEVNAME_SIZE];
 
         if (!mddev->gendisk)
                 return 0;
 
-        bi_rdev = bdev_get_integrity(rdev->bdev);
         bi_mddev = blk_get_integrity(mddev->gendisk);
 
         if (!bi_mddev) /* nothing to do */
@@ -5693,14 +5691,10 @@ int md_run(struct mddev *mddev)
         return 0;
 
 abort:
-        if (mddev->flush_bio_pool) {
-                mempool_destroy(mddev->flush_bio_pool);
-                mddev->flush_bio_pool = NULL;
-        }
-        if (mddev->flush_pool){
-                mempool_destroy(mddev->flush_pool);
-                mddev->flush_pool = NULL;
-        }
+        mempool_destroy(mddev->flush_bio_pool);
+        mddev->flush_bio_pool = NULL;
+        mempool_destroy(mddev->flush_pool);
+        mddev->flush_pool = NULL;
 
         return err;
 }
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index b98e746e7fc4..abb5d382f64d 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1124,6 +1124,29 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule)
         kfree(plug);
 }
 
+/*
+ * 1. Register the new request and wait if the reconstruction thread has put
+ * up a bar for new requests. Continue immediately if no resync is active
+ * currently.
+ * 2. If IO spans the reshape position.  Need to wait for reshape to pass.
+ */
+static void regular_request_wait(struct mddev *mddev, struct r10conf *conf,
+                                 struct bio *bio, sector_t sectors)
+{
+        wait_barrier(conf);
+        while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
+            bio->bi_iter.bi_sector < conf->reshape_progress &&
+            bio->bi_iter.bi_sector + sectors > conf->reshape_progress) {
+                raid10_log(conf->mddev, "wait reshape");
+                allow_barrier(conf);
+                wait_event(conf->wait_barrier,
+                           conf->reshape_progress <= bio->bi_iter.bi_sector ||
+                           conf->reshape_progress >= bio->bi_iter.bi_sector +
+                           sectors);
+                wait_barrier(conf);
+        }
+}
+
 static void raid10_read_request(struct mddev *mddev, struct bio *bio,
                                 struct r10bio *r10_bio)
 {
@@ -1132,7 +1155,6 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,
         const int op = bio_op(bio);
         const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
         int max_sectors;
-        sector_t sectors;
         struct md_rdev *rdev;
         char b[BDEVNAME_SIZE];
         int slot = r10_bio->read_slot;
@@ -1166,30 +1188,8 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,
                 }
                 rcu_read_unlock();
         }
-        /*
-         * Register the new request and wait if the reconstruction
-         * thread has put up a bar for new requests.
-         * Continue immediately if no resync is active currently.
-         */
-        wait_barrier(conf);
-
-        sectors = r10_bio->sectors;
-        while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
-            bio->bi_iter.bi_sector < conf->reshape_progress &&
-            bio->bi_iter.bi_sector + sectors > conf->reshape_progress) {
-                /*
-                 * IO spans the reshape position.  Need to wait for reshape to
-                 * pass
-                 */
-                raid10_log(conf->mddev, "wait reshape");
-                allow_barrier(conf);
-                wait_event(conf->wait_barrier,
-                           conf->reshape_progress <= bio->bi_iter.bi_sector ||
-                           conf->reshape_progress >= bio->bi_iter.bi_sector +
-                           sectors);
-                wait_barrier(conf);
-        }
 
+        regular_request_wait(mddev, conf, bio, r10_bio->sectors);
         rdev = read_balance(conf, r10_bio, &max_sectors);
         if (!rdev) {
                 if (err_rdev) {
@@ -1209,7 +1209,9 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,
                 struct bio *split = bio_split(bio, max_sectors,
                                               gfp, &conf->bio_split);
                 bio_chain(split, bio);
+                allow_barrier(conf);
                 generic_make_request(bio);
+                wait_barrier(conf);
                 bio = split;
                 r10_bio->master_bio = bio;
                 r10_bio->sectors = max_sectors;
@@ -1332,30 +1334,8 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,
                 finish_wait(&conf->wait_barrier, &w);
         }
 
-        /*
-         * Register the new request and wait if the reconstruction
-         * thread has put up a bar for new requests.
-         * Continue immediately if no resync is active currently.
-         */
-        wait_barrier(conf);
-
         sectors = r10_bio->sectors;
-        while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
-            bio->bi_iter.bi_sector < conf->reshape_progress &&
-            bio->bi_iter.bi_sector + sectors > conf->reshape_progress) {
-                /*
-                 * IO spans the reshape position.  Need to wait for reshape to
-                 * pass
-                 */
-                raid10_log(conf->mddev, "wait reshape");
-                allow_barrier(conf);
-                wait_event(conf->wait_barrier,
-                           conf->reshape_progress <= bio->bi_iter.bi_sector ||
-                           conf->reshape_progress >= bio->bi_iter.bi_sector +
-                           sectors);
-                wait_barrier(conf);
-        }
-
+        regular_request_wait(mddev, conf, bio, sectors);
         if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
             (mddev->reshape_backwards
              ? (bio->bi_iter.bi_sector < conf->reshape_safe &&
@@ -1514,7 +1494,9 @@ retry_write:
                 struct bio *split = bio_split(bio, r10_bio->sectors,
                                               GFP_NOIO, &conf->bio_split);
                 bio_chain(split, bio);
+                allow_barrier(conf);
                 generic_make_request(bio);
+                wait_barrier(conf);
                 bio = split;
                 r10_bio->master_bio = bio;
         }