[PATCH 19/19] nvme-multipath: switch to use libmultipath

John Garry
2026-02-25T15:41:30Z

Now that as much unused libmulipath-based code has been added, do the
full switch over.

The major change is that the multipath management is moved out of the
nvme_ns_head structure and into mpath_head and mpath_disk structures.

The check for ns->head->disk is now replaced with a ns->mpath_disk check,
it decide whether we are really in multipath mode. Similarly everywhere
we were referencing ns->head->disk, we reference ns->mpath_disk->disk.

Signed-off-by: John Garry <john.g.garry@oracle.com>
---
drivers/nvme/host/core.c | 65 ++-
drivers/nvme/host/ioctl.c | 89 ----
drivers/nvme/host/multipath.c | 865 +++++++---------------------------
drivers/nvme/host/nvme.h | 72 +--
drivers/nvme/host/pr.c | 355 +++-----------
drivers/nvme/host/sysfs.c | 84 ++--
6 files changed, 318 insertions(+), 1212 deletions(-)

diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index 2d0faec902eb2..be757879f19b2 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -667,9 +667,7 @@ static void nvme_free_ns_head(struct kref *ref)
struct nvme_ns_head *head =
container_of(ref, struct nvme_ns_head, ref);

- nvme_mpath_put_disk(head);
ida_free(&head->subsys->ns_ida, head->instance);
- cleanup_srcu_struct(&head->srcu);
nvme_put_subsystem(head->subsys);
kfree(head->plids);
kfree(head);
@@ -2488,9 +2486,12 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)
struct queue_limits *ns_lim = &ns->disk->queue->limits;
struct queue_limits lim;
unsigned int memflags;
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct gendisk *disk = mpath_disk->disk;

- lim = queue_limits_start_update(ns->head->disk->queue);
- memflags = blk_mq_freeze_queue(ns->head->disk->queue);
+ lim = queue_limits_start_update(disk->queue);
+ memflags = blk_mq_freeze_queue(disk->queue);
/*
* queue_limits mixes values that are the hardware limitations
* for bio splitting with what is the device configuration.
@@ -2511,20 +2512,20 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)
lim.io_min = ns_lim->io_min;
lim.io_opt = ns_lim->io_opt;
queue_limits_stack_bdev(&lim, ns->disk->part0, 0,
- ns->head->disk->disk_name);
+ disk->disk_name);
if (unsupported)
- ns->head->disk->flags |= GENHD_FL_HIDDEN;
+ disk->flags |= GENHD_FL_HIDDEN;
else
nvme_init_integrity(ns->head, &lim, info);
lim.max_write_streams = ns_lim->max_write_streams;
lim.write_stream_granularity = ns_lim->write_stream_granularity;
- ret = queue_limits_commit_update(ns->head->disk->queue, &lim);
+ ret = queue_limits_commit_update(disk->queue, &lim);

- set_capacity_and_notify(ns->head->disk, get_capacity(ns->disk));
- set_disk_ro(ns->head->disk, nvme_ns_is_readonly(ns, info));
- nvme_mpath_revalidate_paths(ns->head);
+ set_capacity_and_notify(disk, get_capacity(ns->disk));
+ set_disk_ro(disk, nvme_ns_is_readonly(ns, info));
+ nvme_mpath_revalidate_paths(head);

- blk_mq_unfreeze_queue(ns->head->disk->queue, memflags);
+ blk_mq_unfreeze_queue(disk->queue, memflags);
}

return ret;
@@ -3884,10 +3885,6 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl,
size_t size = sizeof(*head);
int ret = -ENOMEM;

-#ifdef CONFIG_NVME_MULTIPATH
- size += num_possible_nodes() * sizeof(struct nvme_ns *);
-#endif
-
head = kzalloc(size, GFP_KERNEL);
if (!head)
goto out;
@@ -3895,10 +3892,7 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl,
if (ret < 0)
goto out_free_head;
head->instance = ret;
- INIT_LIST_HEAD(&head->list);
- ret = init_srcu_struct(&head->srcu);
- if (ret)
- goto out_ida_remove;
+
head->subsys = ctrl->subsys;
head->ns_id = info->nsid;
head->ids = info->ids;
@@ -3911,22 +3905,20 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl,
if (head->ids.csi) {
ret = nvme_get_effects_log(ctrl, head->ids.csi, &head->effects);
if (ret)
- goto out_cleanup_srcu;
+ goto out_ida_free;
} else
head->effects = ctrl->effects;

ret = nvme_mpath_alloc_disk(ctrl, head);
if (ret)
- goto out_cleanup_srcu;
+ goto out_ida_free;

list_add_tail(&head->entry, &ctrl->subsys->nsheads);

kref_get(&ctrl->subsys->ref);

return head;
-out_cleanup_srcu:
- cleanup_srcu_struct(&head->srcu);
-out_ida_remove:
+out_ida_free:
ida_free(&ctrl->subsys->ns_ida, head->instance);
out_free_head:
kfree(head);
@@ -3965,7 +3957,7 @@ static int nvme_global_check_duplicate_ids(struct nvme_subsystem *this,
static int nvme_init_ns_head(struct nvme_ns *ns, struct nvme_ns_info *info)
{
struct nvme_ctrl *ctrl = ns->ctrl;
- struct nvme_ns_head *head = NULL;
+ struct nvme_ns_head *head;
int ret;

ret = nvme_global_check_duplicate_ids(ctrl->subsys, &info->ids);
@@ -4046,14 +4038,11 @@ static int nvme_init_ns_head(struct nvme_ns *ns, struct nvme_ns_info *info)
}
}

- list_add_tail_rcu(&ns->siblings, &head->list);
head->ns_count++;
ns->head = head;
+ nvme_mpath_add_ns(ns);
mutex_unlock(&ctrl->subsys->lock);

-#ifdef CONFIG_NVME_MULTIPATH
- cancel_delayed_work(&head->remove_work);
-#endif
return 0;

out_put_ns_head:
@@ -4192,24 +4181,24 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, struct nvme_ns_info *info)
synchronize_srcu(&ctrl->srcu);
out_unlink_ns:
mutex_lock(&ctrl->subsys->lock);
- list_del_rcu(&ns->siblings);
+ nvme_mpath_delete_ns(ns);
ns->head->ns_count--;
if (!ns->head->ns_count) {
list_del_init(&ns->head->entry);
/*
* If multipath is not configured, we still create a namespace
- * head (nshead), but head->disk is not initialized in that
+ * head (nshead), but mpath_head->disk is not initialized in that
* case. As a result, only a single reference to nshead is held
* (via kref_init()) when it is created. Therefore, ensure that
* we do not release the reference to nshead twice if head->disk
* is not present.
*/
- if (ns->head->disk)
+ if (nvme_mpath_has_disk(ns->head))
last_path = true;
}
mutex_unlock(&ctrl->subsys->lock);
if (last_path)
- nvme_put_ns_head(ns->head);
+ nvme_mpath_remove_disk(ns->head);
nvme_put_ns_head(ns->head);
out_cleanup_disk:
put_disk(disk);
@@ -4233,24 +4222,24 @@ static void nvme_ns_remove(struct nvme_ns *ns)
* Ensure that !NVME_NS_READY is seen by other threads to prevent
* this ns going back into current_path.
*/
- synchronize_srcu(&ns->head->srcu);
+ nvme_mpath_synchronize(head);

/* wait for concurrent submissions */
if (nvme_mpath_clear_current_path(ns))
- synchronize_srcu(&ns->head->srcu);
+ nvme_mpath_synchronize(head);

mutex_lock(&ns->ctrl->subsys->lock);
- list_del_rcu(&ns->siblings);
+ nvme_mpath_delete_ns(ns);
head->ns_count--;
if (!head->ns_count) {
- if (!nvme_mpath_queue_if_no_path(ns->head))
+ if (!nvme_mpath_head_queue_if_no_path(head))
list_del_init(&ns->head->entry);
last_path = true;
}
mutex_unlock(&ns->ctrl->subsys->lock);

/* guarantee not available in head->list */
- synchronize_srcu(&ns->head->srcu);
+ nvme_mpath_synchronize(head);

if (!nvme_ns_head_multipath(ns->head))
nvme_cdev_del(&ns->cdev, &ns->cdev_device);
diff --git a/drivers/nvme/host/ioctl.c b/drivers/nvme/host/ioctl.c
index 773c819cde52a..a243662b461e9 100644
--- a/drivers/nvme/host/ioctl.c
+++ b/drivers/nvme/host/ioctl.c
@@ -710,22 +710,6 @@ int nvme_mpath_chr_uring_cmd(struct mpath_device *mpath_device,
return nvme_ns_uring_cmd(ns, ioucmd, issue_flags);
}

-static int nvme_ns_head_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd,
- void __user *argp, struct nvme_ns_head *head, int srcu_idx,
- bool open_for_write)
- __releases(&head->srcu)
-{
- struct nvme_ctrl *ctrl = ns->ctrl;
- int ret;
-
- nvme_get_ctrl(ns->ctrl);
- srcu_read_unlock(&head->srcu, srcu_idx);
- ret = nvme_ctrl_ioctl(ns->ctrl, cmd, argp, open_for_write);
-
- nvme_put_ctrl(ctrl);
- return ret;
-}
-
int nvme_mpath_bdev_ioctl(struct block_device *bdev,
struct mpath_device *mpath_device, blk_mode_t mode,
unsigned int cmd, unsigned long arg, int srcu_idx)
@@ -783,79 +767,6 @@ int nvme_mpath_cdev_ioctl(struct mpath_head *mpath_head,
return ret;
}

-int nvme_ns_head_ioctl(struct block_device *bdev, blk_mode_t mode,
- unsigned int cmd, unsigned long arg)
-{
- struct nvme_ns_head *head = bdev->bd_disk->private_data;
- bool open_for_write = mode & BLK_OPEN_WRITE;
- void __user *argp = (void __user *)arg;
- struct nvme_ns *ns;
- int srcu_idx, ret = -EWOULDBLOCK;
- unsigned int flags = 0;
-
- if (bdev_is_partition(bdev))
- flags |= NVME_IOCTL_PARTITION;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (!ns)
- goto out_unlock;
-
- /*
- * Handle ioctls that apply to the controller instead of the namespace
- * separately and drop the ns SRCU reference early. This avoids a
- * deadlock when deleting namespaces using the passthrough interface.
- */
- if (is_ctrl_ioctl(cmd))
- return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx,
- open_for_write);
-
- ret = nvme_ns_ioctl(ns, cmd, argp, flags, open_for_write);
-out_unlock:
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
-
-long nvme_ns_head_chr_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
-{
- bool open_for_write = file->f_mode & FMODE_WRITE;
- struct cdev *cdev = file_inode(file)->i_cdev;
- struct nvme_ns_head *head =
- container_of(cdev, struct nvme_ns_head, cdev);
- void __user *argp = (void __user *)arg;
- struct nvme_ns *ns;
- int srcu_idx, ret = -EWOULDBLOCK;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (!ns)
- goto out_unlock;
-
- if (is_ctrl_ioctl(cmd))
- return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx,
- open_for_write);
-
- ret = nvme_ns_ioctl(ns, cmd, argp, 0, open_for_write);
-out_unlock:
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
-
-int nvme_ns_head_chr_uring_cmd(struct io_uring_cmd *ioucmd,
- unsigned int issue_flags)
-{
- struct cdev *cdev = file_inode(ioucmd->file)->i_cdev;
- struct nvme_ns_head *head = container_of(cdev, struct nvme_ns_head, cdev);
- int srcu_idx = srcu_read_lock(&head->srcu);
- struct nvme_ns *ns = nvme_find_path(head);
- int ret = -EINVAL;
-
- if (ns)
- ret = nvme_ns_uring_cmd(ns, ioucmd, issue_flags);
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
#endif /* CONFIG_NVME_MULTIPATH */

int nvme_dev_uring_cmd(struct io_uring_cmd *ioucmd, unsigned int issue_flags)
diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index 081a8a20a9908..c686cabfd9d16 100644
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -67,33 +67,17 @@ module_param_cb(multipath_always_on, &multipath_always_on_ops,
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",
- [NVME_IOPOLICY_QD] = "queue-depth",
-};

-static int iopolicy = NVME_IOPOLICY_NUMA;
+static int iopolicy = MPATH_IOPOLICY_NUMA;

static int nvme_set_iopolicy(const char *val, const struct kernel_param *kp)
{
- if (!val)
- return -EINVAL;
- if (!strncmp(val, "numa", 4))
- iopolicy = NVME_IOPOLICY_NUMA;
- else if (!strncmp(val, "round-robin", 11))
- iopolicy = NVME_IOPOLICY_RR;
- else if (!strncmp(val, "queue-depth", 11))
- iopolicy = NVME_IOPOLICY_QD;
- else
- return -EINVAL;
-
- return 0;
+ return mpath_set_iopolicy(val, &iopolicy);
}

static int nvme_get_iopolicy(char *buf, const struct kernel_param *kp)
{
- return sprintf(buf, "%s\n", nvme_iopolicy_names[iopolicy]);
+ return mpath_get_iopolicy(buf, iopolicy);
}

module_param_call(iopolicy, nvme_set_iopolicy, nvme_get_iopolicy,
@@ -103,7 +87,7 @@ MODULE_PARM_DESC(iopolicy,

void nvme_mpath_default_iopolicy(struct nvme_subsystem *subsys)
{
- subsys->iopolicy = iopolicy;
+ subsys->iopolicy.iopolicy = iopolicy;
}

void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
@@ -111,9 +95,13 @@ void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
struct nvme_ns_head *h;

lockdep_assert_held(&subsys->lock);
- list_for_each_entry(h, &subsys->nsheads, entry)
- if (h->disk)
- blk_mq_unfreeze_queue_nomemrestore(h->disk->queue);
+ list_for_each_entry(h, &subsys->nsheads, entry) {
+ struct mpath_disk *mpath_disk = h->mpath_disk;
+
+ if (mpath_disk)
+ blk_mq_unfreeze_queue_nomemrestore(
+ mpath_disk->disk->queue);
+ }
}

void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
@@ -121,9 +109,12 @@ void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
struct nvme_ns_head *h;

lockdep_assert_held(&subsys->lock);
- list_for_each_entry(h, &subsys->nsheads, entry)
- if (h->disk)
- blk_mq_freeze_queue_wait(h->disk->queue);
+ list_for_each_entry(h, &subsys->nsheads, entry) {
+ struct mpath_disk *mpath_disk = h->mpath_disk;
+
+ if (mpath_disk)
+ blk_mq_freeze_queue_wait(mpath_disk->disk->queue);
+ }
}

void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
@@ -131,15 +122,22 @@ void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
struct nvme_ns_head *h;

lockdep_assert_held(&subsys->lock);
- list_for_each_entry(h, &subsys->nsheads, entry)
- if (h->disk)
- blk_freeze_queue_start(h->disk->queue);
+ list_for_each_entry(h, &subsys->nsheads, entry) {
+ struct mpath_disk *mpath_disk = h->mpath_disk;
+
+ if (mpath_disk)
+ blk_freeze_queue_start(mpath_disk->disk->queue);
+ }
}

void nvme_failover_req(struct request *req)
{
struct nvme_ns *ns = req->q->queuedata;
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;
u16 status = nvme_req(req)->status & NVME_SCT_SC_MASK;
+ struct gendisk *disk = mpath_disk->disk;
unsigned long flags;
struct bio *bio;

@@ -155,9 +153,9 @@ void nvme_failover_req(struct request *req)
queue_work(nvme_wq, &ns->ctrl->ana_work);
}

- spin_lock_irqsave(&ns->head->requeue_lock, flags);
+ spin_lock_irqsave(&mpath_head->requeue_lock, flags);
for (bio = req->bio; bio; bio = bio->bi_next) {
- bio_set_dev(bio, ns->head->disk->part0);
+ bio_set_dev(bio, disk->part0);
if (bio->bi_opf & REQ_POLLED) {
bio->bi_opf &= ~REQ_POLLED;
bio->bi_cookie = BLK_QC_T_NONE;
@@ -171,20 +169,23 @@ void nvme_failover_req(struct request *req)
*/
bio->bi_opf &= ~REQ_NOWAIT;
}
- blk_steal_bios(&ns->head->requeue_list, req);
- spin_unlock_irqrestore(&ns->head->requeue_lock, flags);
+ blk_steal_bios(&mpath_head->requeue_list, req);
+ spin_unlock_irqrestore(&mpath_head->requeue_lock, flags);

nvme_req(req)->status = 0;
nvme_end_req(req);
- kblockd_schedule_work(&ns->head->requeue_work);
+ kblockd_schedule_work(&mpath_head->requeue_work);
}

void nvme_mpath_start_request(struct request *rq)
{
struct nvme_ns *ns = rq->q->queuedata;
- struct gendisk *disk = ns->head->disk;
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct gendisk *disk = mpath_disk->disk;
+ struct nvme_subsystem *subsys = head->subsys;

- if ((READ_ONCE(ns->head->subsys->iopolicy) == NVME_IOPOLICY_QD) &&
+ if (mpath_qd_iopolicy(&subsys->iopolicy) &&
!(nvme_req(rq)->flags & NVME_MPATH_CNT_ACTIVE)) {
atomic_inc(&ns->ctrl->nr_active);
nvme_req(rq)->flags |= NVME_MPATH_CNT_ACTIVE;
@@ -203,13 +204,15 @@ EXPORT_SYMBOL_GPL(nvme_mpath_start_request);
void nvme_mpath_end_request(struct request *rq)
{
struct nvme_ns *ns = rq->q->queuedata;
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;

if (nvme_req(rq)->flags & NVME_MPATH_CNT_ACTIVE)
atomic_dec_if_positive(&ns->ctrl->nr_active);

if (!(nvme_req(rq)->flags & NVME_MPATH_IO_STATS))
return;
- bdev_end_io_acct(ns->head->disk->part0, req_op(rq),
+ bdev_end_io_acct(mpath_disk->disk->part0, req_op(rq),
blk_rq_bytes(rq) >> SECTOR_SHIFT,
nvme_req(rq)->start_time);
}
@@ -232,11 +235,17 @@ void nvme_kick_requeue_lists(struct nvme_ctrl *ctrl)
srcu_idx = srcu_read_lock(&ctrl->srcu);
list_for_each_entry_srcu(ns, &ctrl->namespaces, list,
srcu_read_lock_held(&ctrl->srcu)) {
- if (!ns->head->disk)
+ struct mpath_disk *mpath_disk = ns->head->mpath_disk;
+ struct mpath_head *mpath_head;
+ struct gendisk *disk;
+
+ if (!mpath_disk)
continue;
- kblockd_schedule_work(&ns->head->requeue_work);
+ mpath_head = mpath_disk->mpath_head;
+ disk = mpath_disk->disk;
+ kblockd_schedule_work(&mpath_head->requeue_work);
if (nvme_ctrl_state(ns->ctrl) == NVME_CTRL_LIVE)
- disk_uevent(ns->head->disk, KOBJ_CHANGE);
+ disk_uevent(disk, KOBJ_CHANGE);
}
srcu_read_unlock(&ctrl->srcu, srcu_idx);
}
@@ -253,20 +262,13 @@ static const char *nvme_ana_state_names[] = {
bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
{
struct nvme_ns_head *head = ns->head;
- bool changed = false;
- int node;
+ struct mpath_disk *mpath_disk = head->mpath_disk;

- if (!head)
- goto out;
+ if (!mpath_disk)
+ return false;

- for_each_node(node) {
- if (ns == rcu_access_pointer(head->current_path[node])) {
- rcu_assign_pointer(head->current_path[node], NULL);
- changed = true;
- }
- }
-out:
- return changed;
+ return mpath_clear_current_path(mpath_disk->mpath_head,
+ &ns->mpath_device);
}

void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
@@ -277,30 +279,35 @@ void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
srcu_idx = srcu_read_lock(&ctrl->srcu);
list_for_each_entry_srcu(ns, &ctrl->namespaces, list,
srcu_read_lock_held(&ctrl->srcu)) {
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+
+ if (!mpath_disk)
+ continue;
+
nvme_mpath_clear_current_path(ns);
- kblockd_schedule_work(&ns->head->requeue_work);
+ kblockd_schedule_work(&mpath_disk->mpath_head->requeue_work);
}
srcu_read_unlock(&ctrl->srcu, srcu_idx);
}

+static void nvme_mpath_revalidate_paths_cb(struct mpath_device *mpath_device,
+ sector_t capacity)
+{
+ struct nvme_ns *ns = nvme_mpath_to_ns(mpath_device);
+
+ if (capacity != get_capacity(ns->disk))
+ clear_bit(NVME_NS_READY, &ns->flags);
+}
+
void nvme_mpath_revalidate_paths(struct nvme_ns_head *head)
{
- sector_t capacity = get_capacity(head->disk);
- struct nvme_ns *ns;
- int node;
- int srcu_idx;
+ struct mpath_disk *mpath_disk = head->mpath_disk;

- srcu_idx = srcu_read_lock(&head->srcu);
- list_for_each_entry_srcu(ns, &head->list, siblings,
- srcu_read_lock_held(&head->srcu)) {
- if (capacity != get_capacity(ns->disk))
- clear_bit(NVME_NS_READY, &ns->flags);
- }
- srcu_read_unlock(&head->srcu, srcu_idx);
+ if (!mpath_disk)
+ return;

- for_each_node(node)
- rcu_assign_pointer(head->current_path[node], NULL);
- kblockd_schedule_work(&head->requeue_work);
+ mpath_revalidate_paths(mpath_disk, nvme_mpath_revalidate_paths_cb);
}

static bool nvme_path_is_disabled(struct nvme_ns *ns)
@@ -327,142 +334,6 @@ static bool nvme_mpath_is_disabled(struct mpath_device *mpath_device)
return nvme_path_is_disabled(ns);
}

-static struct nvme_ns *__nvme_find_path(struct nvme_ns_head *head, int node)
-{
- int found_distance = INT_MAX, fallback_distance = INT_MAX, distance;
- struct nvme_ns *found = NULL, *fallback = NULL, *ns;
-
- list_for_each_entry_srcu(ns, &head->list, siblings,
- srcu_read_lock_held(&head->srcu)) {
- if (nvme_path_is_disabled(ns))
- continue;
-
- if (ns->ctrl->numa_node != NUMA_NO_NODE &&
- READ_ONCE(head->subsys->iopolicy) == NVME_IOPOLICY_NUMA)
- distance = node_distance(node, ns->ctrl->numa_node);
- else
- distance = LOCAL_DISTANCE;
-
- switch (ns->ana_state) {
- case NVME_ANA_OPTIMIZED:
- if (distance < found_distance) {
- found_distance = distance;
- found = ns;
- }
- break;
- case NVME_ANA_NONOPTIMIZED:
- if (distance < fallback_distance) {
- fallback_distance = distance;
- fallback = ns;
- }
- break;
- default:
- break;
- }
- }
-
- if (!found)
- found = fallback;
- if (found)
- rcu_assign_pointer(head->current_path[node], found);
- return found;
-}
-
-static struct nvme_ns *nvme_next_ns(struct nvme_ns_head *head,
- struct nvme_ns *ns)
-{
- ns = list_next_or_null_rcu(&head->list, &ns->siblings, struct nvme_ns,
- siblings);
- if (ns)
- return ns;
- return list_first_or_null_rcu(&head->list, struct nvme_ns, siblings);
-}
-
-static struct nvme_ns *nvme_round_robin_path(struct nvme_ns_head *head)
-{
- struct nvme_ns *ns, *found = NULL;
- int node = numa_node_id();
- struct nvme_ns *old = srcu_dereference(head->current_path[node],
- &head->srcu);
-
- if (unlikely(!old))
- return __nvme_find_path(head, node);
-
- if (list_is_singular(&head->list)) {
- if (nvme_path_is_disabled(old))
- return NULL;
- return old;
- }
-
- for (ns = nvme_next_ns(head, old);
- ns && ns != old;
- ns = nvme_next_ns(head, ns)) {
- if (nvme_path_is_disabled(ns))
- continue;
-
- if (ns->ana_state == NVME_ANA_OPTIMIZED) {
- found = ns;
- goto out;
- }
- if (ns->ana_state == NVME_ANA_NONOPTIMIZED)
- found = ns;
- }
-
- /*
- * The loop above skips the current path for round-robin semantics.
- * Fall back to the current path if either:
- * - no other optimized path found and current is optimized,
- * - no other usable path found and current is usable.
- */
- if (!nvme_path_is_disabled(old) &&
- (old->ana_state == NVME_ANA_OPTIMIZED ||
- (!found && old->ana_state == NVME_ANA_NONOPTIMIZED)))
- return old;
-
- if (!found)
- return NULL;
-out:
- rcu_assign_pointer(head->current_path[node], found);
- return found;
-}
-
-static struct nvme_ns *nvme_queue_depth_path(struct nvme_ns_head *head)
-{
- struct nvme_ns *best_opt = NULL, *best_nonopt = NULL, *ns;
- unsigned int min_depth_opt = UINT_MAX, min_depth_nonopt = UINT_MAX;
- unsigned int depth;
-
- list_for_each_entry_srcu(ns, &head->list, siblings,
- srcu_read_lock_held(&head->srcu)) {
- if (nvme_path_is_disabled(ns))
- continue;
-
- depth = atomic_read(&ns->ctrl->nr_active);
-
- switch (ns->ana_state) {
- case NVME_ANA_OPTIMIZED:
- if (depth < min_depth_opt) {
- min_depth_opt = depth;
- best_opt = ns;
- }
- break;
- case NVME_ANA_NONOPTIMIZED:
- if (depth < min_depth_nonopt) {
- min_depth_nonopt = depth;
- best_nonopt = ns;
- }
- break;
- default:
- break;
- }
-
- if (min_depth_opt == 0)
- return best_opt;
- }
-
- return best_opt ? best_opt : best_nonopt;
-}
-
static inline bool nvme_path_is_optimized(struct nvme_ns *ns)
{
return nvme_ctrl_state(ns->ctrl) == NVME_CTRL_LIVE &&
@@ -476,64 +347,6 @@ static bool nvme_mpath_is_optimized(struct mpath_device *mpath_device)
return nvme_path_is_optimized(ns);
}

-static struct nvme_ns *nvme_numa_path(struct nvme_ns_head *head)
-{
- int node = numa_node_id();
- struct nvme_ns *ns;
-
- ns = srcu_dereference(head->current_path[node], &head->srcu);
- if (unlikely(!ns))
- return __nvme_find_path(head, node);
- if (unlikely(!nvme_path_is_optimized(ns)))
- return __nvme_find_path(head, node);
- return ns;
-}
-
-inline struct nvme_ns *nvme_find_path(struct nvme_ns_head *head)
-{
- switch (READ_ONCE(head->subsys->iopolicy)) {
- case NVME_IOPOLICY_QD:
- return nvme_queue_depth_path(head);
- case NVME_IOPOLICY_RR:
- return nvme_round_robin_path(head);
- default:
- return nvme_numa_path(head);
- }
-}
-
-static bool nvme_available_path(struct nvme_ns_head *head)
-{
- struct nvme_ns *ns;
-
- if (!test_bit(NVME_NSHEAD_DISK_LIVE, &head->flags))
- return false;
-
- list_for_each_entry_srcu(ns, &head->list, siblings,
- srcu_read_lock_held(&head->srcu)) {
- if (test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ns->ctrl->flags))
- continue;
- switch (nvme_ctrl_state(ns->ctrl)) {
- case NVME_CTRL_LIVE:
- case NVME_CTRL_RESETTING:
- case NVME_CTRL_CONNECTING:
- return true;
- default:
- break;
- }
- }
-
- /*
- * If "head->delayed_removal_secs" is configured (i.e., non-zero), do
- * not immediately fail I/O. Instead, requeue the I/O for the configured
- * duration, anticipating that if there's a transient link failure then
- * it may recover within this time window. This parameter is exported to
- * userspace via sysfs, and its default value is zero. It is internally
- * mapped to NVME_NSHEAD_QUEUE_IF_NO_PATH. When delayed_removal_secs is
- * non-zero, this flag is set to true. When zero, the flag is cleared.
- */
- return nvme_mpath_queue_if_no_path(head);
-}
-
static bool nvme_mpath_available_path(struct mpath_device *mpath_device,
bool *available)
{
@@ -554,94 +367,12 @@ static bool nvme_mpath_available_path(struct mpath_device *mpath_device,
return true;
}

-static void nvme_ns_head_submit_bio(struct bio *bio)
-{
- struct nvme_ns_head *head = bio->bi_bdev->bd_disk->private_data;
- struct device *dev = disk_to_dev(head->disk);
- struct nvme_ns *ns;
- int srcu_idx;
-
- /*
- * The namespace might be going away and the bio might be moved to a
- * different queue via blk_steal_bios(), so we need to use the bio_split
- * pool from the original queue to allocate the bvecs from.
- */
- bio = bio_split_to_limits(bio);
- if (!bio)
- return;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (likely(ns)) {
- bio_set_dev(bio, ns->disk->part0);
- bio->bi_opf |= REQ_NVME_MPATH;
- trace_block_bio_remap(bio, disk_devt(ns->head->disk),
- bio->bi_iter.bi_sector);
- submit_bio_noacct(bio);
- } else if (nvme_available_path(head)) {
- dev_warn_ratelimited(dev, "no usable path - requeuing I/O\n");
-
- spin_lock_irq(&head->requeue_lock);
- bio_list_add(&head->requeue_list, bio);
- spin_unlock_irq(&head->requeue_lock);
- } else {
- dev_warn_ratelimited(dev, "no available path - failing I/O\n");
-
- bio_io_error(bio);
- }
-
- srcu_read_unlock(&head->srcu, srcu_idx);
-}
-
-static int nvme_ns_head_open(struct gendisk *disk, blk_mode_t mode)
-{
- if (!nvme_tryget_ns_head(disk->private_data))
- return -ENXIO;
- return 0;
-}
-
-static void nvme_ns_head_release(struct gendisk *disk)
-{
- nvme_put_ns_head(disk->private_data);
-}
-
-static int nvme_ns_head_get_unique_id(struct gendisk *disk, u8 id[16],
- enum blk_unique_id type)
-{
- struct nvme_ns_head *head = disk->private_data;
- struct nvme_ns *ns;
- int srcu_idx, ret = -EWOULDBLOCK;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (ns)
- ret = nvme_ns_get_unique_id(ns, id, type);
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
-
static int nvme_mpath_get_unique_id(struct mpath_device *mpath_device,
u8 id[16], enum blk_unique_id type)
{
return nvme_ns_get_unique_id(nvme_mpath_to_ns(mpath_device), id, type);
}
-
#ifdef CONFIG_BLK_DEV_ZONED
-static int nvme_ns_head_report_zones(struct gendisk *disk, sector_t sector,
- unsigned int nr_zones, struct blk_report_zones_args *args)
-{
- struct nvme_ns_head *head = disk->private_data;
- struct nvme_ns *ns;
- int srcu_idx, ret = -EWOULDBLOCK;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (ns)
- ret = nvme_ns_report_zones(ns, sector, nr_zones, args);
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
-
static int nvme_mpath_report_zones(struct mpath_device *mpath_device,
sector_t sector, unsigned int nr_zones,
struct blk_report_zones_args *args)
@@ -650,51 +381,9 @@ static int nvme_mpath_report_zones(struct mpath_device *mpath_device,
nr_zones, args);
}
#else
-#define nvme_ns_head_report_zones NULL
#define nvme_mpath_report_zones NULL
#endif /* CONFIG_BLK_DEV_ZONED */

-const struct block_device_operations nvme_ns_head_ops = {
- .owner = THIS_MODULE,
- .submit_bio = nvme_ns_head_submit_bio,
- .open = nvme_ns_head_open,
- .release = nvme_ns_head_release,
- .ioctl = nvme_ns_head_ioctl,
- .compat_ioctl = blkdev_compat_ptr_ioctl,
- .getgeo = nvme_getgeo,
- .get_unique_id = nvme_ns_head_get_unique_id,
- .report_zones = nvme_ns_head_report_zones,
- .pr_ops = &nvme_pr_ops,
-};
-
-static inline struct nvme_ns_head *cdev_to_ns_head(struct cdev *cdev)
-{
- return container_of(cdev, struct nvme_ns_head, cdev);
-}
-
-static int nvme_ns_head_chr_open(struct inode *inode, struct file *file)
-{
- if (!nvme_tryget_ns_head(cdev_to_ns_head(inode->i_cdev)))
- return -ENXIO;
- return 0;
-}
-
-static int nvme_ns_head_chr_release(struct inode *inode, struct file *file)
-{
- nvme_put_ns_head(cdev_to_ns_head(inode->i_cdev));
- return 0;
-}
-
-static const struct file_operations nvme_ns_head_chr_fops = {
- .owner = THIS_MODULE,
- .open = nvme_ns_head_chr_open,
- .release = nvme_ns_head_chr_release,
- .unlocked_ioctl = nvme_ns_head_chr_ioctl,
- .compat_ioctl = compat_ptr_ioctl,
- .uring_cmd = nvme_ns_head_chr_uring_cmd,
- .uring_cmd_iopoll = nvme_ns_chr_uring_cmd_iopoll,
-};
-
static int nvme_mpath_add_cdev(struct mpath_head *mpath_head)
{
struct nvme_ns_head *head = mpath_head->drvdata;
@@ -715,72 +404,17 @@ static void nvme_mpath_del_cdev(struct mpath_head *mpath_head)
nvme_cdev_del(&mpath_head->cdev, &mpath_head->cdev_device);
}

-static int nvme_add_ns_head_cdev(struct nvme_ns_head *head)
-{
- int ret;
-
- head->cdev_device.parent = &head->subsys->dev;
- ret = dev_set_name(&head->cdev_device, "ng%dn%d",
- head->subsys->instance, head->instance);
- if (ret)
- return ret;
- ret = nvme_cdev_add(&head->cdev, &head->cdev_device,
- &nvme_ns_head_chr_fops, THIS_MODULE);
- return ret;
-}
-
-static void nvme_partition_scan_work(struct work_struct *work)
-{
- struct nvme_ns_head *head =
- container_of(work, struct nvme_ns_head, partition_scan_work);
-
- if (WARN_ON_ONCE(!test_and_clear_bit(GD_SUPPRESS_PART_SCAN,
- &head->disk->state)))
- return;
-
- mutex_lock(&head->disk->open_mutex);
- bdev_disk_changed(head->disk, false);
- mutex_unlock(&head->disk->open_mutex);
-}
-
-static void nvme_requeue_work(struct work_struct *work)
+bool nvme_mpath_has_disk(struct nvme_ns_head *head)
{
- struct nvme_ns_head *head =
- container_of(work, struct nvme_ns_head, requeue_work);
- struct bio *bio, *next;
-
- spin_lock_irq(&head->requeue_lock);
- next = bio_list_get(&head->requeue_list);
- spin_unlock_irq(&head->requeue_lock);
-
- while ((bio = next) != NULL) {
- next = bio->bi_next;
- bio->bi_next = NULL;
-
- submit_bio_noacct(bio);
- }
-}
-
-static void nvme_remove_head(struct nvme_ns_head *head)
-{
- if (test_and_clear_bit(NVME_NSHEAD_DISK_LIVE, &head->flags)) {
- /*
- * requeue I/O after NVME_NSHEAD_DISK_LIVE has been cleared
- * to allow multipath to fail all I/O.
- */
- kblockd_schedule_work(&head->requeue_work);
-
- nvme_cdev_del(&head->cdev, &head->cdev_device);
- synchronize_srcu(&head->srcu);
- del_gendisk(head->disk);
- }
- nvme_put_ns_head(head);
+ return head->mpath_disk;
}

static void nvme_remove_head_work(struct work_struct *work)
{
- struct nvme_ns_head *head = container_of(to_delayed_work(work),
- struct nvme_ns_head, remove_work);
+ struct mpath_head *mpath_head = container_of(to_delayed_work(work),
+ struct mpath_head, remove_work);
+ struct nvme_ns_head *head = mpath_head->drvdata;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
bool remove = false;

mutex_lock(&head->subsys->lock);
@@ -789,24 +423,21 @@ static void nvme_remove_head_work(struct work_struct *work)
remove = true;
}
mutex_unlock(&head->subsys->lock);
- if (remove)
- nvme_remove_head(head);

+ if (remove) {
+ mpath_unregister_disk(mpath_disk);
+ nvme_put_ns_head(head);
+ }
module_put(THIS_MODULE);
}

int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head)
{
+ struct mpath_disk *mpath_disk;
+ struct mpath_head *mpath_head;
+ struct nvme_subsystem *subsys = ctrl->subsys;
struct queue_limits lim;

- mutex_init(&head->lock);
- bio_list_init(&head->requeue_list);
- spin_lock_init(&head->requeue_lock);
- INIT_WORK(&head->requeue_work, nvme_requeue_work);
- INIT_WORK(&head->partition_scan_work, nvme_partition_scan_work);
- INIT_DELAYED_WORK(&head->remove_work, nvme_remove_head_work);
- head->delayed_removal_secs = 0;
-
/*
* If "multipath_always_on" is enabled, a multipath node is added
* regardless of whether the disk is single/multi ported, and whether
@@ -832,66 +463,29 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head)
if (head->ids.csi == NVME_CSI_ZNS)
lim.features |= BLK_FEAT_ZONED;

- head->disk = blk_alloc_disk(&lim, ctrl->numa_node);
- if (IS_ERR(head->disk))
- return PTR_ERR(head->disk);
- head->disk->fops = &nvme_ns_head_ops;
- head->disk->private_data = head;
-
- /*
- * We need to suppress the partition scan from occuring within the
- * controller's scan_work context. If a path error occurs here, the IO
- * will wait until a path becomes available or all paths are torn down,
- * but that action also occurs within scan_work, so it would deadlock.
- * Defer the partition scan to a different context that does not block
- * scan_work.
- */
- set_bit(GD_SUPPRESS_PART_SCAN, &head->disk->state);
- sprintf(head->disk->disk_name, "nvme%dn%d",
- ctrl->subsys->instance, head->instance);
- nvme_tryget_ns_head(head);
- return 0;
-}
-
-static void nvme_mpath_set_live(struct nvme_ns *ns)
-{
- struct nvme_ns_head *head = ns->head;
- int rc;
-
- if (!head->disk)
- return;
+ mpath_disk = mpath_alloc_head_disk(&lim, ctrl->numa_node);
+ if (!mpath_disk)
+ return -ENOMEM;

- /*
- * test_and_set_bit() is used because it is protecting against two nvme
- * paths simultaneously calling device_add_disk() on the same namespace
- * head.
- */
- if (!test_and_set_bit(NVME_NSHEAD_DISK_LIVE, &head->flags)) {
- rc = device_add_disk(&head->subsys->dev, head->disk,
- nvme_ns_attr_groups);
- if (rc) {
- clear_bit(NVME_NSHEAD_DISK_LIVE, &head->flags);
- return;
- }
- nvme_add_ns_head_cdev(head);
- queue_work(nvme_wq, &head->partition_scan_work);
+ mpath_head = mpath_alloc_head();
+ if (IS_ERR(mpath_head)) {
+ mpath_put_disk(mpath_disk);
+ return PTR_ERR(mpath_head);
}

- nvme_mpath_add_sysfs_link(ns->head);
+ mpath_head->drvdata = head;

- mutex_lock(&head->lock);
- if (nvme_path_is_optimized(ns)) {
- int node, srcu_idx;
+ head->mpath_disk = mpath_disk;
+ mpath_disk->mpath_head = mpath_head;
+ mpath_disk->parent = &subsys->dev;

- srcu_idx = srcu_read_lock(&head->srcu);
- for_each_online_node(node)
- __nvme_find_path(head, node);
- srcu_read_unlock(&head->srcu, srcu_idx);
- }
- mutex_unlock(&head->lock);
+ mpath_head->mpdt = &mpdt;
+ INIT_DELAYED_WORK(&mpath_head->remove_work, nvme_remove_head_work);

- synchronize_srcu(&head->srcu);
- kblockd_schedule_work(&head->requeue_work);
+ sprintf(mpath_disk->disk->disk_name, "nvme%dn%d",
+ ctrl->subsys->instance, head->instance);
+ nvme_tryget_ns_head(head);
+ return 0;
}

static int nvme_parse_ana_log(struct nvme_ctrl *ctrl, void *data,
@@ -946,9 +540,13 @@ static inline bool nvme_state_is_live(enum nvme_ana_state state)
static void nvme_update_ns_ana_state(struct nvme_ana_group_desc *desc,
struct nvme_ns *ns)
{
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;
ns->ana_grpid = le32_to_cpu(desc->grpid);
ns->ana_state = desc->state;
clear_bit(NVME_NS_ANA_PENDING, &ns->flags);
+
/*
* nvme_mpath_set_live() will trigger I/O to the multipath path device
* and in turn to this path device. However we cannot accept this I/O
@@ -960,7 +558,7 @@ static void nvme_update_ns_ana_state(struct nvme_ana_group_desc *desc,
*/
if (nvme_state_is_live(ns->ana_state) &&
nvme_ctrl_state(ns->ctrl) == NVME_CTRL_LIVE)
- nvme_mpath_set_live(ns);
+ mpath_device_set_live(mpath_disk, &ns->mpath_device);
else {
/*
* Add sysfs link from multipath head gendisk node to path
@@ -977,8 +575,8 @@ static void nvme_update_ns_ana_state(struct nvme_ana_group_desc *desc,
* is not live but still create the sysfs link to this path from
* head node if head node of the path has already come alive.
*/
- if (test_bit(NVME_NSHEAD_DISK_LIVE, &ns->head->flags))
- nvme_mpath_add_sysfs_link(ns->head);
+ if (test_bit(MPATH_HEAD_DISK_LIVE, &mpath_head->flags))
+ mpath_add_sysfs_link(mpath_disk);
}
}

@@ -1018,6 +616,17 @@ void nvme_mpath_delete_ns(struct nvme_ns *ns)
mpath_delete_device(mpath_disk->mpath_head, &ns->mpath_device);
}

+void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns)
+{
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+
+ if (!mpath_disk)
+ return;
+
+ mpath_remove_sysfs_link(mpath_disk, &ns->mpath_device);
+}
+
static int nvme_update_ana_state(struct nvme_ctrl *ctrl,
struct nvme_ana_group_desc *desc, void *data)
{
@@ -1140,32 +749,23 @@ static ssize_t nvme_subsys_iopolicy_show(struct device *dev,
{
struct nvme_subsystem *subsys =
container_of(dev, struct nvme_subsystem, dev);
+ return mpath_iopolicy_show(&subsys->iopolicy, buf);

- return sysfs_emit(buf, "%s\n",
- nvme_iopolicy_names[READ_ONCE(subsys->iopolicy)]);
}

-static void nvme_subsys_iopolicy_update(struct nvme_subsystem *subsys,
- int iopolicy)
+static void nvme_subsys_iopolicy_store_update(void *data)
{
+ struct nvme_subsystem *subsys = data;
struct nvme_ctrl *ctrl;
- int old_iopolicy = READ_ONCE(subsys->iopolicy);

- if (old_iopolicy == iopolicy)
- return;
-
- WRITE_ONCE(subsys->iopolicy, iopolicy);
-
- /* iopolicy changes clear the mpath by design */
mutex_lock(&nvme_subsystems_lock);
- list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry)
+ pr_err("%s subsys=%pS\n", __func__, subsys);
+ list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+ pr_err("%s2 subsys=%pS ctrl=%pS calling nvme_mpath_clear_ctrl_paths\n",
+ __func__, subsys, ctrl);
nvme_mpath_clear_ctrl_paths(ctrl);
+ }
mutex_unlock(&nvme_subsystems_lock);
-
- pr_notice("subsysnqn %s iopolicy changed from %s to %s\n",
- subsys->subnqn,
- nvme_iopolicy_names[old_iopolicy],
- nvme_iopolicy_names[iopolicy]);
}

static ssize_t nvme_subsys_iopolicy_store(struct device *dev,
@@ -1173,16 +773,9 @@ static ssize_t nvme_subsys_iopolicy_store(struct device *dev,
{
struct nvme_subsystem *subsys =
container_of(dev, struct nvme_subsystem, dev);
- int i;

- for (i = 0; i < ARRAY_SIZE(nvme_iopolicy_names); i++) {
- if (sysfs_streq(buf, nvme_iopolicy_names[i])) {
- nvme_subsys_iopolicy_update(subsys, i);
- return count;
- }
- }
-
- return -EINVAL;
+ return mpath_iopolicy_store(&subsys->iopolicy, buf, count,
+ nvme_subsys_iopolicy_store_update, subsys);
}
SUBSYS_ATTR_RW(iopolicy, S_IRUGO | S_IWUSR,
nvme_subsys_iopolicy_show, nvme_subsys_iopolicy_store);
@@ -1207,8 +800,9 @@ static ssize_t queue_depth_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
+ struct nvme_subsystem *subsys = ns->head->subsys;

- if (ns->head->subsys->iopolicy != NVME_IOPOLICY_QD)
+ if (!mpath_qd_iopolicy(&subsys->iopolicy))
return 0;

return sysfs_emit(buf, "%d\n", atomic_read(&ns->ctrl->nr_active));
@@ -1218,69 +812,33 @@ DEVICE_ATTR_RO(queue_depth);
static ssize_t numa_nodes_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
- int node, srcu_idx;
- nodemask_t numa_nodes;
- struct nvme_ns *current_ns;
struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;
+ struct nvme_subsystem *subsys = ns->head->subsys;
+ struct mpath_device *mpath_device = &ns->mpath_device;

- if (head->subsys->iopolicy != NVME_IOPOLICY_NUMA)
- return 0;
-
- nodes_clear(numa_nodes);
-
- srcu_idx = srcu_read_lock(&head->srcu);
- for_each_node(node) {
- current_ns = srcu_dereference(head->current_path[node],
- &head->srcu);
- if (ns == current_ns)
- node_set(node, numa_nodes);
- }
- srcu_read_unlock(&head->srcu, srcu_idx);
-
- return sysfs_emit(buf, "%*pbl\n", nodemask_pr_args(&numa_nodes));
+ return mpath_numa_nodes_show(mpath_head, mpath_device, &subsys->iopolicy, buf);
}
DEVICE_ATTR_RO(numa_nodes);

-static ssize_t delayed_removal_secs_show(struct device *dev,
+static ssize_t delayed_removal_secs_show(struct device *bd_device,
struct device_attribute *attr, char *buf)
{
- struct gendisk *disk = dev_to_disk(dev);
- struct nvme_ns_head *head = disk->private_data;
- int ret;
+ struct mpath_disk *mpath_disk = mpath_bd_device_to_disk(bd_device);
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;

- mutex_lock(&head->subsys->lock);
- ret = sysfs_emit(buf, "%u\n", head->delayed_removal_secs);
- mutex_unlock(&head->subsys->lock);
- return ret;
+ return mpath_delayed_removal_secs_show(mpath_head, buf);
}

-static ssize_t delayed_removal_secs_store(struct device *dev,
+static ssize_t delayed_removal_secs_store(struct device *bd_device,
struct device_attribute *attr, const char *buf, size_t count)
{
- struct gendisk *disk = dev_to_disk(dev);
- struct nvme_ns_head *head = disk->private_data;
- unsigned int sec;
- int ret;
-
- ret = kstrtouint(buf, 0, &sec);
- if (ret < 0)
- return ret;
-
- mutex_lock(&head->subsys->lock);
- head->delayed_removal_secs = sec;
- if (sec)
- set_bit(NVME_NSHEAD_QUEUE_IF_NO_PATH, &head->flags);
- else
- clear_bit(NVME_NSHEAD_QUEUE_IF_NO_PATH, &head->flags);
- mutex_unlock(&head->subsys->lock);
- /*
- * Ensure that update to NVME_NSHEAD_QUEUE_IF_NO_PATH is seen
- * by its reader.
- */
- synchronize_srcu(&head->srcu);
+ struct mpath_disk *mpath_disk = mpath_bd_device_to_disk(bd_device);
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;

- return count;
+ return mpath_delayed_removal_secs_store(mpath_head, buf, count);
}

DEVICE_ATTR_RW(delayed_removal_secs);
@@ -1297,87 +855,14 @@ static int nvme_lookup_ana_group_desc(struct nvme_ctrl *ctrl,
return -ENXIO; /* just break out of the loop */
}

-void nvme_mpath_add_sysfs_link(struct nvme_ns_head *head)
-{
- struct device *target;
- int rc, srcu_idx;
- struct nvme_ns *ns;
- struct kobject *kobj;
-
- /*
- * Ensure head disk node is already added otherwise we may get invalid
- * kobj for head disk node
- */
- if (!test_bit(GD_ADDED, &head->disk->state))
- return;
-
- kobj = &disk_to_dev(head->disk)->kobj;
-
- /*
- * loop through each ns chained through the head->list and create the
- * sysfs link from head node to the ns path node
- */
- srcu_idx = srcu_read_lock(&head->srcu);
-
- list_for_each_entry_srcu(ns, &head->list, siblings,
- srcu_read_lock_held(&head->srcu)) {
- /*
- * Ensure that ns path disk node is already added otherwise we
- * may get invalid kobj name for target
- */
- if (!test_bit(GD_ADDED, &ns->disk->state))
- continue;
-
- /*
- * Avoid creating link if it already exists for the given path.
- * When path ana state transitions from optimized to non-
- * optimized or vice-versa, the nvme_mpath_set_live() is
- * invoked which in truns call this function. Now if the sysfs
- * link already exists for the given path and we attempt to re-
- * create the link then sysfs code would warn about it loudly.
- * So we evaluate NVME_NS_SYSFS_ATTR_LINK flag here to ensure
- * that we're not creating duplicate link.
- * The test_and_set_bit() is used because it is protecting
- * against multiple nvme paths being simultaneously added.
- */
- if (test_and_set_bit(NVME_NS_SYSFS_ATTR_LINK, &ns->flags))
- continue;
-
- target = disk_to_dev(ns->disk);
- /*
- * Create sysfs link from head gendisk kobject @kobj to the
- * ns path gendisk kobject @target->kobj.
- */
- rc = sysfs_add_link_to_group(kobj, nvme_ns_mpath_attr_group.name,
- &target->kobj, dev_name(target));
- if (unlikely(rc)) {
- dev_err(disk_to_dev(ns->head->disk),
- "failed to create link to %s\n",
- dev_name(target));
- clear_bit(NVME_NS_SYSFS_ATTR_LINK, &ns->flags);
- }
- }
-
- srcu_read_unlock(&head->srcu, srcu_idx);
-}
-
-void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns)
+void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid)
{
- struct device *target;
- struct kobject *kobj;
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;

- if (!test_bit(NVME_NS_SYSFS_ATTR_LINK, &ns->flags))
+ if (!mpath_disk)
return;

- target = disk_to_dev(ns->disk);
- kobj = &disk_to_dev(ns->head->disk)->kobj;
- sysfs_remove_link_from_group(kobj, nvme_ns_mpath_attr_group.name,
- dev_name(target));
- clear_bit(NVME_NS_SYSFS_ATTR_LINK, &ns->flags);
-}
-
-void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid)
-{
if (nvme_ctrl_use_ana(ns->ctrl)) {
struct nvme_ana_group_desc desc = {
.grpid = anagrpid,
@@ -1398,23 +883,28 @@ void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid)
}
} else {
ns->ana_state = NVME_ANA_OPTIMIZED;
- nvme_mpath_set_live(ns);
+ mpath_device_set_live(mpath_disk, &ns->mpath_device);
}

#ifdef CONFIG_BLK_DEV_ZONED
- if (blk_queue_is_zoned(ns->queue) && ns->head->disk)
- ns->head->disk->nr_zones = ns->disk->nr_zones;
+ if (blk_queue_is_zoned(ns->queue) && mpath_disk->disk)
+ mpath_disk->disk->nr_zones = ns->disk->nr_zones;
#endif
}

void nvme_mpath_remove_disk(struct nvme_ns_head *head)
{
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct mpath_head *mpath_head;
bool remove = false;

- if (!head->disk)
+ if (!mpath_disk)
return;

+ mpath_head = mpath_disk->mpath_head;
+
mutex_lock(&head->subsys->lock);
+
/*
* We are called when all paths have been removed, and at that point
* head->list is expected to be empty. However, nvme_ns_remove() and
@@ -1424,37 +914,21 @@ void nvme_mpath_remove_disk(struct nvme_ns_head *head)
* head->list here. If it is no longer empty then we skip enqueuing the
* delayed head removal work.
*/
+
if (head->ns_count)
goto out;

- if (head->delayed_removal_secs) {
- /*
- * Ensure that no one could remove this module while the head
- * remove work is pending.
- */
- if (!try_module_get(THIS_MODULE))
- goto out;
- mod_delayed_work(nvme_wq, &head->remove_work,
- head->delayed_removal_secs * HZ);
- } else {
+ if (mpath_can_remove_head(mpath_head)) {
list_del_init(&head->entry);
remove = true;
}
out:
mutex_unlock(&head->subsys->lock);
- if (remove)
- nvme_remove_head(head);
-}

-void nvme_mpath_put_disk(struct nvme_ns_head *head)
-{
- if (!head->disk)
- return;
- /* make sure all pending bios are cleaned up */
- kblockd_schedule_work(&head->requeue_work);
- flush_work(&head->requeue_work);
- flush_work(&head->partition_scan_work);
- put_disk(head->disk);
+ if (remove) {
+ mpath_unregister_disk(mpath_disk);
+ nvme_put_ns_head(head);
+ }
}

void nvme_mpath_init_ctrl(struct nvme_ctrl *ctrl)
@@ -1525,15 +999,16 @@ void nvme_mpath_uninit(struct nvme_ctrl *ctrl)
ctrl->ana_log_size = 0;
}

-static enum mpath_iopolicy_e nvme_mpath_get_iopolicy(
- struct mpath_head *mpath_head)
+
+static enum mpath_iopolicy_e nvme_mpath_get_iopolicy(struct mpath_head *mpath_head)
{
struct nvme_ns_head *head = mpath_head->drvdata;
struct nvme_subsystem *subsys = head->subsys;

- return mpath_read_iopolicy(&subsys->mpath_iopolicy);
+ return mpath_read_iopolicy(&subsys->iopolicy);
}

+
static enum mpath_access_state nvme_mpath_get_access_state(
struct mpath_device *mpath_device)
{
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index e276a7bcb7aff..d83495dead590 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -253,11 +253,6 @@ struct nvme_request {
struct nvme_ctrl *ctrl;
};

-/*
- * Mark a bio as coming in through the mpath node.
- */
-#define REQ_NVME_MPATH REQ_DRV
-
enum {
NVME_REQ_CANCELLED = (1 << 0),
NVME_REQ_USERCMD = (1 << 1),
@@ -475,11 +470,6 @@ static inline enum nvme_ctrl_state nvme_ctrl_state(struct nvme_ctrl *ctrl)
return READ_ONCE(ctrl->state);
}

-enum nvme_iopolicy {
- NVME_IOPOLICY_NUMA,
- NVME_IOPOLICY_RR,
- NVME_IOPOLICY_QD,
-};

struct nvme_subsystem {
int instance;
@@ -502,8 +492,7 @@ struct nvme_subsystem {
u16 vendor_id;
struct ida ns_ida;
#ifdef CONFIG_NVME_MULTIPATH
- enum nvme_iopolicy iopolicy;
- struct mpath_iopolicy mpath_iopolicy;
+ struct mpath_iopolicy iopolicy;
#endif
};

@@ -525,8 +514,6 @@ struct nvme_ns_ids {
* only ever has a single entry for private namespaces.
*/
struct nvme_ns_head {
- struct list_head list;
- struct srcu_struct srcu;
struct nvme_subsystem *subsys;
struct nvme_ns_ids ids;
u8 lba_shift;
@@ -551,33 +538,15 @@ struct nvme_ns_head {

struct ratelimit_state rs_nuse;

- struct cdev cdev;
- struct device cdev_device;
-
- struct gendisk *disk;
-
u16 nr_plids;
u16 *plids;

struct mpath_disk *mpath_disk;
-#ifdef CONFIG_NVME_MULTIPATH
- struct bio_list requeue_list;
- spinlock_t requeue_lock;
- struct work_struct requeue_work;
- struct work_struct partition_scan_work;
- struct mutex lock;
- unsigned long flags;
- struct delayed_work remove_work;
- unsigned int delayed_removal_secs;
-#define NVME_NSHEAD_DISK_LIVE 0
-#define NVME_NSHEAD_QUEUE_IF_NO_PATH 1
- struct nvme_ns __rcu *current_path[];
-#endif
};

static inline bool nvme_ns_head_multipath(struct nvme_ns_head *head)
{
- return IS_ENABLED(CONFIG_NVME_MULTIPATH) && head->disk;
+ return IS_ENABLED(CONFIG_NVME_MULTIPATH) && head->mpath_disk;
}

enum nvme_ns_features {
@@ -1011,9 +980,7 @@ int nvme_getgeo(struct gendisk *disk, struct hd_geometry *geo);
int nvme_dev_uring_cmd(struct io_uring_cmd *ioucmd, unsigned int issue_flags);

extern const struct attribute_group *nvme_ns_attr_groups[];
-extern const struct attribute_group nvme_ns_mpath_attr_group;
extern const struct pr_ops nvme_pr_ops;
-extern const struct block_device_operations nvme_ns_head_ops;
extern const struct attribute_group nvme_dev_attrs_group;
extern const struct attribute_group *nvme_subsys_attrs_groups[];
extern const struct attribute_group *nvme_dev_attr_groups[];
@@ -1030,6 +997,7 @@ static inline bool nvme_ctrl_use_ana(struct nvme_ctrl *ctrl)
void nvme_mpath_synchronize(struct nvme_ns_head *head);
void nvme_mpath_add_ns(struct nvme_ns *ns);
void nvme_mpath_delete_ns(struct nvme_ns *ns);
+void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns);
void nvme_mpath_unfreeze(struct nvme_subsystem *subsys);
void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys);
void nvme_mpath_start_freeze(struct nvme_subsystem *subsys);
@@ -1037,8 +1005,7 @@ void nvme_mpath_default_iopolicy(struct nvme_subsystem *subsys);
void nvme_failover_req(struct request *req);
void nvme_kick_requeue_lists(struct nvme_ctrl *ctrl);
int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl,struct nvme_ns_head *head);
-void nvme_mpath_add_sysfs_link(struct nvme_ns_head *ns);
-void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns);
+bool nvme_mpath_has_disk(struct nvme_ns_head *head);
void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid);
void nvme_mpath_put_disk(struct nvme_ns_head *head);
int nvme_mpath_init_identify(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id);
@@ -1064,15 +1031,19 @@ int nvme_mpath_chr_uring_cmd(struct mpath_device *mpath_device,

static inline bool nvme_is_mpath_request(struct request *req)
{
- return req->cmd_flags & REQ_NVME_MPATH;
+ return is_mpath_request(req);
}

static inline void nvme_trace_bio_complete(struct request *req)
{
struct nvme_ns *ns = req->q->queuedata;

- if (nvme_is_mpath_request(req) && req->bio)
- trace_block_bio_complete(ns->head->disk->queue, req->bio);
+ if (nvme_is_mpath_request(req) && req->bio) {
+ struct nvme_ns_head *head = ns->head;
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+
+ trace_block_bio_complete(mpath_disk->disk->queue, req->bio);
+ }
}

extern bool multipath;
@@ -1085,13 +1056,7 @@ extern struct device_attribute subsys_attr_iopolicy;

static inline bool nvme_disk_is_ns_head(struct gendisk *disk)
{
- return disk->fops == &nvme_ns_head_ops;
-}
-static inline bool nvme_mpath_queue_if_no_path(struct nvme_ns_head *head)
-{
- if (test_bit(NVME_NSHEAD_QUEUE_IF_NO_PATH, &head->flags))
- return true;
- return false;
+ return is_mpath_head(disk);
}
#else
#define multipath false
@@ -1108,6 +1073,9 @@ static inline void nvme_mpath_add_ns(struct nvme_ns *ns)
static inline void nvme_mpath_delete_ns(struct nvme_ns *ns)
{
}
+static inline void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns)
+{
+}
static inline void nvme_failover_req(struct request *req)
{
}
@@ -1119,16 +1087,14 @@ static inline int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl,
{
return 0;
}
-static inline void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid)
-{
-}
-static inline void nvme_mpath_put_disk(struct nvme_ns_head *head)
+static inline bool nvme_mpath_has_disk(struct nvme_ns_head *head)
{
+ return false;
}
-static inline void nvme_mpath_add_sysfs_link(struct nvme_ns *ns)
+static inline void nvme_mpath_add_disk(struct nvme_ns *ns, __le32 anagrpid)
{
}
-static inline void nvme_mpath_remove_sysfs_link(struct nvme_ns *ns)
+static inline void nvme_mpath_put_disk(struct nvme_ns_head *head)
{
}
static inline bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
diff --git a/drivers/nvme/host/pr.c b/drivers/nvme/host/pr.c
index fd5a9f309a56f..b1002c3d43eb3 100644
--- a/drivers/nvme/host/pr.c
+++ b/drivers/nvme/host/pr.c
@@ -49,24 +49,9 @@ static enum pr_type block_pr_type_from_nvme(enum nvme_pr_type type)
return 0;
}

-static int nvme_send_ns_head_pr_command(struct block_device *bdev,
- struct nvme_command *c, void *data, unsigned int data_len)
-{
- struct nvme_ns_head *head = bdev->bd_disk->private_data;
- int srcu_idx = srcu_read_lock(&head->srcu);
- struct nvme_ns *ns = nvme_find_path(head);
- int ret = -EWOULDBLOCK;
-
- if (ns) {
- c->common.nsid = cpu_to_le32(ns->head->ns_id);
- ret = nvme_submit_sync_cmd(ns->queue, c, data, data_len);
- }
- srcu_read_unlock(&head->srcu, srcu_idx);
- return ret;
-}
-
-static int nvme_send_ns_pr_command(struct nvme_ns *ns, struct nvme_command *c,
- void *data, unsigned int data_len)
+static int nvme_send_device_pr_command(struct nvme_ns *ns,
+ struct nvme_command *c, void *data,
+ unsigned int data_len)
{
c->common.nsid = cpu_to_le32(ns->head->ns_id);
return nvme_submit_sync_cmd(ns->queue, c, data, data_len);
@@ -92,31 +77,7 @@ static int nvme_status_to_pr_err(int status)
}
}

-static int __nvme_send_pr_command(struct block_device *bdev, u32 cdw10,
- u32 cdw11, u8 op, void *data, unsigned int data_len)
-{
- struct nvme_command c = { 0 };
-
- c.common.opcode = op;
- c.common.cdw10 = cpu_to_le32(cdw10);
- c.common.cdw11 = cpu_to_le32(cdw11);
-
- if (nvme_disk_is_ns_head(bdev->bd_disk))
- return nvme_send_ns_head_pr_command(bdev, &c, data, data_len);
- return nvme_send_ns_pr_command(bdev->bd_disk->private_data, &c,
- data, data_len);
-}
-
-static int nvme_send_pr_command(struct block_device *bdev, u32 cdw10, u32 cdw11,
- u8 op, void *data, unsigned int data_len)
-{
- int ret;
-
- ret = __nvme_send_pr_command(bdev, cdw10, cdw11, op, data, data_len);
- return ret < 0 ? ret : nvme_status_to_pr_err(ret);
-}
-
-static int __nvme_send_pr_command_ns(struct nvme_ns *ns, u32 cdw10,
+static int __nvme_send_pr_command(struct nvme_ns *ns, u32 cdw10,
u32 cdw11, u8 op, void *data, unsigned int data_len)
{
struct nvme_command c = { 0 };
@@ -125,19 +86,18 @@ static int __nvme_send_pr_command_ns(struct nvme_ns *ns, u32 cdw10,
c.common.cdw10 = cpu_to_le32(cdw10);
c.common.cdw11 = cpu_to_le32(cdw11);

- return nvme_send_ns_pr_command(ns, &c, data, data_len);
+ return nvme_send_device_pr_command(ns, &c, data, data_len);
}

-static int nvme_send_pr_command_ns(struct nvme_ns *ns, u32 cdw10, u32 cdw11,
+static int nvme_send_pr_command(struct nvme_ns *ns, u32 cdw10, u32 cdw11,
u8 op, void *data, unsigned int data_len)
{
int ret;

- ret = __nvme_send_pr_command_ns(ns, cdw10, cdw11, op, data, data_len);
+ ret = __nvme_send_pr_command(ns, cdw10, cdw11, op, data, data_len);
return ret < 0 ? ret : nvme_status_to_pr_err(ret);
}

-__maybe_unused
static int nvme_pr_register_ns(struct nvme_ns *ns, u64 old_key, u64 new_key,
u32 flags)
{
@@ -156,33 +116,11 @@ static int nvme_pr_register_ns(struct nvme_ns *ns, u64 old_key, u64 new_key,
cdw10 |= (flags & PR_FL_IGNORE_KEY) ? NVME_PR_IGNORE_KEY : 0;
cdw10 |= NVME_PR_CPTPL_PERSIST;

- ret = nvme_send_pr_command_ns(ns, cdw10, 0, nvme_cmd_resv_register,
+ ret = nvme_send_pr_command(ns, cdw10, 0, nvme_cmd_resv_register,
&data, sizeof(data));
return ret;
}

-static int nvme_pr_register(struct block_device *bdev, u64 old_key, u64 new_key,
- unsigned int flags)
-{
- struct nvmet_pr_register_data data = { 0 };
- u32 cdw10;
-
- if (flags & ~PR_FL_IGNORE_KEY)
- return -EOPNOTSUPP;
-
- data.crkey = cpu_to_le64(old_key);
- data.nrkey = cpu_to_le64(new_key);
-
- cdw10 = old_key ? NVME_PR_REGISTER_ACT_REPLACE :
- NVME_PR_REGISTER_ACT_REG;
- cdw10 |= (flags & PR_FL_IGNORE_KEY) ? NVME_PR_IGNORE_KEY : 0;
- cdw10 |= NVME_PR_CPTPL_PERSIST;
-
- return nvme_send_pr_command(bdev, cdw10, 0, nvme_cmd_resv_register,
- &data, sizeof(data));
-}
-
-__maybe_unused
static int nvme_pr_reserve_ns(struct nvme_ns *ns, u64 key, enum pr_type type,
u32 flags)
{
@@ -198,30 +136,10 @@ static int nvme_pr_reserve_ns(struct nvme_ns *ns, u64 key, enum pr_type type,
cdw10 |= nvme_pr_type_from_blk(type) << 8;
cdw10 |= (flags & PR_FL_IGNORE_KEY) ? NVME_PR_IGNORE_KEY : 0;

- return nvme_send_pr_command_ns(ns, cdw10, 0, nvme_cmd_resv_acquire,
+ return nvme_send_pr_command(ns, cdw10, 0, nvme_cmd_resv_acquire,
&data, sizeof(data));
}

-static int nvme_pr_reserve(struct block_device *bdev, u64 key,
- enum pr_type type, unsigned flags)
-{
- struct nvmet_pr_acquire_data data = { 0 };
- u32 cdw10;
-
- if (flags & ~PR_FL_IGNORE_KEY)
- return -EOPNOTSUPP;
-
- data.crkey = cpu_to_le64(key);
-
- cdw10 = NVME_PR_ACQUIRE_ACT_ACQUIRE;
- cdw10 |= nvme_pr_type_from_blk(type) << 8;
- cdw10 |= (flags & PR_FL_IGNORE_KEY) ? NVME_PR_IGNORE_KEY : 0;
-
- return nvme_send_pr_command(bdev, cdw10, 0, nvme_cmd_resv_acquire,
- &data, sizeof(data));
-}
-
-__maybe_unused
static int nvme_pr_preempt_ns(struct nvme_ns *ns, u64 old, u64 new,
enum pr_type type, bool abort)
{
@@ -235,28 +153,10 @@ static int nvme_pr_preempt_ns(struct nvme_ns *ns, u64 old, u64 new,
NVME_PR_ACQUIRE_ACT_PREEMPT;
cdw10 |= nvme_pr_type_from_blk(type) << 8;

- return nvme_send_pr_command_ns(ns, cdw10, 0, nvme_cmd_resv_acquire,
- &data, sizeof(data));
-}
-
-static int nvme_pr_preempt(struct block_device *bdev, u64 old, u64 new,
- enum pr_type type, bool abort)
-{
- struct nvmet_pr_acquire_data data = { 0 };
- u32 cdw10;
-
- data.crkey = cpu_to_le64(old);
- data.prkey = cpu_to_le64(new);
-
- cdw10 = abort ? NVME_PR_ACQUIRE_ACT_PREEMPT_AND_ABORT :
- NVME_PR_ACQUIRE_ACT_PREEMPT;
- cdw10 |= nvme_pr_type_from_blk(type) << 8;
-
- return nvme_send_pr_command(bdev, cdw10, 0, nvme_cmd_resv_acquire,
+ return nvme_send_pr_command(ns, cdw10, 0, nvme_cmd_resv_acquire,
&data, sizeof(data));
}

-__maybe_unused
static int nvme_pr_clear_ns(struct nvme_ns *ns, u64 key)
{
struct nvmet_pr_release_data data = { 0 };
@@ -267,40 +167,10 @@ static int nvme_pr_clear_ns(struct nvme_ns *ns, u64 key)
cdw10 = NVME_PR_RELEASE_ACT_CLEAR;
cdw10 |= key ? 0 : NVME_PR_IGNORE_KEY;

- return nvme_send_pr_command_ns(ns, cdw10, 0, nvme_cmd_resv_release,
- &data, sizeof(data));
-}
-
-static int nvme_pr_clear(struct block_device *bdev, u64 key)
-{
- struct nvmet_pr_release_data data = { 0 };
- u32 cdw10;
-
- data.crkey = cpu_to_le64(key);
-
- cdw10 = NVME_PR_RELEASE_ACT_CLEAR;
- cdw10 |= key ? 0 : NVME_PR_IGNORE_KEY;
-
- return nvme_send_pr_command(bdev, cdw10, 0, nvme_cmd_resv_release,
+ return nvme_send_pr_command(ns, cdw10, 0, nvme_cmd_resv_release,
&data, sizeof(data));
}

-static int nvme_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
-{
- struct nvmet_pr_release_data data = { 0 };
- u32 cdw10;
-
- data.crkey = cpu_to_le64(key);
-
- cdw10 = NVME_PR_RELEASE_ACT_RELEASE;
- cdw10 |= nvme_pr_type_from_blk(type) << 8;
- cdw10 |= key ? 0 : NVME_PR_IGNORE_KEY;
-
- return nvme_send_pr_command(bdev, cdw10, 0, nvme_cmd_resv_release,
- &data, sizeof(data));
-}
-
-__maybe_unused
static int nvme_pr_release_ns(struct nvme_ns *ns, u64 key, enum pr_type type)
{
struct nvmet_pr_release_data data = { 0 };
@@ -312,11 +182,11 @@ static int nvme_pr_release_ns(struct nvme_ns *ns, u64 key, enum pr_type type)
cdw10 |= nvme_pr_type_from_blk(type) << 8;
cdw10 |= key ? 0 : NVME_PR_IGNORE_KEY;

- return nvme_send_pr_command_ns(ns, cdw10, 0, nvme_cmd_resv_release,
+ return nvme_send_pr_command(ns, cdw10, 0, nvme_cmd_resv_release,
&data, sizeof(data));
}

-static int nvme_mpath_pr_resv_report_ns(struct nvme_ns *ns, void *data,
+static int nvme_mpath_pr_resv_report(struct nvme_ns *ns, void *data,
u32 data_len, bool *eds)
{
u32 cdw10, cdw11;
@@ -327,7 +197,7 @@ static int nvme_mpath_pr_resv_report_ns(struct nvme_ns *ns, void *data,
*eds = true;

retry:
- ret = __nvme_send_pr_command_ns(ns, cdw10, cdw11, nvme_cmd_resv_report,
+ ret = __nvme_send_pr_command(ns, cdw10, cdw11, nvme_cmd_resv_report,
data, data_len);
if (ret == NVME_SC_HOST_ID_INCONSIST &&
cdw11 == NVME_EXTENDED_DATA_STRUCT) {
@@ -339,30 +209,6 @@ static int nvme_mpath_pr_resv_report_ns(struct nvme_ns *ns, void *data,
return ret < 0 ? ret : nvme_status_to_pr_err(ret);
}

-static int nvme_pr_resv_report(struct block_device *bdev, void *data,
- u32 data_len, bool *eds)
-{
- u32 cdw10, cdw11;
- int ret;
-
- cdw10 = nvme_bytes_to_numd(data_len);
- cdw11 = NVME_EXTENDED_DATA_STRUCT;
- *eds = true;
-
-retry:
- ret = __nvme_send_pr_command(bdev, cdw10, cdw11, nvme_cmd_resv_report,
- data, data_len);
- if (ret == NVME_SC_HOST_ID_INCONSIST &&
- cdw11 == NVME_EXTENDED_DATA_STRUCT) {
- cdw11 = 0;
- *eds = false;
- goto retry;
- }
-
- return ret < 0 ? ret : nvme_status_to_pr_err(ret);
-}
-
-__maybe_unused
static int nvme_pr_read_keys_ns(struct nvme_ns *ns, struct pr_keys *keys_info)
{
size_t rse_len;
@@ -383,7 +229,7 @@ static int nvme_pr_read_keys_ns(struct nvme_ns *ns, struct pr_keys *keys_info)
if (!rse)
return -ENOMEM;

- ret = nvme_mpath_pr_resv_report_ns(ns, rse, rse_len, &eds);
+ ret = nvme_mpath_pr_resv_report(ns, rse, rse_len, &eds);
if (ret)
goto free_rse;

@@ -399,53 +245,8 @@ static int nvme_pr_read_keys_ns(struct nvme_ns *ns, struct pr_keys *keys_info)
struct nvme_reservation_status *rs;

rs = (struct nvme_reservation_status *)rse;
- keys_info->keys[i] = le64_to_cpu(rs->regctl_ds[i].rkey);
- }
- }
-
-free_rse:
- kfree(rse);
- return ret;
-}
-
-static int nvme_pr_read_keys(struct block_device *bdev,
- struct pr_keys *keys_info)
-{
- size_t rse_len;
- u32 num_keys = keys_info->num_keys;
- struct nvme_reservation_status_ext *rse;
- int ret, i;
- bool eds;
-
- /*
- * Assume we are using 128-bit host IDs and allocate a buffer large
- * enough to get enough keys to fill the return keys buffer.
- */
- rse_len = struct_size(rse, regctl_eds, num_keys);
- if (rse_len > U32_MAX)
- return -EINVAL;
-
- rse = kzalloc(rse_len, GFP_KERNEL);
- if (!rse)
- return -ENOMEM;
-
- ret = nvme_pr_resv_report(bdev, rse, rse_len, &eds);
- if (ret)
- goto free_rse;
-
- keys_info->generation = le32_to_cpu(rse->gen);
- keys_info->num_keys = get_unaligned_le16(&rse->regctl);
-
- num_keys = min(num_keys, keys_info->num_keys);
- for (i = 0; i < num_keys; i++) {
- if (eds) {
keys_info->keys[i] =
- le64_to_cpu(rse->regctl_eds[i].rkey);
- } else {
- struct nvme_reservation_status *rs;
-
- rs = (struct nvme_reservation_status *)rse;
- keys_info->keys[i] = le64_to_cpu(rs->regctl_ds[i].rkey);
+ le64_to_cpu(rs->regctl_ds[i].rkey);
}
}

@@ -454,7 +255,6 @@ static int nvme_pr_read_keys(struct block_device *bdev,
return ret;
}

-__maybe_unused
static int nvme_pr_read_reservation_ns(struct nvme_ns *ns,
struct pr_held_reservation *resv)
{
@@ -468,7 +268,7 @@ static int nvme_pr_read_reservation_ns(struct nvme_ns *ns,
* Get the number of registrations so we know how big to allocate
* the response buffer.
*/
- ret = nvme_mpath_pr_resv_report_ns(ns, &tmp_rse, sizeof(tmp_rse),
+ ret = nvme_mpath_pr_resv_report(ns, &tmp_rse, sizeof(tmp_rse),
&eds);
if (ret)
return ret;
@@ -484,7 +284,7 @@ static int nvme_pr_read_reservation_ns(struct nvme_ns *ns,
if (!rse)
return -ENOMEM;

- ret = nvme_mpath_pr_resv_report_ns(ns, rse, rse_len, &eds);
+ ret = nvme_mpath_pr_resv_report(ns, rse, rse_len, &eds);
if (ret)
goto free_rse;

@@ -499,7 +299,8 @@ static int nvme_pr_read_reservation_ns(struct nvme_ns *ns,
for (i = 0; i < num_regs; i++) {
if (eds) {
if (rse->regctl_eds[i].rcsts) {
- resv->key = le64_to_cpu(rse->regctl_eds[i].rkey);
+ resv->key =
+ le64_to_cpu(rse->regctl_eds[i].rkey);
break;
}
} else {
@@ -518,67 +319,6 @@ static int nvme_pr_read_reservation_ns(struct nvme_ns *ns,
return ret;
}

-static int nvme_pr_read_reservation(struct block_device *bdev,
- struct pr_held_reservation *resv)
-{
- struct nvme_reservation_status_ext tmp_rse, *rse;
- int ret, i, num_regs;
- u32 rse_len;
- bool eds;
-
-get_num_regs:
- /*
- * Get the number of registrations so we know how big to allocate
- * the response buffer.
- */
- ret = nvme_pr_resv_report(bdev, &tmp_rse, sizeof(tmp_rse), &eds);
- if (ret)
- return ret;
-
- num_regs = get_unaligned_le16(&tmp_rse.regctl);
- if (!num_regs) {
- resv->generation = le32_to_cpu(tmp_rse.gen);
- return 0;
- }
-
- rse_len = struct_size(rse, regctl_eds, num_regs);
- rse = kzalloc(rse_len, GFP_KERNEL);
- if (!rse)
- return -ENOMEM;
-
- ret = nvme_pr_resv_report(bdev, rse, rse_len, &eds);
- if (ret)
- goto free_rse;
-
- if (num_regs != get_unaligned_le16(&rse->regctl)) {
- kfree(rse);
- goto get_num_regs;
- }
-
- resv->generation = le32_to_cpu(rse->gen);
- resv->type = block_pr_type_from_nvme(rse->rtype);
-
- for (i = 0; i < num_regs; i++) {
- if (eds) {
- if (rse->regctl_eds[i].rcsts) {
- resv->key = le64_to_cpu(rse->regctl_eds[i].rkey);
- break;
- }
- } else {
- struct nvme_reservation_status *rs;
-
- rs = (struct nvme_reservation_status *)rse;
- if (rs->regctl_ds[i].rcsts) {
- resv->key = le64_to_cpu(rs->regctl_ds[i].rkey);
- break;
- }
- }
- }
-
-free_rse:
- kfree(rse);
- return ret;
-}

#if defined(CONFIG_NVME_MULTIPATH)
static int nvme_mpath_pr_register(struct mpath_device *mpath_device,
@@ -647,6 +387,61 @@ const struct mpath_pr_ops nvme_mpath_pr_ops = {
};
#endif

+static int nvme_pr_register(struct block_device *bdev, u64 old_key,
+ u64 new_key, unsigned int flags)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_register_ns(ns, old_key, new_key, flags);
+}
+
+static int nvme_pr_reserve(struct block_device *bdev, u64 key,
+ enum pr_type type, unsigned flags)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_reserve_ns(ns, key, type, flags);
+}
+
+static int nvme_pr_preempt(struct block_device *bdev, u64 old, u64 new,
+ enum pr_type type, bool abort)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_preempt_ns(ns, old, new, type, abort);
+}
+
+static int nvme_pr_clear(struct block_device *bdev, u64 key)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_clear_ns(ns, key);
+}
+
+static int nvme_pr_release(struct block_device *bdev, u64 key,
+ enum pr_type type)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_release_ns(ns, key, type);
+}
+
+static int nvme_pr_read_keys(struct block_device *bdev,
+ struct pr_keys *keys_info)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_read_keys_ns(ns, keys_info);
+}
+
+static int nvme_pr_read_reservation(struct block_device *bdev,
+ struct pr_held_reservation *resv)
+{
+ struct nvme_ns *ns = bdev->bd_disk->private_data;
+
+ return nvme_pr_read_reservation_ns(ns, resv);
+}
+
const struct pr_ops nvme_pr_ops = {
.pr_register = nvme_pr_register,
.pr_reserve = nvme_pr_reserve,
diff --git a/drivers/nvme/host/sysfs.c b/drivers/nvme/host/sysfs.c
index 16c6fea4b2db6..95f621c0a5b05 100644
--- a/drivers/nvme/host/sysfs.c
+++ b/drivers/nvme/host/sysfs.c
@@ -64,8 +64,11 @@ static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev)
{
struct gendisk *disk = dev_to_disk(dev);

- if (nvme_disk_is_ns_head(disk))
- return disk->private_data;
+ if (nvme_disk_is_ns_head(disk)) {
+ struct mpath_disk *mpath_disk = mpath_gendisk_to_disk(disk);
+
+ return mpath_disk->mpath_head->drvdata;
+ }
return nvme_get_ns_from_dev(dev)->head;
}

@@ -183,30 +186,36 @@ static ssize_t metadata_bytes_show(struct device *dev,
}
static DEVICE_ATTR_RO(metadata_bytes);

-static int ns_head_update_nuse(struct nvme_ns_head *head)
+static int ns_head_update_nuse_cb(struct mpath_device *mpath_device)
{
+ struct nvme_ns *ns = container_of(mpath_device, struct nvme_ns, mpath_device);
+ struct nvme_ns_head *head = ns->head;
struct nvme_id_ns *id;
- struct nvme_ns *ns;
- int srcu_idx, ret = -EWOULDBLOCK;
-
- /* Avoid issuing commands too often by rate limiting the update */
- if (!__ratelimit(&head->rs_nuse))
- return 0;
-
- srcu_idx = srcu_read_lock(&head->srcu);
- ns = nvme_find_path(head);
- if (!ns)
- goto out_unlock;
+ int ret;

ret = nvme_identify_ns(ns->ctrl, head->ns_id, &id);
if (ret)
- goto out_unlock;
+ return ret;

head->nuse = le64_to_cpu(id->nuse);
kfree(id);
+ return 0;
+}
+
+static int ns_head_update_nuse(struct nvme_ns_head *head)
+{
+ struct mpath_disk *mpath_disk = head->mpath_disk;
+ struct mpath_head *mpath_head = mpath_disk->mpath_head;
+ int ret;
+
+ /* Avoid issuing commands too often by rate limiting the update */
+ if (!__ratelimit(&head->rs_nuse))
+ return 0;
+
+ ret = mpath_call_for_device(mpath_head, ns_head_update_nuse_cb);
+ if (ret == -ENODEV)
+ return -EWOULDBLOCK;

-out_unlock:
- srcu_read_unlock(&head->srcu, srcu_idx);
return ret;
}

@@ -312,49 +321,10 @@ static const struct attribute_group nvme_ns_attr_group = {
.is_visible = nvme_ns_attrs_are_visible,
};

-#ifdef CONFIG_NVME_MULTIPATH
-/*
- * NOTE: The dummy attribute does not appear in sysfs. It exists solely to allow
- * control over the visibility of the multipath sysfs node. Without at least one
- * attribute defined in nvme_ns_mpath_attrs[], the sysfs implementation does not
- * invoke the multipath_sysfs_group_visible() method. As a result, we would not
- * be able to control the visibility of the multipath sysfs node.
- */
-static struct attribute dummy_attr = {
- .name = "dummy",
-};
-
-static struct attribute *nvme_ns_mpath_attrs[] = {
- &dummy_attr,
- NULL,
-};
-
-static bool multipath_sysfs_group_visible(struct kobject *kobj)
-{
- struct device *dev = container_of(kobj, struct device, kobj);
-
- return nvme_disk_is_ns_head(dev_to_disk(dev));
-}
-
-static bool multipath_sysfs_attr_visible(struct kobject *kobj,
- struct attribute *attr, int n)
-{
- return false;
-}
-
-DEFINE_SYSFS_GROUP_VISIBLE(multipath_sysfs)
-
-const struct attribute_group nvme_ns_mpath_attr_group = {
- .name = "multipath",
- .attrs = nvme_ns_mpath_attrs,
- .is_visible = SYSFS_GROUP_VISIBLE(multipath_sysfs),
-};
-#endif
-
const struct attribute_group *nvme_ns_attr_groups[] = {
&nvme_ns_attr_group,
#ifdef CONFIG_NVME_MULTIPATH
- &nvme_ns_mpath_attr_group,
+ &mpath_attr_group,
#endif
NULL,
};
--
2.43.5