nvme: introduce multipath_always_on module param

Currently, a multipath head disk node is not created for single-
ported NVMe adapters or private namespaces with non-unique NSID.
However, creating a head node in these cases can help transparently
handle transient PCIe link failures. Without a head node, features
like delayed removal cannot be leveraged, making it difficult to
tolerate such link failures. To address this, this commit introduces
nvme_core module parameter multipath_always_on.

When multipath_always_on is set to true, it forces the creation of a
multipath head node regardless NVMe disk or namespace type. So this
option allows the use of delayed removal of head node functionality
even for single-ported NVMe disks and private namespaces with a unique
NSID and thus helps transparently handle transient PCIe link failures.

By default multipath_always_on is set to false, thus preserving the
existing behavior. Setting it to true enables improved fault tolerance
in PCIe setups. Moreover, please note that enabling this option would
also implicitly enable nvme_core.multipath.

Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Nilay Shroff <nilay@linux.ibm.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index 2db326d6114f4176ac62a2887348e35ef9820deb..38b420fb63f0c9112f93c1f80fe1334ecb38f812 100644 (file)
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -10,10 +10,61 @@
 #include "nvme.h"
 
 bool multipath = true;
-module_param(multipath, bool, 0444);
+static bool multipath_always_on;
+
+static int multipath_param_set(const char *val, const struct kernel_param *kp)
+{
+       int ret;
+       bool *arg = kp->arg;
+
+       ret = param_set_bool(val, kp);
+       if (ret)
+               return ret;
+
+       if (multipath_always_on && !*arg) {
+               pr_err("Can't disable multipath when multipath_always_on is configured.\n");
+               *arg = true;
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static const struct kernel_param_ops multipath_param_ops = {
+       .set = multipath_param_set,
+       .get = param_get_bool,
+};
+
+module_param_cb(multipath, &multipath_param_ops, &multipath, 0444);
 MODULE_PARM_DESC(multipath,
        "turn on native support for multiple controllers per subsystem");
 
+static int multipath_always_on_set(const char *val,
+               const struct kernel_param *kp)
+{
+       int ret;
+       bool *arg = kp->arg;
+
+       ret = param_set_bool(val, kp);
+       if (ret < 0)
+               return ret;
+
+       if (*arg)
+               multipath = true;
+
+       return 0;
+}
+
+static const struct kernel_param_ops multipath_always_on_ops = {
+       .set = multipath_always_on_set,
+       .get = param_get_bool,
+};
+
+module_param_cb(multipath_always_on, &multipath_always_on_ops,
+               &multipath_always_on, 0444);
+MODULE_PARM_DESC(multipath_always_on,
+       "create multipath node always except for private namespace with non-unique nsid; note that this also implicitly enables native multipath support");
+
 static const char *nvme_iopolicy_names[] = {
        [NVME_IOPOLICY_NUMA]    = "numa",
        [NVME_IOPOLICY_RR]      = "round-robin",
@@ -674,12 +725,21 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head)
        head->delayed_removal_secs = 0;
 
        /*
-        * Add a multipath node if the subsystems supports multiple controllers.
-        * We also do this for private namespaces as the namespace sharing flag
-        * could change after a rescan.
+        * If "multipath_always_on" is enabled, a multipath node is added
+        * regardless of whether the disk is single/multi ported, and whether
+        * the namespace is shared or private. If "multipath_always_on" is not
+        * enabled, a multipath node is added only if the subsystem supports
+        * multiple controllers and the "multipath" option is configured. In
+        * either case, for private namespaces, we ensure that the NSID is
+        * unique.
         */
-       if (!(ctrl->subsys->cmic & NVME_CTRL_CMIC_MULTI_CTRL) ||
-           !nvme_is_unique_nsid(ctrl, head) || !multipath)
+       if (!multipath_always_on) {
+               if (!(ctrl->subsys->cmic & NVME_CTRL_CMIC_MULTI_CTRL) ||
+                               !multipath)
+                       return 0;
+       }
+
+       if (!nvme_is_unique_nsid(ctrl, head))
                return 0;
 
        blk_set_stacking_limits(&lim);