* [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 21:21 ` Keith Busch
2018-08-15 19:58 ` [PATCH V4 2/9] nvme-core: export existing ctrl and ns interfaces Chaitanya Kulkarni
` (7 subsequent siblings)
8 siblings, 1 reply; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
The new interface nvme_get_ctrl_by_path() allows to search the nvme ctrl
by its pathname. On success, it increments the refcount of the ctrl and
associated subsystem. The caller needs to decrement the ctrl and
subsystem refcount by calling nvme_put_ctrl_by_path() once the work is
done.
This is a preparation patch for implementing NVMe Over Fabric target
passthru feature.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/host/core.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++
drivers/nvme/host/nvme.h | 3 +++
2 files changed, 66 insertions(+)
diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index dd8ec1dd9219..efc24d441d79 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -99,6 +99,7 @@ static struct class *nvme_subsys_class;
static void nvme_ns_remove(struct nvme_ns *ns);
static int nvme_revalidate_disk(struct gendisk *disk);
+static int nvme_get_subsystem(struct nvme_subsystem *subsys);
static void nvme_put_subsystem(struct nvme_subsystem *subsys);
static void nvme_remove_invalid_namespaces(struct nvme_ctrl *ctrl,
unsigned nsid);
@@ -126,6 +127,61 @@ static void nvme_queue_scan(struct nvme_ctrl *ctrl)
queue_work(nvme_wq, &ctrl->scan_work);
}
+int nvme_get_ctrl_by_path(char *path, struct nvme_ctrl **ctrl)
+{
+ int ret = -ENODEV;
+ char *cdev = strrchr(path, '/');
+ struct nvme_ctrl *ictrl = NULL;
+ struct nvme_subsystem *isubsys = NULL;
+
+ if (!cdev) {
+ *ctrl = NULL;
+ return ret;
+ }
+ cdev++;
+
+ mutex_lock(&nvme_subsystems_lock);
+ list_for_each_entry(isubsys, &nvme_subsystems, entry) {
+ if (!nvme_get_subsystem(isubsys)) {
+ pr_info("failed to get the subsystem for ctrl %s\n",
+ path);
+ goto out;
+ }
+ mutex_unlock(&nvme_subsystems_lock);
+
+ list_for_each_entry(ictrl, &isubsys->ctrls, subsys_entry) {
+ spin_lock(&ictrl->lock);
+ nvme_get_ctrl(ictrl);
+ if (strcmp(cdev, kobject_name(&ictrl->device->kobj))
+ == 0) {
+ *ctrl = ictrl;
+ if (try_module_get(ictrl->ops->module)) {
+ spin_unlock(&ictrl->lock);
+ mutex_lock(&nvme_subsystems_lock);
+ ret = 0;
+ goto out;
+ }
+ }
+ nvme_put_ctrl(ictrl);
+ spin_unlock(&ictrl->lock);
+ }
+ mutex_lock(&nvme_subsystems_lock);
+ nvme_put_subsystem(isubsys);
+ }
+out:
+ mutex_unlock(&nvme_subsystems_lock);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(nvme_get_ctrl_by_path);
+
+void nvme_put_ctrl_by_path(struct nvme_ctrl *ctrl)
+{
+ nvme_put_ctrl(ctrl);
+ module_put(ctrl->ops->module);
+ nvme_put_subsystem(ctrl->subsys);
+}
+EXPORT_SYMBOL_GPL(nvme_put_ctrl_by_path);
+
int nvme_reset_ctrl(struct nvme_ctrl *ctrl)
{
if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING))
@@ -2119,6 +2175,13 @@ static void nvme_destroy_subsystem(struct kref *ref)
put_device(&subsys->dev);
}
+static int nvme_get_subsystem(struct nvme_subsystem *subsys)
+{
+ lockdep_assert_held(&nvme_subsystems_lock);
+
+ return kref_get_unless_zero(&subsys->ref);
+}
+
static void nvme_put_subsystem(struct nvme_subsystem *subsys)
{
kref_put(&subsys->ref, nvme_destroy_subsystem);
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index bb4a2003c097..495eafcb9e9d 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -547,6 +547,9 @@ static inline void nvme_mpath_stop(struct nvme_ctrl *ctrl)
}
#endif /* CONFIG_NVME_MULTIPATH */
+int nvme_get_ctrl_by_path(char *name, struct nvme_ctrl **ctrl);
+void nvme_put_ctrl_by_path(struct nvme_ctrl *ctrl);
+
#ifdef CONFIG_NVM
void nvme_nvm_update_nvm_info(struct nvme_ns *ns);
int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node);
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl
2018-08-15 19:58 ` [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl Chaitanya Kulkarni
@ 2018-08-15 21:21 ` Keith Busch
2018-08-15 21:28 ` Chaitanya Kulkarni
0 siblings, 1 reply; 12+ messages in thread
From: Keith Busch @ 2018-08-15 21:21 UTC (permalink / raw)
On Wed, Aug 15, 2018@03:58:46PM -0400, Chaitanya Kulkarni wrote:
> +int nvme_get_ctrl_by_path(char *path, struct nvme_ctrl **ctrl)
> +{
> + int ret = -ENODEV;
> + char *cdev = strrchr(path, '/');
> + struct nvme_ctrl *ictrl = NULL;
> + struct nvme_subsystem *isubsys = NULL;
> +
> + if (!cdev) {
> + *ctrl = NULL;
> + return ret;
> + }
> + cdev++;
> +
> + mutex_lock(&nvme_subsystems_lock);
> + list_for_each_entry(isubsys, &nvme_subsystems, entry) {
> + if (!nvme_get_subsystem(isubsys)) {
> + pr_info("failed to get the subsystem for ctrl %s\n",
> + path);
> + goto out;
> + }
> + mutex_unlock(&nvme_subsystems_lock);
> +
> + list_for_each_entry(ictrl, &isubsys->ctrls, subsys_entry) {
> + spin_lock(&ictrl->lock);
> + nvme_get_ctrl(ictrl);
> + if (strcmp(cdev, kobject_name(&ictrl->device->kobj))
> + == 0) {
> + *ctrl = ictrl;
> + if (try_module_get(ictrl->ops->module)) {
> + spin_unlock(&ictrl->lock);
> + mutex_lock(&nvme_subsystems_lock);
> + ret = 0;
> + goto out;
> + }
> + }
> + nvme_put_ctrl(ictrl);
> + spin_unlock(&ictrl->lock);
> + }
> + mutex_lock(&nvme_subsystems_lock);
> + nvme_put_subsystem(isubsys);
> + }
> +out:
> + mutex_unlock(&nvme_subsystems_lock);
> + return ret;
> +}
Some difficult to follow locking and reference counting here.
The 'nvme_get_subsystem' is a kref_get_unless_zero, so if the subsystem
happens to be at the final 'put' during this iteration, why bail out
instead of going to the next subsystem? Seems like a 'continue' is the
right thing to do there.
The end part of the loop is even more confusing. If the nvme_put_subsystem
happens to be the final 'put', it will deadlock because the
nvme_destroy_subsystem will want to take the same lock you're already
holding. It looks like getting rid of the reference counting on the
subsystem, and hold nvme_subsystems_lock for the entire loop gets the
desired result.
And while iterating the inner loop subsys_entry, it looks like you
need to hold isubsys->lock. And if you're holding that lock, you won't
need a reference on nvme_ctrl until you find the controller you're
searching for.
Finally I cant even tell why ictrl->lock is being taken. That will only
prevent a state transition, which doesn't seem to matter here.
^ permalink raw reply [flat|nested] 12+ messages in thread* [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl
2018-08-15 21:21 ` Keith Busch
@ 2018-08-15 21:28 ` Chaitanya Kulkarni
0 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 21:28 UTC (permalink / raw)
Thanks Keith for the comments, I'll simplify the code for next version.
From: Keith Busch <keith.busch@linux.intel.com>
Sent: Wednesday, August 15, 2018 2:21 PM
To: Chaitanya Kulkarni
Cc: linux-nvme at lists.infradead.org; keith.busch at intel.com; hch at lst.de; sagi at grimberg.me
Subject: Re: [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl
?
On Wed, Aug 15, 2018@03:58:46PM -0400, Chaitanya Kulkarni wrote:
> +int nvme_get_ctrl_by_path(char *path, struct nvme_ctrl **ctrl)
> +{
> +???? int ret = -ENODEV;
> +???? char *cdev = strrchr(path, '/');
> +???? struct nvme_ctrl *ictrl = NULL;
> +???? struct nvme_subsystem *isubsys = NULL;
> +
> +???? if (!cdev) {
> +???????????? *ctrl = NULL;
> +???????????? return ret;
> +???? }
> +???? cdev++;
> +
> +???? mutex_lock(&nvme_subsystems_lock);
> +???? list_for_each_entry(isubsys, &nvme_subsystems, entry) {
> +???????????? if (!nvme_get_subsystem(isubsys)) {
> +???????????????????? pr_info("failed to get the subsystem for ctrl %s\n",
> +???????????????????????????????????? path);
> +???????????????????? goto out;
> +???????????? }
> +???????????? mutex_unlock(&nvme_subsystems_lock);
> +
> +???????????? list_for_each_entry(ictrl, &isubsys->ctrls, subsys_entry) {
> +???????????????????? spin_lock(&ictrl->lock);
> +???????????????????? nvme_get_ctrl(ictrl);
> +???????????????????? if (strcmp(cdev, kobject_name(&ictrl->device->kobj))
> +???????????????????????????????????? == 0) {
> +???????????????????????????? *ctrl = ictrl;
> +???????????????????????????? if (try_module_get(ictrl->ops->module)) {
> +???????????????????????????????????? spin_unlock(&ictrl->lock);
> +???????????????????????????????????? mutex_lock(&nvme_subsystems_lock);
> +???????????????????????????????????? ret = 0;
> +???????????????????????????????????? goto out;
> +???????????????????????????? }
> +???????????????????? }
> +???????????????????? nvme_put_ctrl(ictrl);
> +???????????????????? spin_unlock(&ictrl->lock);
> +???????????? }
> +???????????? mutex_lock(&nvme_subsystems_lock);
> +???????????? nvme_put_subsystem(isubsys);
> +???? }
> +out:
> +???? mutex_unlock(&nvme_subsystems_lock);
> +???? return ret;
> +}
Some difficult to follow locking and reference counting here.
The 'nvme_get_subsystem' is a kref_get_unless_zero, so if the subsystem
happens to be at the final 'put' during this iteration, why bail out
instead of going to the next subsystem? Seems like a 'continue' is the
right thing to do there.
The end part of the loop is even more confusing. If the nvme_put_subsystem
happens to be the final 'put', it will deadlock because the
nvme_destroy_subsystem will want to take the same lock you're already
holding. It looks like getting rid of the reference counting on the
subsystem, and hold nvme_subsystems_lock for the entire loop gets the
desired result.
And while iterating the inner loop subsys_entry, it looks like you
need to hold isubsys->lock. And if you're holding that lock, you won't
need a reference on nvme_ctrl until you find the controller you're
searching for.
Finally I cant even tell why ictrl->lock is being taken. That will only
prevent a state transition, which doesn't seem to matter here.
^ permalink raw reply [flat|nested] 12+ messages in thread
* [PATCH V4 2/9] nvme-core: export existing ctrl and ns interfaces
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 3/9] nvmet: export nvmet_add_async_event api Chaitanya Kulkarni
` (6 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
We export existing nvme ctrl and ns management APIs so that
target passthru code can manage the nvme ctrl.
This is a preparation patch for implementing NVMe Over Fabric
target passthru feature.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/host/core.c | 18 +++++++++++-------
drivers/nvme/host/nvme.h | 8 ++++++++
2 files changed, 19 insertions(+), 7 deletions(-)
diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index efc24d441d79..efca1e0b7f8f 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -453,10 +453,11 @@ static void nvme_free_ns(struct kref *kref)
kfree(ns);
}
-static void nvme_put_ns(struct nvme_ns *ns)
+void nvme_put_ns(struct nvme_ns *ns)
{
kref_put(&ns->kref, nvme_free_ns);
}
+EXPORT_SYMBOL_GPL(nvme_put_ns);
static inline void nvme_clear_nvme_request(struct request *req)
{
@@ -1050,8 +1051,7 @@ static int nvme_identify_ns_list(struct nvme_ctrl *dev, unsigned nsid, __le32 *n
NVME_IDENTIFY_DATA_SIZE);
}
-static struct nvme_id_ns *nvme_identify_ns(struct nvme_ctrl *ctrl,
- unsigned nsid)
+struct nvme_id_ns *nvme_identify_ns(struct nvme_ctrl *ctrl, unsigned nsid)
{
struct nvme_id_ns *id;
struct nvme_command c = { };
@@ -1075,6 +1075,7 @@ static struct nvme_id_ns *nvme_identify_ns(struct nvme_ctrl *ctrl,
return id;
}
+EXPORT_SYMBOL_GPL(nvme_identify_ns);
static int nvme_set_features(struct nvme_ctrl *dev, unsigned fid, unsigned dword11,
void *buffer, size_t buflen, u32 *result)
@@ -1205,8 +1206,8 @@ static u32 nvme_known_admin_effects(u8 opcode)
return 0;
}
-static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
- u8 opcode)
+u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
+ u8 opcode)
{
u32 effects = 0;
@@ -1235,6 +1236,7 @@ static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
}
return effects;
}
+EXPORT_SYMBOL_GPL(nvme_passthru_start);
static void nvme_update_formats(struct nvme_ctrl *ctrl)
{
@@ -1249,7 +1251,7 @@ static void nvme_update_formats(struct nvme_ctrl *ctrl)
nvme_remove_invalid_namespaces(ctrl, NVME_NSID_ALL);
}
-static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)
+void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)
{
/*
* Revalidate LBA changes prior to unfreezing. This is necessary to
@@ -1265,6 +1267,7 @@ static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)
if (effects & (NVME_CMD_EFFECTS_NIC | NVME_CMD_EFFECTS_NCC))
nvme_queue_scan(ctrl);
}
+EXPORT_SYMBOL_GPL(nvme_passthru_end);
static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
struct nvme_passthru_cmd __user *ucmd)
@@ -3054,7 +3057,7 @@ static int ns_cmp(void *priv, struct list_head *a, struct list_head *b)
return nsa->head->ns_id - nsb->head->ns_id;
}
-static struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid)
+struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid)
{
struct nvme_ns *ns, *ret = NULL;
@@ -3072,6 +3075,7 @@ static struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid)
up_read(&ctrl->namespaces_rwsem);
return ret;
}
+EXPORT_SYMBOL_GPL(nvme_find_get_ns);
static int nvme_setup_streams_ns(struct nvme_ctrl *ctrl, struct nvme_ns *ns)
{
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index 495eafcb9e9d..9dcb1ca24126 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -420,6 +420,8 @@ void nvme_start_ctrl(struct nvme_ctrl *ctrl);
void nvme_stop_ctrl(struct nvme_ctrl *ctrl);
void nvme_put_ctrl(struct nvme_ctrl *ctrl);
int nvme_init_identify(struct nvme_ctrl *ctrl);
+struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid);
+void nvme_put_ns(struct nvme_ns *ns);
void nvme_remove_namespaces(struct nvme_ctrl *ctrl);
@@ -449,8 +451,14 @@ int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
union nvme_result *result, void *buffer, unsigned bufflen,
unsigned timeout, int qid, int at_head,
blk_mq_req_flags_t flags);
+
+u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
+ u8 opcode);
+void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects);
int nvme_set_queue_count(struct nvme_ctrl *ctrl, int *count);
void nvme_stop_keep_alive(struct nvme_ctrl *ctrl);
+struct nvme_id_ns *nvme_identify_ns(struct nvme_ctrl *ctrl,
+ unsigned nsid);
int nvme_reset_ctrl(struct nvme_ctrl *ctrl);
int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl);
int nvme_delete_ctrl(struct nvme_ctrl *ctrl);
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 3/9] nvmet: export nvmet_add_async_event api
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 1/9] nvme-core: add new interfaces to access nvme-ctrl Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 2/9] nvme-core: export existing ctrl and ns interfaces Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 4/9] nvmet: add global subsystem list Chaitanya Kulkarni
` (5 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This patch changes the return value for nvmet_add_async_event()
and exports the same API.
This change is needed for the target passthru code to generate
async events.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/core.c | 5 +++--
drivers/nvme/target/nvmet.h | 2 ++
2 files changed, 5 insertions(+), 2 deletions(-)
diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c
index 14b4c4916a8e..4317678df194 100644
--- a/drivers/nvme/target/core.c
+++ b/drivers/nvme/target/core.c
@@ -129,14 +129,14 @@ static void nvmet_async_event_work(struct work_struct *work)
}
}
-static void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type,
+bool nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type,
u8 event_info, u8 log_page)
{
struct nvmet_async_event *aen;
aen = kmalloc(sizeof(*aen), GFP_KERNEL);
if (!aen)
- return;
+ return false;
aen->event_type = event_type;
aen->event_info = event_info;
@@ -147,6 +147,7 @@ static void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type,
mutex_unlock(&ctrl->lock);
schedule_work(&ctrl->async_event_work);
+ return true;
}
static bool nvmet_aen_disabled(struct nvmet_ctrl *ctrl, u32 aen)
diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h
index ec9af4ee03b6..221cf6cacd4a 100644
--- a/drivers/nvme/target/nvmet.h
+++ b/drivers/nvme/target/nvmet.h
@@ -370,6 +370,8 @@ void nvmet_send_ana_event(struct nvmet_subsys *subsys,
struct nvmet_port *port);
void nvmet_port_send_ana_event(struct nvmet_port *port);
+bool nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type,
+ u8 event_info, u8 log_page);
int nvmet_register_transport(const struct nvmet_fabrics_ops *ops);
void nvmet_unregister_transport(const struct nvmet_fabrics_ops *ops);
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 4/9] nvmet: add global subsystem list
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (2 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 3/9] nvmet: export nvmet_add_async_event api Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 5/9] nvmet: add passthru cmd handlers Chaitanya Kulkarni
` (4 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This adds a new structure member for nvmet_subsys and global
list of the subsystems.
We use this global list to maintain currently connected,
not connected, linked and not linked subsystem on the lists.
This is a preparation patch for implementing the NVMeOF target
passthru code.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/core.c | 12 ++++++++++++
drivers/nvme/target/nvmet.h | 2 ++
2 files changed, 14 insertions(+)
diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c
index 4317678df194..ada700cce2d2 100644
--- a/drivers/nvme/target/core.c
+++ b/drivers/nvme/target/core.c
@@ -22,6 +22,9 @@ struct workqueue_struct *buffered_io_wq;
static const struct nvmet_fabrics_ops *nvmet_transports[NVMF_TRTYPE_MAX];
static DEFINE_IDA(cntlid_ida);
+static LIST_HEAD(nvmet_subsystems);
+DEFINE_MUTEX(nvmet_subsystems_lock);
+
/*
* This read/write semaphore is used to synchronize access to configuration
* information on a target system that will result in discovery log page
@@ -1166,6 +1169,11 @@ struct nvmet_subsys *nvmet_subsys_alloc(const char *subsysnqn,
INIT_LIST_HEAD(&subsys->namespaces);
INIT_LIST_HEAD(&subsys->ctrls);
INIT_LIST_HEAD(&subsys->hosts);
+ INIT_LIST_HEAD(&subsys->entry);
+
+ mutex_lock(&nvmet_subsystems_lock);
+ list_add_tail(&subsys->entry, &nvmet_subsystems);
+ mutex_unlock(&nvmet_subsystems_lock);
return subsys;
}
@@ -1177,6 +1185,10 @@ static void nvmet_subsys_free(struct kref *ref)
WARN_ON_ONCE(!list_empty(&subsys->namespaces));
+ mutex_lock(&nvmet_subsystems_lock);
+ list_del(&subsys->entry);
+ mutex_unlock(&nvmet_subsystems_lock);
+
kfree(subsys->subsysnqn);
kfree(subsys);
}
diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h
index 221cf6cacd4a..72f7380ab590 100644
--- a/drivers/nvme/target/nvmet.h
+++ b/drivers/nvme/target/nvmet.h
@@ -211,6 +211,8 @@ struct nvmet_subsys {
struct config_group namespaces_group;
struct config_group allowed_hosts_group;
+
+ struct list_head entry;
};
static inline struct nvmet_subsys *to_subsys(struct config_item *item)
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 5/9] nvmet: add passthru cmd handlers
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (3 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 4/9] nvmet: add global subsystem list Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 6/9] nvmet: integrate passthru code with core Chaitanya Kulkarni
` (3 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This patch adds passthru command handling capability for the NVMeOF
target and exports passthru APIs which are used to integrate passthru
code with nvmet-core. We add passthru ns member to the target request
to hold the ns reference for respective commands.
The new file pt-cmd.c handles passthru cmd parsing and execution. In the
passthru mode, we create a block layer request from the nvmet request
and map the data on to the block layer request. For handling the side
effects we add two functions similar to the nvme_passthru[start|end]()
functions present in the nvme-core. We explicitly blacklist the commands
at the time of parsing, which allows us to route the fabric commands
through default code path.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/Makefile | 2 +-
drivers/nvme/target/nvmet.h | 9 +
drivers/nvme/target/pt-cmd.c | 396 +++++++++++++++++++++++++++++++++++++++++++
3 files changed, 406 insertions(+), 1 deletion(-)
create mode 100644 drivers/nvme/target/pt-cmd.c
diff --git a/drivers/nvme/target/Makefile b/drivers/nvme/target/Makefile
index 8118c93391c6..280f83a85cd5 100644
--- a/drivers/nvme/target/Makefile
+++ b/drivers/nvme/target/Makefile
@@ -7,7 +7,7 @@ obj-$(CONFIG_NVME_TARGET_FC) += nvmet-fc.o
obj-$(CONFIG_NVME_TARGET_FCLOOP) += nvme-fcloop.o
nvmet-y += core.o configfs.o admin-cmd.o fabrics-cmd.o \
- discovery.o io-cmd-file.o io-cmd-bdev.o
+ discovery.o io-cmd-file.o io-cmd-bdev.o pt-cmd.o
nvme-loop-y += loop.o
nvmet-rdma-y += rdma.o
nvmet-fc-y += fc.o
diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h
index 72f7380ab590..5975839d2b7c 100644
--- a/drivers/nvme/target/nvmet.h
+++ b/drivers/nvme/target/nvmet.h
@@ -27,6 +27,8 @@
#include <linux/rcupdate.h>
#include <linux/blkdev.h>
+#include "../host/nvme.h"
+
#define NVMET_ASYNC_EVENTS 4
#define NVMET_ERROR_LOG_SLOTS 128
@@ -213,6 +215,8 @@ struct nvmet_subsys {
struct config_group allowed_hosts_group;
struct list_head entry;
+
+ struct nvme_ctrl *pt_ctrl;
};
static inline struct nvmet_subsys *to_subsys(struct config_item *item)
@@ -285,6 +289,9 @@ struct nvmet_req {
struct bio_vec *bvec;
struct work_struct work;
} f;
+ struct {
+ struct nvme_ns *pt_ns;
+ } p;
};
int sg_cnt;
/* data length as parsed from the command: */
@@ -327,6 +334,7 @@ struct nvmet_async_event {
};
u16 nvmet_parse_connect_cmd(struct nvmet_req *req);
+u16 nvmet_pt_parse_pt_cmd(struct nvmet_req *req);
u16 nvmet_bdev_parse_io_cmd(struct nvmet_req *req);
u16 nvmet_file_parse_io_cmd(struct nvmet_req *req);
u16 nvmet_parse_admin_cmd(struct nvmet_req *req);
@@ -437,6 +445,7 @@ void nvmet_file_ns_disable(struct nvmet_ns *ns);
u16 nvmet_bdev_flush(struct nvmet_req *req);
u16 nvmet_file_flush(struct nvmet_req *req);
void nvmet_ns_changed(struct nvmet_subsys *subsys, u32 nsid);
+bool nvmet_pt_cmd_allow(struct nvmet_req *req);
static inline u32 nvmet_rw_len(struct nvmet_req *req)
{
diff --git a/drivers/nvme/target/pt-cmd.c b/drivers/nvme/target/pt-cmd.c
new file mode 100644
index 000000000000..851e3ee63ac6
--- /dev/null
+++ b/drivers/nvme/target/pt-cmd.c
@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * NVMe Over Fabrics Target Passthrough command implementation.
+ * Copyright (c) 2017-2018 Western Digital Corporation or its
+ * affiliates.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+#include <linux/delay.h>
+
+#include "nvmet.h"
+
+#define NVMET_PT_NS_CMD_DELAY 1000
+
+static inline struct nvme_ctrl *nvmet_pt_ctrl(struct nvmet_req *req)
+{
+ return req->sq->ctrl->subsys->pt_ctrl;
+}
+
+static void nvmet_pt_req_complete(struct nvmet_req *req, struct request *rq,
+ u16 status)
+{
+ nvmet_req_complete(req, status);
+ __blk_put_request(rq->q, rq);
+
+ if (req->p.pt_ns) {
+ nvme_put_ns(req->p.pt_ns);
+ req->p.pt_ns = NULL;
+ }
+}
+
+static void nvmet_pt_req_done(struct request *rq,
+ blk_status_t blk_status)
+{
+ struct nvmet_req *req = rq->end_io_data;
+ u16 status = nvme_req(rq)->status;
+
+ nvmet_set_result(req, nvme_req(rq)->result.u32);
+
+ /* prioritize nvme request status over blk_status_t */
+ if (!status && blk_status)
+ status = NVME_SC_INTERNAL;
+
+ nvmet_pt_req_complete(req, rq, status);
+}
+
+static inline u16 nvmet_pt_admin_format_nvm_start(struct nvmet_req *req)
+{
+ int lbaf = le32_to_cpu(req->cmd->format.cdw10) & 0x0000000F;
+ int nsid = le32_to_cpu(req->cmd->format.nsid);
+ u16 status = NVME_SC_SUCCESS;
+ struct nvme_id_ns *id;
+
+ id = nvme_identify_ns(nvmet_pt_ctrl(req), nsid);
+ if (!id)
+ return NVME_SC_INTERNAL;
+ /*
+ * XXX: Please update this code once NVMeOF target starts supoorting
+ * metadata. We don't support ns lba format with metadata over fabrics
+ * right now, so report error if format nvm cmd tries to format
+ * a namespace with the LBA format which has metadata.
+ */
+ if (id->lbaf[lbaf].ms)
+ status = NVME_SC_INVALID_NS;
+
+ kfree(id);
+ return status;
+}
+
+static inline u16 nvmet_pt_id_ctrl_init_fabircs_fields(struct nvmet_req *req)
+{
+ struct nvmet_ctrl *ctrl = req->sq->ctrl;
+ u16 status = NVME_SC_SUCCESS;
+ struct nvme_id_ctrl *id;
+
+ id = kzalloc(sizeof(*id), GFP_KERNEL);
+ if (!id) {
+ status = NVME_SC_INTERNAL;
+ goto out;
+ }
+ status = nvmet_copy_from_sgl(req, 0, id, sizeof(struct nvme_id_ctrl));
+ if (status)
+ goto out_free;
+
+ id->cntlid = cpu_to_le16(ctrl->cntlid);
+
+ id->acl = 3;
+ /* XXX: update these values when AER is implemented for the passthru */
+ id->aerl = 0;
+
+ /* emulate kas as most of the PCIe ctrl don't have a support for kas */
+ id->kas = cpu_to_le16(NVMET_KAS);
+
+ /* don't support host memory buffer */
+ id->hmpre = 0;
+ id->hmmin = 0;
+
+ id->sqes = min_t(__u8, ((0x6 << 4) | 0x6), id->sqes);
+ id->cqes = min_t(__u8, ((0x4 << 4) | 0x4), id->cqes);
+ id->maxcmd = cpu_to_le16(NVMET_MAX_CMD);
+
+ /* don't support fuse commands */
+ id->fuses = 0;
+
+ id->sgls = cpu_to_le32(1 << 0); /* we always support SGLs */
+ if (ctrl->ops->has_keyed_sgls)
+ id->sgls |= cpu_to_le32(1 << 2);
+ if (req->port->inline_data_size)
+ id->sgls |= cpu_to_le32(1 << 20);
+
+ /* to allow loop mode don't use passthru ctrl subnqn */
+ memcpy(id->subnqn, ctrl->subsysnqn, sizeof(id->subnqn));
+
+ /* use fabric id-ctrl values */
+ id->ioccsz = cpu_to_le32((sizeof(struct nvme_command) +
+ req->port->inline_data_size) / 16);
+ id->iorcsz = cpu_to_le32(sizeof(struct nvme_completion) / 16);
+
+ id->msdbd = ctrl->ops->msdbd;
+
+ status = nvmet_copy_to_sgl(req, 0, id, sizeof(struct nvme_id_ctrl));
+
+out_free:
+ kfree(id);
+out:
+ return status;
+}
+
+static inline u16 nvmet_pt_id_ns_init_fabircs_fields(struct nvmet_req *req)
+{
+ u16 status = NVME_SC_SUCCESS;
+ struct nvme_id_ns *id;
+ int i;
+
+ id = kzalloc(sizeof(*id), GFP_KERNEL);
+ if (!id) {
+ status = NVME_SC_INTERNAL;
+ goto out;
+ }
+
+ status = nvmet_copy_from_sgl(req, 0, id, sizeof(struct nvme_id_ns));
+ if (status)
+ goto out_free;
+
+ for (i = 0; i < (id->nlbaf + 1); i++)
+ if (id->lbaf[i].ms)
+ memset(&id->lbaf[i], 0, sizeof(id->lbaf[i]));
+
+ id->flbas = id->flbas & ~(1 << 4);
+ id->mc = 0;
+
+ status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id));
+
+out_free:
+ kfree(id);
+out:
+ return status;
+}
+
+static inline u16 nvmet_pt_admin_cmd_identify_end(struct nvmet_req *req)
+{
+ u16 status = NVME_SC_SUCCESS;
+
+ switch (req->cmd->identify.cns) {
+ case NVME_ID_CNS_CTRL:
+ status = nvmet_pt_id_ctrl_init_fabircs_fields(req);
+ break;
+ case NVME_ID_CNS_NS:
+ status = nvmet_pt_id_ns_init_fabircs_fields(req);
+ break;
+ }
+ return status;
+}
+
+static u16 nvmet_pt_admin_passthru_start(struct nvmet_req *req)
+{
+ u16 status = NVME_SC_SUCCESS;
+
+ switch (req->cmd->common.opcode) {
+ case nvme_admin_format_nvm:
+ status = nvmet_pt_admin_format_nvm_start(req);
+ break;
+ }
+ return status;
+}
+
+static u16 nvmet_pt_admin_passthru_end(struct nvmet_req *req)
+{
+ u8 aer_type = NVME_AER_TYPE_NOTICE;
+ u16 status = NVME_SC_SUCCESS;
+
+ switch (req->cmd->common.opcode) {
+ case nvme_admin_identify:
+ status = nvmet_pt_admin_cmd_identify_end(req);
+ break;
+ case nvme_admin_ns_mgmt:
+ case nvme_admin_ns_attach:
+ case nvme_admin_format_nvm:
+ /* allow passthru ctrl to finish the operation */
+ mdelay(NVMET_PT_NS_CMD_DELAY);
+ if (!nvmet_add_async_event(req->sq->ctrl, aer_type, 0, 0))
+ status = NVME_SC_INTERNAL;
+ mdelay(NVMET_PT_NS_CMD_DELAY);
+ break;
+ }
+ return status;
+}
+
+static void nvmet_pt_execute_admin_cmd(struct nvmet_req *req,
+ struct request *rq)
+{
+ u8 opcode = req->cmd->common.opcode;
+ u32 effects;
+ u16 status;
+
+ status = nvmet_pt_admin_passthru_start(req);
+ if (status)
+ goto out;
+
+ effects = nvme_passthru_start(nvmet_pt_ctrl(req), NULL, opcode);
+
+ blk_execute_rq(rq->q, NULL, rq, 0);
+
+ nvme_passthru_end(nvmet_pt_ctrl(req), effects);
+ status = nvmet_pt_admin_passthru_end(req);
+out:
+ if (status == NVME_SC_SUCCESS) {
+ nvmet_set_result(req, nvme_req(rq)->result.u32);
+ status = nvme_req(rq)->status;
+ }
+
+ nvmet_pt_req_complete(req, rq, status);
+}
+
+static struct request *nvmet_pt_blk_make_request(struct nvmet_req *req,
+ struct bio *bio, gfp_t gfp_mask)
+{
+ struct nvme_ctrl *pt_ctrl = nvmet_pt_ctrl(req);
+ struct nvme_command *cmd = req->cmd;
+ struct request_queue *q;
+ struct request *rq;
+
+ if (likely(req->sq->qid != 0))
+ q = req->p.pt_ns->queue;
+ else
+ q = pt_ctrl->admin_q;
+
+ rq = nvme_alloc_request(q, cmd, BLK_MQ_REQ_NOWAIT, NVME_QID_ANY);
+ if (IS_ERR(rq))
+ return rq;
+
+ for_each_bio(bio) {
+ int ret = blk_rq_append_bio(rq, &bio);
+
+ if (unlikely(ret)) {
+ blk_put_request(rq);
+ return ERR_PTR(ret);
+ }
+ }
+ /*
+ * We don't support fuse cmds, also nvme-pci driver used its own
+ * sgl_threshold parameter to decide whether to use SGLs or PRPs hence
+ * turn off those bits in the flags.
+ */
+ req->cmd->common.flags &= ~(NVME_CMD_FUSE_FIRST | NVME_CMD_FUSE_SECOND |
+ NVME_CMD_SGL_ALL);
+ return rq;
+}
+
+static void nvmet_pt_execute_pt(struct nvmet_req *req)
+{
+ struct bio *first_bio = NULL;
+ int sg_cnt = req->sg_cnt;
+ struct bio *prev = NULL;
+ struct bio *bio = NULL;
+ struct scatterlist *sg;
+ int op = REQ_OP_READ;
+ struct request *rq;
+ int op_flags = 0;
+ int i;
+
+ if (nvme_is_write(req->cmd)) {
+ op = REQ_OP_WRITE;
+ op_flags = REQ_SYNC | REQ_IDLE;
+ }
+
+ if (req->sg_cnt) {
+ bio = bio_alloc(GFP_KERNEL, min(sg_cnt, BIO_MAX_PAGES));
+ first_bio = bio;
+ bio->bi_end_io = bio_put;
+
+ for_each_sg(req->sg, sg, req->sg_cnt, i) {
+ if (bio_add_page(bio, sg_page(sg), sg->length,
+ sg->offset) != sg->length) {
+ prev = bio;
+ bio_set_op_attrs(bio, op, op_flags);
+ bio = bio_alloc(GFP_KERNEL,
+ min(sg_cnt, BIO_MAX_PAGES));
+ bio_chain(bio, prev);
+ }
+ sg_cnt--;
+ }
+ }
+
+ rq = nvmet_pt_blk_make_request(req, first_bio, GFP_KERNEL);
+ if (IS_ERR(rq))
+ goto fail_free_bio;
+
+ rq->end_io_data = req;
+ if (likely(req->sq->qid != 0))
+ blk_execute_rq_nowait(rq->q, NULL, rq, 0, nvmet_pt_req_done);
+ else
+ nvmet_pt_execute_admin_cmd(req, rq);
+ return;
+
+fail_free_bio:
+ while (first_bio) {
+ bio = first_bio;
+ first_bio = first_bio->bi_next;
+ bio_endio(bio);
+ }
+}
+
+static inline bool nvmet_pt_admin_cmd_supported(struct nvmet_req *req)
+{
+ struct nvme_command *cmd = req->cmd;
+ unsigned int fid;
+ bool ret = true;
+
+ switch (cmd->common.opcode) {
+ /* black listed commands */
+ case nvme_admin_create_sq:
+ case nvme_admin_create_cq:
+ case nvme_admin_delete_sq:
+ case nvme_admin_delete_cq:
+ case nvme_admin_async_event: /* not implemented */
+ case nvme_admin_activate_fw:
+ case nvme_admin_download_fw:
+ case nvme_admin_directive_send:
+ case nvme_admin_directive_recv:
+ case nvme_admin_dbbuf:
+ case nvme_admin_security_send:
+ case nvme_admin_security_recv:
+ case nvme_fabrics_command:
+ /* fall thru */
+ /*
+ * Most PCIe ctrls don't support keep alive cmd, we route
+ * keep alive to the non-passthru mode. In future please change
+ * this code when PCIe ctrls with keep alive support available.
+ */
+ case nvme_admin_keep_alive:
+ ret = false;
+ break;
+ case nvme_admin_set_features:
+ fid = le32_to_cpu(req->cmd->features.fid);
+ switch (fid) {
+ case NVME_FEAT_NUM_QUEUES: /* disabled */
+ case NVME_FEAT_ASYNC_EVENT: /* not implemented */
+ case NVME_FEAT_KATO: /* route through target code */
+ ret = false;
+ break;
+ }
+ break;
+ }
+ return ret;
+}
+
+bool nvmet_pt_cmd_allow(struct nvmet_req *req)
+{
+ if (likely(req->sq->ctrl) && !nvmet_pt_ctrl(req))
+ return false;
+
+ if (unlikely(req->sq->qid == 0))
+ return nvmet_pt_admin_cmd_supported(req);
+
+ return true;
+}
+
+u16 nvmet_pt_parse_pt_cmd(struct nvmet_req *req)
+{
+ u32 nsid = le32_to_cpu(req->cmd->common.nsid);
+
+ if (unlikely(nvmet_check_ctrl_status(req, req->cmd)))
+ return NVME_SC_INVALID_NS | NVME_SC_DNR;
+
+ if (unlikely(req->sq->qid == 0))
+ goto out;
+
+ req->p.pt_ns = nvme_find_get_ns(nvmet_pt_ctrl(req), nsid);
+ if (unlikely(!req->p.pt_ns)) {
+ pr_err("failed to get passthru ns nsid:%u\n", nsid);
+ return NVME_SC_INVALID_NS | NVME_SC_DNR;
+ }
+out:
+ req->execute = nvmet_pt_execute_pt;
+ return NVME_SC_SUCCESS;
+}
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 6/9] nvmet: integrate passthru code with core
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (4 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 5/9] nvmet: add passthru cmd handlers Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 7/9] nvmet: add configfs interface for target passthru Chaitanya Kulkarni
` (2 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This patch integrates the passthru command code with NVMeOF target
core. As we integrate the passthru code with target core, it exports
APIs to enable/disable passthru ctrl via configfs.
Here we also make sure none of the target-ns belongs to the passthru-ctrl
and none of the existing subsystems is configured with this passthru-ctrl.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/core.c | 180 +++++++++++++++++++++++++++++++++++++++++---
drivers/nvme/target/nvmet.h | 4 +
2 files changed, 175 insertions(+), 9 deletions(-)
diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c
index ada700cce2d2..98ca0e5f20a1 100644
--- a/drivers/nvme/target/core.c
+++ b/drivers/nvme/target/core.c
@@ -369,11 +369,66 @@ static void nvmet_ns_dev_disable(struct nvmet_ns *ns)
nvmet_file_ns_disable(ns);
}
+static int nvmet_pt_ns(struct nvme_ctrl *ctrl, char *disk_name)
+{
+ struct nvme_ns *ns;
+ int ret = 0;
+
+ if (!disk_name)
+ return -EINVAL;
+
+ down_read(&ctrl->namespaces_rwsem);
+ list_for_each_entry(ns, &ctrl->namespaces, list) {
+ if (!strcmp(ns->disk->disk_name, disk_name)) {
+ ret = -EINVAL;
+ break;
+ }
+ }
+ up_read(&ctrl->namespaces_rwsem);
+ return ret;
+}
+
+static int nvmet_ns_device_path_allow(struct nvmet_ns *ns)
+{
+ struct nvmet_subsys *s = ns->subsys;
+ char *dev_file;
+ int ret = 0;
+
+ mutex_lock(&nvmet_subsystems_lock);
+ list_for_each_entry(s, &nvmet_subsystems, entry) {
+ kref_get(&s->ref);
+ mutex_unlock(&nvmet_subsystems_lock);
+ mutex_lock(&s->lock);
+ if (s->pt_ctrl) {
+ dev_file = strrchr(ns->device_path, '/');
+ dev_file++;
+ if (nvmet_pt_ns(s->pt_ctrl, dev_file)) {
+ pr_err("%s ns belongs to passthru ctrl\n",
+ ns->device_path);
+ ret = -EINVAL;
+ mutex_unlock(&s->lock);
+ mutex_lock(&nvmet_subsystems_lock);
+ nvmet_subsys_put(s);
+ break;
+ }
+ }
+ mutex_unlock(&s->lock);
+ mutex_lock(&nvmet_subsystems_lock);
+ nvmet_subsys_put(s);
+ }
+ mutex_unlock(&nvmet_subsystems_lock);
+ return ret;
+}
+
int nvmet_ns_enable(struct nvmet_ns *ns)
{
struct nvmet_subsys *subsys = ns->subsys;
int ret;
+ ret = nvmet_ns_device_path_allow(ns);
+ if (ret)
+ goto out;
+
mutex_lock(&subsys->lock);
ret = -EMFILE;
if (subsys->nr_namespaces == NVMET_MAX_NAMESPACES)
@@ -420,6 +475,7 @@ int nvmet_ns_enable(struct nvmet_ns *ns)
ret = 0;
out_unlock:
mutex_unlock(&subsys->lock);
+out:
return ret;
out_dev_put:
nvmet_ns_dev_disable(ns);
@@ -498,6 +554,77 @@ struct nvmet_ns *nvmet_ns_alloc(struct nvmet_subsys *subsys, u32 nsid)
return ns;
}
+int nvmet_pt_ctrl_enable(struct nvmet_subsys *subsys)
+{
+ struct nvmet_subsys *s;
+ struct nvmet_ns *tns;
+ char *pt_ctrl_path;
+ char *dev_file;
+ int ret = 0;
+
+ if (!subsys)
+ return -ENODEV;
+
+ if (subsys->pt_ctrl)
+ return -EINVAL;
+
+ pt_ctrl_path = subsys->pt_ctrl_path;
+ if (nvme_get_ctrl_by_path(pt_ctrl_path, &subsys->pt_ctrl)) {
+ pr_err("unable to find passthru ctrl '%s'\n", pt_ctrl_path);
+ return -ENODEV;
+ }
+
+ mutex_lock(&nvmet_subsystems_lock);
+ list_for_each_entry(s, &nvmet_subsystems, entry) {
+ /* skip current subsys */
+ if (!strcmp(s->subsysnqn, subsys->subsysnqn))
+ continue;
+
+ kref_get(&s->ref);
+ mutex_unlock(&nvmet_subsystems_lock);
+ /* check if this pt ctrl is alredy belongs to other subsys */
+ if (s->pt_ctrl && !strcmp(s->pt_ctrl_path, pt_ctrl_path)) {
+ ret = -EINVAL;
+ pr_err("pt ctrl %s is associated with subsys %s\n",
+ subsys->pt_ctrl_path, subsys->subsysnqn);
+ goto out;
+ }
+ /* check if any target ns is present on pt ctrl's ns list */
+ mutex_lock(&s->lock);
+ list_for_each_entry(tns, &s->namespaces, dev_link) {
+ dev_file = strrchr(tns->device_path, '/');
+ dev_file++;
+ if (nvmet_pt_ns(subsys->pt_ctrl, dev_file)) {
+ ret = -EINVAL;
+ pr_err("ns conflict passthru enable failed\n");
+ break;
+ }
+ }
+ mutex_unlock(&s->lock);
+out:
+ mutex_lock(&nvmet_subsystems_lock);
+ nvmet_subsys_put(s);
+ if (ret)
+ break;
+
+ }
+ mutex_unlock(&nvmet_subsystems_lock);
+ if (ret) {
+ nvmet_pt_ctrl_disable(subsys);
+ kfree(subsys->pt_ctrl_path);
+ subsys->pt_ctrl_path = NULL;
+ }
+ return ret;
+}
+
+void nvmet_pt_ctrl_disable(struct nvmet_subsys *subsys)
+{
+ if (!subsys || !subsys->pt_ctrl)
+ return;
+
+ nvme_put_ctrl_by_path(subsys->pt_ctrl);
+ subsys->pt_ctrl = NULL;
+}
static void __nvmet_req_complete(struct nvmet_req *req, u16 status)
{
u32 old_sqhd, new_sqhd;
@@ -687,6 +814,8 @@ bool nvmet_req_init(struct nvmet_req *req, struct nvmet_cq *cq,
if (unlikely(!req->sq->ctrl))
/* will return an error for any Non-connect command: */
status = nvmet_parse_connect_cmd(req);
+ else if (nvmet_pt_cmd_allow(req))
+ status = nvmet_pt_parse_pt_cmd(req);
else if (likely(req->sq->qid != 0))
status = nvmet_parse_io_cmd(req);
else if (req->cmd->common.opcode == nvme_fabrics_command)
@@ -722,7 +851,16 @@ EXPORT_SYMBOL_GPL(nvmet_req_uninit);
void nvmet_req_execute(struct nvmet_req *req)
{
- if (unlikely(req->data_len != req->transfer_len))
+ /*
+ * Right now data_len is calculated before the transfer len
+ * after we parse the command, With passthru interface
+ * we allow VUC's. In order to make the code simple and compact,
+ * instead of assinging the the dala len for each VUC in the command
+ * parse function just use the transfer len as it is. This may
+ * result is error if expected data_len != transfer_len.
+ */
+ if (!(req->sq->ctrl && req->sq->ctrl->subsys->pt_ctrl) &&
+ unlikely(req->data_len != req->transfer_len))
nvmet_req_complete(req, NVME_SC_SGL_INVALID_DATA | NVME_SC_DNR);
else
req->execute(req);
@@ -943,6 +1081,19 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, const char *hostnqn,
}
status = NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
+ /*
+ * Check here if this subsystem is already connected to the
+ * passthru ctrl. We allow only one target ctrl for one passthru
+ * subsystem.
+ */
+ mutex_lock(&subsys->lock);
+ if (subsys->pt_ctrl) {
+ if (subsys->pt_connected == true) {
+ mutex_unlock(&subsys->lock);
+ goto out_put_subsystem;
+ }
+ }
+ mutex_unlock(&subsys->lock);
down_read(&nvmet_config_sem);
if (!nvmet_host_allowed(req, subsys, hostnqn)) {
pr_info("connect by host %s for subsystem %s not allowed\n",
@@ -991,12 +1142,16 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, const char *hostnqn,
if (!ctrl->sqs)
goto out_free_cqs;
- ret = ida_simple_get(&cntlid_ida,
- NVME_CNTLID_MIN, NVME_CNTLID_MAX,
- GFP_KERNEL);
- if (ret < 0) {
- status = NVME_SC_CONNECT_CTRL_BUSY | NVME_SC_DNR;
- goto out_free_sqs;
+ if (subsys->pt_ctrl)
+ ret = subsys->pt_ctrl->cntlid;
+ else {
+ ret = ida_simple_get(&cntlid_ida,
+ NVME_CNTLID_MIN, NVME_CNTLID_MAX,
+ GFP_KERNEL);
+ if (ret < 0) {
+ status = NVME_SC_CONNECT_CTRL_BUSY | NVME_SC_DNR;
+ goto out_free_sqs;
+ }
}
ctrl->cntlid = ret;
@@ -1030,13 +1185,16 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, const char *hostnqn,
mutex_lock(&subsys->lock);
list_add_tail(&ctrl->subsys_entry, &subsys->ctrls);
+ if (subsys->pt_ctrl && subsys->pt_connected == false)
+ subsys->pt_connected = true;
mutex_unlock(&subsys->lock);
*ctrlp = ctrl;
return 0;
out_remove_ida:
- ida_simple_remove(&cntlid_ida, ctrl->cntlid);
+ if (!subsys->pt_ctrl)
+ ida_simple_remove(&cntlid_ida, ctrl->cntlid);
out_free_sqs:
kfree(ctrl->sqs);
out_free_cqs:
@@ -1057,6 +1215,8 @@ static void nvmet_ctrl_free(struct kref *ref)
struct nvmet_subsys *subsys = ctrl->subsys;
mutex_lock(&subsys->lock);
+ if (subsys->pt_ctrl && subsys->pt_connected == true)
+ subsys->pt_connected = false;
list_del(&ctrl->subsys_entry);
mutex_unlock(&subsys->lock);
@@ -1065,7 +1225,8 @@ static void nvmet_ctrl_free(struct kref *ref)
flush_work(&ctrl->async_event_work);
cancel_work_sync(&ctrl->fatal_err_work);
- ida_simple_remove(&cntlid_ida, ctrl->cntlid);
+ if (!subsys->pt_ctrl)
+ ida_simple_remove(&cntlid_ida, ctrl->cntlid);
kfree(ctrl->sqs);
kfree(ctrl->cqs);
@@ -1189,6 +1350,7 @@ static void nvmet_subsys_free(struct kref *ref)
list_del(&subsys->entry);
mutex_unlock(&nvmet_subsystems_lock);
+ kfree(subsys->pt_ctrl_path);
kfree(subsys->subsysnqn);
kfree(subsys);
}
diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h
index 5975839d2b7c..c2712392bb33 100644
--- a/drivers/nvme/target/nvmet.h
+++ b/drivers/nvme/target/nvmet.h
@@ -216,6 +216,8 @@ struct nvmet_subsys {
struct list_head entry;
+ bool pt_connected;
+ char *pt_ctrl_path;
struct nvme_ctrl *pt_ctrl;
};
@@ -446,6 +448,8 @@ u16 nvmet_bdev_flush(struct nvmet_req *req);
u16 nvmet_file_flush(struct nvmet_req *req);
void nvmet_ns_changed(struct nvmet_subsys *subsys, u32 nsid);
bool nvmet_pt_cmd_allow(struct nvmet_req *req);
+int nvmet_pt_ctrl_enable(struct nvmet_subsys *subsys);
+void nvmet_pt_ctrl_disable(struct nvmet_subsys *subsys);
static inline u32 nvmet_rw_len(struct nvmet_req *req)
{
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 7/9] nvmet: add configfs interface for target passthru
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (5 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 6/9] nvmet: integrate passthru code with core Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 8/9] block: add helper to get the request based cookie Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 9/9] nvmet: add request polling support Chaitanya Kulkarni
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This patch adds configfs interface for target passthru ctrl management.
The new directory "pt" under nvmet configfs is added to configure passthru
ctrl (pt-ctrl). Once all the fields for the pt-ctrl are set user can
enable the pt-ctrl through configfs.
The new directory pt is parallel to the subsystem and has similar
attributes as default subsystem, each passthru ctrl is represented as one
subsystem. Since we allow ctrl passthru we don't export or allow user to
access the passthru namespace(s) in the configfs.
The new attribute "attr_ctrl_path" expects nvme ctrl path,
e.g. "/dev/nvmeX".
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/configfs.c | 145 ++++++++++++++++++++++++++++++++++++++++-
1 file changed, 144 insertions(+), 1 deletion(-)
diff --git a/drivers/nvme/target/configfs.c b/drivers/nvme/target/configfs.c
index 51f5a8c092b4..a7f5b508e5fa 100644
--- a/drivers/nvme/target/configfs.c
+++ b/drivers/nvme/target/configfs.c
@@ -21,6 +21,7 @@
#include "nvmet.h"
static const struct config_item_type nvmet_host_type;
+static const struct config_item_type nvmet_pt_type;
static const struct config_item_type nvmet_subsys_type;
static const struct nvmet_transport_name {
@@ -570,7 +571,8 @@ static int nvmet_port_subsys_allow_link(struct config_item *parent,
struct nvmet_subsys_link *link, *p;
int ret;
- if (target->ci_type != &nvmet_subsys_type) {
+ if (!(target->ci_type == &nvmet_subsys_type ||
+ target->ci_type == &nvmet_pt_type)) {
pr_err("can only link subsystems into the subsystems dir.!\n");
return -EINVAL;
}
@@ -865,6 +867,141 @@ static const struct config_item_type nvmet_subsystems_type = {
.ct_owner = THIS_MODULE,
};
+
+/*
+ * Passthru attributes and operations.
+ */
+static ssize_t nvmet_pt_attr_ctrl_path_show(struct config_item *item,
+ char *page)
+{
+ struct nvmet_subsys *subsys = to_subsys(item);
+
+ return snprintf(page, PAGE_SIZE, "%s\n", subsys->pt_ctrl_path);
+}
+
+static ssize_t nvmet_pt_attr_ctrl_path_store(struct config_item *item,
+ const char *page, size_t count)
+{
+ struct nvmet_subsys *subsys = to_subsys(item);
+ int ret = -ENOMEM;
+
+ mutex_lock(&subsys->lock);
+ kfree(subsys->pt_ctrl_path);
+
+ subsys->pt_ctrl_path = kstrdup(page, GFP_KERNEL);
+ if (!subsys->pt_ctrl_path)
+ goto out_unlock;
+
+ mutex_unlock(&subsys->lock);
+
+ return count;
+out_unlock:
+ mutex_unlock(&subsys->lock);
+ return ret;
+
+}
+CONFIGFS_ATTR(nvmet_pt_, attr_ctrl_path);
+
+static ssize_t nvmet_pt_attr_enable_show(struct config_item *item, char *page)
+{
+ return sprintf(page, "%d\n", to_subsys(item)->pt_ctrl ? 1 : 0);
+}
+
+static ssize_t nvmet_pt_attr_enable_store(struct config_item *item,
+ const char *page, size_t count)
+{
+ struct nvmet_subsys *subsys = to_subsys(item);
+ bool enable;
+ int ret = 0;
+
+ if (subsys->pt_ctrl_path == NULL) {
+ pr_err("passthru ctrl path is not initialized.\n");
+ return -EINVAL;
+ }
+
+ if (strtobool(page, &enable))
+ return -EINVAL;
+
+ if (enable)
+ ret = nvmet_pt_ctrl_enable(subsys);
+ else
+ nvmet_pt_ctrl_disable(subsys);
+
+ return ret ? ret : count;
+}
+CONFIGFS_ATTR(nvmet_pt_, attr_enable);
+
+static struct configfs_attribute *nvmet_pt_attrs[] = {
+ &nvmet_pt_attr_attr_ctrl_path,
+ &nvmet_pt_attr_attr_enable,
+ &nvmet_subsys_attr_attr_allow_any_host,
+ &nvmet_subsys_attr_attr_version,
+ &nvmet_subsys_attr_attr_serial,
+ NULL,
+};
+
+/*
+ * Passthru structures & folder operation functions below
+ */
+static void nvmet_pt_release(struct config_item *item)
+{
+ struct nvmet_subsys *subsys = to_subsys(item);
+
+ nvmet_subsys_del_ctrls(subsys);
+ /*
+ * Since we are the only one to manage the pt ctrl,
+ * disable the pt ctrl in case user did not disable
+ * the ctrl attribute prior to removing the passthru subsystem.
+ */
+
+ nvmet_pt_ctrl_disable(subsys);
+
+ nvmet_subsys_put(subsys);
+}
+
+static struct configfs_item_operations nvmet_pt_item_ops = {
+ .release = nvmet_pt_release,
+};
+
+static const struct config_item_type nvmet_pt_type = {
+ .ct_item_ops = &nvmet_pt_item_ops,
+ .ct_attrs = nvmet_pt_attrs,
+ .ct_owner = THIS_MODULE,
+};
+
+static struct config_group *nvmet_pt_make(struct config_group *group,
+ const char *name)
+{
+ struct nvmet_subsys *subsys;
+
+ if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
+ pr_err("can't create discovery subsystem through configfs\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
+ if (!subsys)
+ return ERR_PTR(-ENOMEM);
+
+ config_group_init_type_name(&subsys->group, name, &nvmet_pt_type);
+
+ config_group_init_type_name(&subsys->allowed_hosts_group,
+ "allowed_hosts", &nvmet_allowed_hosts_type);
+ configfs_add_default_group(&subsys->allowed_hosts_group,
+ &subsys->group);
+
+ return &subsys->group;
+}
+
+static struct configfs_group_operations nvmet_pts_group_ops = {
+ .make_group = nvmet_pt_make,
+};
+
+static struct config_item_type nvmet_pts_type = {
+ .ct_group_ops = &nvmet_pts_group_ops,
+ .ct_owner = THIS_MODULE,
+};
+
static ssize_t nvmet_referral_enable_show(struct config_item *item,
char *page)
{
@@ -1178,6 +1315,7 @@ static const struct config_item_type nvmet_ports_type = {
};
static struct config_group nvmet_subsystems_group;
+static struct config_group nvmet_pts_group;
static struct config_group nvmet_ports_group;
static void nvmet_host_release(struct config_item *item)
@@ -1241,6 +1379,11 @@ int __init nvmet_init_configfs(void)
config_group_init(&nvmet_configfs_subsystem.su_group);
mutex_init(&nvmet_configfs_subsystem.su_mutex);
+ config_group_init_type_name(&nvmet_pts_group,
+ "passthru", &nvmet_pts_type);
+ configfs_add_default_group(&nvmet_pts_group,
+ &nvmet_configfs_subsystem.su_group);
+
config_group_init_type_name(&nvmet_subsystems_group,
"subsystems", &nvmet_subsystems_type);
configfs_add_default_group(&nvmet_subsystems_group,
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 8/9] block: add helper to get the request based cookie
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (6 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 7/9] nvmet: add configfs interface for target passthru Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
2018-08-15 19:58 ` [PATCH V4 9/9] nvmet: add request polling support Chaitanya Kulkarni
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
This patch adds a helper function to get calculate the cookie based
on the request. This is needed for the drivers which are issuing
request based I/Os such as NVMe Over Fabrics target passthru driver an
using polling.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
block/blk-mq.c | 20 ++++++++++++++++++++
include/linux/blk-mq.h | 1 +
2 files changed, 21 insertions(+)
diff --git a/block/blk-mq.c b/block/blk-mq.c
index e13bdc2707ce..2759eeed0847 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -1669,6 +1669,26 @@ static blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx, struct request *rq)
return blk_tag_to_qc_t(rq->internal_tag, hctx->queue_num, true);
}
+blk_qc_t blk_mq_req_cookie(struct request *rq)
+{
+ struct blk_mq_ctx *ctx;
+ struct blk_mq_hw_ctx *hctx;
+
+ if (!rq || !rq->q)
+ return BLK_QC_T_NONE;
+
+ ctx = blk_mq_get_ctx(rq->q);
+ if (!ctx)
+ return BLK_QC_T_NONE;
+
+ hctx = blk_mq_map_queue(rq->q, ctx->cpu);
+ if (!hctx)
+ return BLK_QC_T_NONE;
+
+ return request_to_qc_t(hctx, rq);
+}
+EXPORT_SYMBOL(blk_mq_req_cookie);
+
static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx,
struct request *rq,
blk_qc_t *cookie)
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index d710e92874cc..c3dabb2ad177 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -270,6 +270,7 @@ void blk_mq_stop_hw_queues(struct request_queue *q);
void blk_mq_start_hw_queues(struct request_queue *q);
void blk_mq_start_stopped_hw_queue(struct blk_mq_hw_ctx *hctx, bool async);
void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async);
+blk_qc_t blk_mq_req_cookie(struct request *rq);
void blk_mq_quiesce_queue(struct request_queue *q);
void blk_mq_unquiesce_queue(struct request_queue *q);
void blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH V4 9/9] nvmet: add request polling support
2018-08-15 19:58 [PATCH V4 0/9] nvmet: add target passthru commands support Chaitanya Kulkarni
` (7 preceding siblings ...)
2018-08-15 19:58 ` [PATCH V4 8/9] block: add helper to get the request based cookie Chaitanya Kulkarni
@ 2018-08-15 19:58 ` Chaitanya Kulkarni
8 siblings, 0 replies; 12+ messages in thread
From: Chaitanya Kulkarni @ 2018-08-15 19:58 UTC (permalink / raw)
Use request based polling for NVMeOF target passthru I/O submission.
Signed-off-by: Chaitanya Kulkarni <chaitanya.kulkarni at wdc.com>
---
drivers/nvme/target/pt-cmd.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/drivers/nvme/target/pt-cmd.c b/drivers/nvme/target/pt-cmd.c
index 851e3ee63ac6..6a7f46918103 100644
--- a/drivers/nvme/target/pt-cmd.c
+++ b/drivers/nvme/target/pt-cmd.c
@@ -306,8 +306,10 @@ static void nvmet_pt_execute_pt(struct nvmet_req *req)
goto fail_free_bio;
rq->end_io_data = req;
- if (likely(req->sq->qid != 0))
+ if (likely(req->sq->qid != 0)) {
blk_execute_rq_nowait(rq->q, NULL, rq, 0, nvmet_pt_req_done);
+ blk_poll(rq->q, blk_mq_req_cookie(rq));
+ }
else
nvmet_pt_execute_admin_cmd(req, rq);
return;
--
2.14.1
^ permalink raw reply related [flat|nested] 12+ messages in thread