6 files changed, 91 insertions, 87 deletions

diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 4d1d8dfb2d2a..f2273143b3cb 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -963,6 +963,7 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c,
         uint32_t rtime = cpu_to_le32(get_seconds());
         struct uuid_entry *u;
         char buf[BDEVNAME_SIZE];
+        struct cached_dev *exist_dc, *t;
 
         bdevname(dc->bdev, buf);
 
@@ -987,6 +988,16 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c,
                 return -EINVAL;
         }
 
+        /* Check whether already attached */
+        list_for_each_entry_safe(exist_dc, t, &c->cached_devs, list) {
+                if (!memcmp(dc->sb.uuid, exist_dc->sb.uuid, 16)) {
+                        pr_err("Tried to attach %s but duplicate UUID already attached",
+                                buf);
+
+                        return -EINVAL;
+                }
+        }
+
         u = uuid_find(c, dc->sb.uuid);
 
         if (u &&
@@ -1204,7 +1215,7 @@ static void register_bdev(struct cache_sb *sb, struct page *sb_page,
 
         return;
 err:
-        pr_notice("error opening %s: %s", bdevname(bdev, name), err);
+        pr_notice("error %s: %s", bdevname(bdev, name), err);
         bcache_device_stop(&dc->disk);
 }
 
@@ -1883,6 +1894,8 @@ static int register_cache(struct cache_sb *sb, struct page *sb_page,
         const char *err = NULL; /* must be set for any error case */
         int ret = 0;
 
+        bdevname(bdev, name);
+
         memcpy(&ca->sb, sb, sizeof(struct cache_sb));
         ca->bdev = bdev;
         ca->bdev->bd_holder = ca;
@@ -1891,11 +1904,12 @@ static int register_cache(struct cache_sb *sb, struct page *sb_page,
         bio_first_bvec_all(&ca->sb_bio)->bv_page = sb_page;
         get_page(sb_page);
 
-        if (blk_queue_discard(bdev_get_queue(ca->bdev)))
+        if (blk_queue_discard(bdev_get_queue(bdev)))
                 ca->discard = CACHE_DISCARD(&ca->sb);
 
         ret = cache_alloc(ca);
         if (ret != 0) {
+                blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
                 if (ret == -ENOMEM)
                         err = "cache_alloc(): -ENOMEM";
                 else
@@ -1918,14 +1932,14 @@ static int register_cache(struct cache_sb *sb, struct page *sb_page,
                 goto out;
         }
 
-        pr_info("registered cache device %s", bdevname(bdev, name));
+        pr_info("registered cache device %s", name);
 
 out:
         kobject_put(&ca->kobj);
 
 err:
         if (err)
-                pr_notice("error opening %s: %s", bdevname(bdev, name), err);
+                pr_notice("error %s: %s", name, err);
 
         return ret;
 }
@@ -2014,6 +2028,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
         if (err)
                 goto err_close;
 
+        err = "failed to register device";
         if (SB_IS_BDEV(sb)) {
                 struct cached_dev *dc = kzalloc(sizeof(*dc), GFP_KERNEL);
                 if (!dc)
@@ -2028,7 +2043,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
                         goto err_close;
 
                 if (register_cache(sb, sb_page, bdev, ca) != 0)
-                        goto err_close;
+                        goto err;
         }
 out:
         if (sb_page)
@@ -2041,7 +2056,7 @@ out:
 err_close:
         blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 err:
-        pr_info("error opening %s: %s", path, err);
+        pr_info("error %s: %s", path, err);
         ret = -EINVAL;
         goto out;
 }
diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index 414c9af54ded..aa2032fa80d4 100644
--- a/drivers/md/dm-bufio.c
+++ b/drivers/md/dm-bufio.c
@@ -386,9 +386,6 @@ static void __cache_size_refresh(void)
 static void *alloc_buffer_data(struct dm_bufio_client *c, gfp_t gfp_mask,
                                enum data_mode *data_mode)
 {
-        unsigned noio_flag;
-        void *ptr;
-
         if (c->block_size <= DM_BUFIO_BLOCK_SIZE_SLAB_LIMIT) {
                 *data_mode = DATA_MODE_SLAB;
                 return kmem_cache_alloc(DM_BUFIO_CACHE(c), gfp_mask);
@@ -412,16 +409,15 @@ static void *alloc_buffer_data(struct dm_bufio_client *c, gfp_t gfp_mask,
          * all allocations done by this process (including pagetables) are done
          * as if GFP_NOIO was specified.
          */
+        if (gfp_mask & __GFP_NORETRY) {
+                unsigned noio_flag = memalloc_noio_save();
+                void *ptr = __vmalloc(c->block_size, gfp_mask, PAGE_KERNEL);
 
-        if (gfp_mask & __GFP_NORETRY)
-                noio_flag = memalloc_noio_save();
-
-        ptr = __vmalloc(c->block_size, gfp_mask, PAGE_KERNEL);
-
-        if (gfp_mask & __GFP_NORETRY)
                 memalloc_noio_restore(noio_flag);
+                return ptr;
+        }
 
-        return ptr;
+        return __vmalloc(c->block_size, gfp_mask, PAGE_KERNEL);
 }
 
 /*
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 7d3e572072f5..a05a560d3cba 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -211,29 +211,27 @@ static int alloc_multipath_stage2(struct dm_target *ti, struct multipath *m)
                 else
                         m->queue_mode = DM_TYPE_REQUEST_BASED;
 
-        } else if (m->queue_mode == DM_TYPE_BIO_BASED ||
-                   m->queue_mode == DM_TYPE_NVME_BIO_BASED) {
+        } else if (m->queue_mode == DM_TYPE_BIO_BASED) {
                 INIT_WORK(&m->process_queued_bios, process_queued_bios);
-
-                if (m->queue_mode == DM_TYPE_BIO_BASED) {
-                        /*
-                         * bio-based doesn't support any direct scsi_dh management;
-                         * it just discovers if a scsi_dh is attached.
-                         */
-                        set_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags);
-                }
-        }
-
-        if (m->queue_mode != DM_TYPE_NVME_BIO_BASED) {
-                set_bit(MPATHF_QUEUE_IO, &m->flags);
-                atomic_set(&m->pg_init_in_progress, 0);
-                atomic_set(&m->pg_init_count, 0);
-                m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
-                init_waitqueue_head(&m->pg_init_wait);
+                /*
+                 * bio-based doesn't support any direct scsi_dh management;
+                 * it just discovers if a scsi_dh is attached.
+                 */
+                set_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags);
         }
 
         dm_table_set_type(ti->table, m->queue_mode);
 
+        /*
+         * Init fields that are only used when a scsi_dh is attached
+         * - must do this unconditionally (really doesn't hurt non-SCSI uses)
+         */
+        set_bit(MPATHF_QUEUE_IO, &m->flags);
+        atomic_set(&m->pg_init_in_progress, 0);
+        atomic_set(&m->pg_init_count, 0);
+        m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
+        init_waitqueue_head(&m->pg_init_wait);
+
         return 0;
 }
 
@@ -337,9 +335,6 @@ static void __switch_pg(struct multipath *m, struct priority_group *pg)
 {
         m->current_pg = pg;
 
-        if (m->queue_mode == DM_TYPE_NVME_BIO_BASED)
-                return;
-
         /* Must we initialise the PG first, and queue I/O till it's ready? */
         if (m->hw_handler_name) {
                 set_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
@@ -385,8 +380,7 @@ static struct pgpath *choose_pgpath(struct multipath *m, size_t nr_bytes)
         unsigned bypassed = 1;
 
         if (!atomic_read(&m->nr_valid_paths)) {
-                if (m->queue_mode != DM_TYPE_NVME_BIO_BASED)
-                        clear_bit(MPATHF_QUEUE_IO, &m->flags);
+                clear_bit(MPATHF_QUEUE_IO, &m->flags);
                 goto failed;
         }
 
@@ -599,7 +593,7 @@ static struct pgpath *__map_bio(struct multipath *m, struct bio *bio)
         return pgpath;
 }
 
-static struct pgpath *__map_bio_nvme(struct multipath *m, struct bio *bio)
+static struct pgpath *__map_bio_fast(struct multipath *m, struct bio *bio)
 {
         struct pgpath *pgpath;
         unsigned long flags;
@@ -634,8 +628,8 @@ static int __multipath_map_bio(struct multipath *m, struct bio *bio,
 {
         struct pgpath *pgpath;
 
-        if (m->queue_mode == DM_TYPE_NVME_BIO_BASED)
-                pgpath = __map_bio_nvme(m, bio);
+        if (!m->hw_handler_name)
+                pgpath = __map_bio_fast(m, bio);
         else
                 pgpath = __map_bio(m, bio);
 
@@ -675,8 +669,7 @@ static void process_queued_io_list(struct multipath *m)
 {
         if (m->queue_mode == DM_TYPE_MQ_REQUEST_BASED)
                 dm_mq_kick_requeue_list(dm_table_get_md(m->ti->table));
-        else if (m->queue_mode == DM_TYPE_BIO_BASED ||
-                 m->queue_mode == DM_TYPE_NVME_BIO_BASED)
+        else if (m->queue_mode == DM_TYPE_BIO_BASED)
                 queue_work(kmultipathd, &m->process_queued_bios);
 }
 
@@ -811,15 +804,14 @@ static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
         return 0;
 }
 
-static int setup_scsi_dh(struct block_device *bdev, struct multipath *m, char **error)
+static int setup_scsi_dh(struct block_device *bdev, struct multipath *m,
+                         const char *attached_handler_name, char **error)
 {
         struct request_queue *q = bdev_get_queue(bdev);
-        const char *attached_handler_name;
         int r;
 
         if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags)) {
 retain:
-                attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
                 if (attached_handler_name) {
                         /*
                          * Clear any hw_handler_params associated with a
@@ -873,6 +865,8 @@ static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps
         int r;
         struct pgpath *p;
         struct multipath *m = ti->private;
+        struct request_queue *q;
+        const char *attached_handler_name;
 
         /* we need at least a path arg */
         if (as->argc < 1) {
@@ -891,9 +885,11 @@ static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps
                 goto bad;
         }
 
-        if (m->queue_mode != DM_TYPE_NVME_BIO_BASED) {
+        q = bdev_get_queue(p->path.dev->bdev);
+        attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
+        if (attached_handler_name) {
                 INIT_DELAYED_WORK(&p->activate_path, activate_path_work);
-                r = setup_scsi_dh(p->path.dev->bdev, m, &ti->error);
+                r = setup_scsi_dh(p->path.dev->bdev, m, attached_handler_name, &ti->error);
                 if (r) {
                         dm_put_device(ti, p->path.dev);
                         goto bad;
@@ -1001,8 +997,7 @@ static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
         if (!hw_argc)
                 return 0;
 
-        if (m->queue_mode == DM_TYPE_BIO_BASED ||
-            m->queue_mode == DM_TYPE_NVME_BIO_BASED) {
+        if (m->queue_mode == DM_TYPE_BIO_BASED) {
                 dm_consume_args(as, hw_argc);
                 DMERR("bio-based multipath doesn't allow hardware handler args");
                 return 0;
@@ -1091,8 +1086,6 @@ static int parse_features(struct dm_arg_set *as, struct multipath *m)
 
                         if (!strcasecmp(queue_mode_name, "bio"))
                                 m->queue_mode = DM_TYPE_BIO_BASED;
-                        else if (!strcasecmp(queue_mode_name, "nvme"))
-                                m->queue_mode = DM_TYPE_NVME_BIO_BASED;
                         else if (!strcasecmp(queue_mode_name, "rq"))
                                 m->queue_mode = DM_TYPE_REQUEST_BASED;
                         else if (!strcasecmp(queue_mode_name, "mq"))
@@ -1193,7 +1186,7 @@ static int multipath_ctr(struct dm_target *ti, unsigned argc, char **argv)
         ti->num_discard_bios = 1;
         ti->num_write_same_bios = 1;
         ti->num_write_zeroes_bios = 1;
-        if (m->queue_mode == DM_TYPE_BIO_BASED || m->queue_mode == DM_TYPE_NVME_BIO_BASED)
+        if (m->queue_mode == DM_TYPE_BIO_BASED)
                 ti->per_io_data_size = multipath_per_bio_data_size();
         else
                 ti->per_io_data_size = sizeof(struct dm_mpath_io);
@@ -1730,9 +1723,6 @@ static void multipath_status(struct dm_target *ti, status_type_t type,
                         case DM_TYPE_BIO_BASED:
                                 DMEMIT("queue_mode bio ");
                                 break;
-                        case DM_TYPE_NVME_BIO_BASED:
-                                DMEMIT("queue_mode nvme ");
-                                break;
                         case DM_TYPE_MQ_REQUEST_BASED:
                                 DMEMIT("queue_mode mq ");
                                 break;
@@ -2030,8 +2020,9 @@ static int multipath_busy(struct dm_target *ti)
  *---------------------------------------------------------------*/
 static struct target_type multipath_target = {
         .name = "multipath",
-        .version = {1, 12, 0},
-        .features = DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
+        .version = {1, 13, 0},
+        .features = DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE |
+                    DM_TARGET_PASSES_INTEGRITY,
         .module = THIS_MODULE,
         .ctr = multipath_ctr,
         .dtr = multipath_dtr,
diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index 7ef469e902c6..c1d1034ff7b7 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -3408,9 +3408,10 @@ static sector_t rs_get_progress(struct raid_set *rs, unsigned long recovery,
                 set_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags);
 
         } else {
-                if (test_bit(MD_RECOVERY_NEEDED, &recovery) ||
-                    test_bit(MD_RECOVERY_RESHAPE, &recovery) ||
-                    test_bit(MD_RECOVERY_RUNNING, &recovery))
+                if (!test_bit(MD_RECOVERY_INTR, &recovery) &&
+                    (test_bit(MD_RECOVERY_NEEDED, &recovery) ||
+                     test_bit(MD_RECOVERY_RESHAPE, &recovery) ||
+                     test_bit(MD_RECOVERY_RUNNING, &recovery)))
                         r = mddev->curr_resync_completed;
                 else
                         r = mddev->recovery_cp;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 5fe7ec356c33..7eb3e2a3c07d 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -942,17 +942,12 @@ static int dm_table_determine_type(struct dm_table *t)
 
         if (t->type != DM_TYPE_NONE) {
                 /* target already set the table's type */
-                if (t->type == DM_TYPE_BIO_BASED)
-                        return 0;
-                else if (t->type == DM_TYPE_NVME_BIO_BASED) {
-                        if (!dm_table_does_not_support_partial_completion(t)) {
-                                DMERR("nvme bio-based is only possible with devices"
-                                      " that don't support partial completion");
-                                return -EINVAL;
-                        }
-                        /* Fallthru, also verify all devices are blk-mq */
+                if (t->type == DM_TYPE_BIO_BASED) {
+                        /* possibly upgrade to a variant of bio-based */
+                        goto verify_bio_based;
                 }
                 BUG_ON(t->type == DM_TYPE_DAX_BIO_BASED);
+                BUG_ON(t->type == DM_TYPE_NVME_BIO_BASED);
                 goto verify_rq_based;
         }
 
@@ -985,6 +980,7 @@ static int dm_table_determine_type(struct dm_table *t)
         }
 
         if (bio_based) {
+verify_bio_based:
                 /* We must use this table as bio-based */
                 t->type = DM_TYPE_BIO_BASED;
                 if (dm_table_supports_dax(t) ||
@@ -1755,7 +1751,7 @@ static int device_no_partial_completion(struct dm_target *ti, struct dm_dev *dev
         char b[BDEVNAME_SIZE];
 
         /* For now, NVMe devices are the only devices of this class */
-        return (strncmp(bdevname(dev->bdev, b), "nvme", 3) == 0);
+        return (strncmp(bdevname(dev->bdev, b), "nvme", 4) == 0);
 }
 
 static bool dm_table_does_not_support_partial_completion(struct dm_table *t)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 68136806d365..45328d8b2859 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -458,9 +458,11 @@ static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return dm_get_geometry(md, geo);
 }
 
-static int dm_grab_bdev_for_ioctl(struct mapped_device *md,
-                                  struct block_device **bdev,
-                                  fmode_t *mode)
+static char *_dm_claim_ptr = "I belong to device-mapper";
+
+static int dm_get_bdev_for_ioctl(struct mapped_device *md,
+                                 struct block_device **bdev,
+                                 fmode_t *mode)
 {
         struct dm_target *tgt;
         struct dm_table *map;
@@ -490,6 +492,10 @@ retry:
                 goto out;
 
         bdgrab(*bdev);
+        r = blkdev_get(*bdev, *mode, _dm_claim_ptr);
+        if (r < 0)
+                goto out;
+
         dm_put_live_table(md, srcu_idx);
         return r;
 
@@ -508,7 +514,7 @@ static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
         struct mapped_device *md = bdev->bd_disk->private_data;
         int r;
 
-        r = dm_grab_bdev_for_ioctl(md, &bdev, &mode);
+        r = dm_get_bdev_for_ioctl(md, &bdev, &mode);
         if (r < 0)
                 return r;
 
@@ -528,7 +534,7 @@ static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
 
         r =  __blkdev_driver_ioctl(bdev, mode, cmd, arg);
 out:
-        bdput(bdev);
+        blkdev_put(bdev, mode);
         return r;
 }
 
@@ -708,14 +714,13 @@ static void dm_put_live_table_fast(struct mapped_device *md) __releases(RCU)
 static int open_table_device(struct table_device *td, dev_t dev,
                              struct mapped_device *md)
 {
-        static char *_claim_ptr = "I belong to device-mapper";
         struct block_device *bdev;
 
         int r;
 
         BUG_ON(td->dm_dev.bdev);
 
-        bdev = blkdev_get_by_dev(dev, td->dm_dev.mode | FMODE_EXCL, _claim_ptr);
+        bdev = blkdev_get_by_dev(dev, td->dm_dev.mode | FMODE_EXCL, _dm_claim_ptr);
         if (IS_ERR(bdev))
                 return PTR_ERR(bdev);
 
@@ -3011,7 +3016,7 @@ static int dm_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
         fmode_t mode;
         int r;
 
-        r = dm_grab_bdev_for_ioctl(md, &bdev, &mode);
+        r = dm_get_bdev_for_ioctl(md, &bdev, &mode);
         if (r < 0)
                 return r;
 
@@ -3021,7 +3026,7 @@ static int dm_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
         else
                 r = -EOPNOTSUPP;
 
-        bdput(bdev);
+        blkdev_put(bdev, mode);
         return r;
 }
 
@@ -3032,7 +3037,7 @@ static int dm_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
         fmode_t mode;
         int r;
 
-        r = dm_grab_bdev_for_ioctl(md, &bdev, &mode);
+        r = dm_get_bdev_for_ioctl(md, &bdev, &mode);
         if (r < 0)
                 return r;
 
@@ -3042,7 +3047,7 @@ static int dm_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
         else
                 r = -EOPNOTSUPP;
 
-        bdput(bdev);
+        blkdev_put(bdev, mode);
         return r;
 }
 
@@ -3054,7 +3059,7 @@ static int dm_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
         fmode_t mode;
         int r;
 
-        r = dm_grab_bdev_for_ioctl(md, &bdev, &mode);
+        r = dm_get_bdev_for_ioctl(md, &bdev, &mode);
         if (r < 0)
                 return r;
 
@@ -3064,7 +3069,7 @@ static int dm_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
         else
                 r = -EOPNOTSUPP;
 
-        bdput(bdev);
+        blkdev_put(bdev, mode);
         return r;
 }
 
@@ -3075,7 +3080,7 @@ static int dm_pr_clear(struct block_device *bdev, u64 key)
         fmode_t mode;
         int r;
 
-        r = dm_grab_bdev_for_ioctl(md, &bdev, &mode);
+        r = dm_get_bdev_for_ioctl(md, &bdev, &mode);
         if (r < 0)
                 return r;
 
@@ -3085,7 +3090,7 @@ static int dm_pr_clear(struct block_device *bdev, u64 key)
         else
                 r = -EOPNOTSUPP;
 
-        bdput(bdev);
+        blkdev_put(bdev, mode);
         return r;
 }