dm: allocate requests in target when stacking on blk-mq devices

For blk-mq request-based DM the responsibility of allocating a cloned
request is transfered from DM core to the target type.  Doing so
enables the cloned request to be allocated from the appropriate
blk-mq request_queue's pool (only the DM target, e.g. multipath, can
know which block device to send a given cloned request to).

Care was taken to preserve compatibility with old-style block request
completion that requires request-based DM _not_ acquire the clone
request's queue lock in the completion path.  As such, there are now 2
different request-based DM target_type interfaces:
1) the original .map_rq() interface will continue to be used for
   non-blk-mq devices -- the preallocated clone request is passed in
   from DM core.
2) a new .clone_and_map_rq() and .release_clone_rq() will be used for
   blk-mq devices -- blk_get_request() and blk_put_request() are used
   respectively from these hooks.

dm_table_set_type() was updated to detect if the request-based target is
being stacked on blk-mq devices, if so DM_TYPE_MQ_REQUEST_BASED is set.
DM core disallows switching the DM table's type after it is set.  This
means that there is no mixing of non-blk-mq and blk-mq devices within
the same request-based DM table.

[This patch was started by Keith and later heavily modified by Mike]

Tested-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Keith Busch <keith.busch@intel.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>

1 files changed, 43 insertions, 8 deletions

diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 2552b88f8953..863fc8c1ac06 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -11,6 +11,7 @@
 #include "dm-path-selector.h"
 #include "dm-uevent.h"
 
+#include <linux/blkdev.h>
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/mempool.h>
@@ -378,12 +379,13 @@ static int __must_push_back(struct multipath *m)
 /*
  * Map cloned requests
  */
-static int multipath_map(struct dm_target *ti, struct request *clone,
-                         union map_info *map_context)
+static int __multipath_map(struct dm_target *ti, struct request *clone,
+                           union map_info *map_context,
+                           struct request *rq, struct request **__clone)
 {
         struct multipath *m = (struct multipath *) ti->private;
         int r = DM_MAPIO_REQUEUE;
-        size_t nr_bytes = blk_rq_bytes(clone);
+        size_t nr_bytes = clone ? blk_rq_bytes(clone) : blk_rq_bytes(rq);
         struct pgpath *pgpath;
         struct block_device *bdev;
         struct dm_mpath_io *mpio;
@@ -416,12 +418,25 @@ static int multipath_map(struct dm_target *ti, struct request *clone,
 
         bdev = pgpath->path.dev->bdev;
 
-        clone->q = bdev_get_queue(bdev);
-        clone->rq_disk = bdev->bd_disk;
-        clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
-
         spin_unlock_irq(&m->lock);
 
+        if (clone) {
+                /* Old request-based interface: allocated clone is passed in */
+                clone->q = bdev_get_queue(bdev);
+                clone->rq_disk = bdev->bd_disk;
+                clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
+        } else {
+                /* blk-mq request-based interface */
+                *__clone = blk_get_request(bdev_get_queue(bdev),
+                                           rq_data_dir(rq), GFP_KERNEL);
+                if (IS_ERR(*__clone))
+                        /* ENOMEM, requeue */
+                        return r;
+                (*__clone)->bio = (*__clone)->biotail = NULL;
+                (*__clone)->rq_disk = bdev->bd_disk;
+                (*__clone)->cmd_flags |= REQ_FAILFAST_TRANSPORT;
+        }
+
         if (pgpath->pg->ps.type->start_io)
                 pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
                                               &pgpath->path,
@@ -434,6 +449,24 @@ out_unlock:
         return r;
 }
 
+static int multipath_map(struct dm_target *ti, struct request *clone,
+                         union map_info *map_context)
+{
+        return __multipath_map(ti, clone, map_context, NULL, NULL);
+}
+
+static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,
+                                   union map_info *map_context,
+                                   struct request **clone)
+{
+        return __multipath_map(ti, NULL, map_context, rq, clone);
+}
+
+static void multipath_release_clone(struct request *clone)
+{
+        blk_put_request(clone);
+}
+
 /*
  * If we run out of usable paths, should we queue I/O or error it?
  */
@@ -1670,11 +1703,13 @@ out:
  *---------------------------------------------------------------*/
 static struct target_type multipath_target = {
         .name = "multipath",
-        .version = {1, 7, 0},
+        .version = {1, 8, 0},
         .module = THIS_MODULE,
         .ctr = multipath_ctr,
         .dtr = multipath_dtr,
         .map_rq = multipath_map,
+        .clone_and_map_rq = multipath_clone_and_map,
+        .release_clone_rq = multipath_release_clone,
         .rq_end_io = multipath_end_io,
         .presuspend = multipath_presuspend,
         .postsuspend = multipath_postsuspend,