Support for Cancel commands for host (TCP and RDMA)
Subsystems (2)
v2 cover Support for Cancel commands for host (TCP and RDMA)
The nvme host driver could take advantage of Cancel (defined by TP 4097a) to abort a command that timed out instead of resetting the controller.
The abort command's implementation is mandated by the specs but the target isn't necessarily required to perform any meaningful action (as it happens, for example, with the Linux nvmet implementation, where the abort command does nothing at all).
On the other hand, the Cancel command is optional, therefore if the target claims to support it, it's reasonable to expect its implementation to perform something useful.
This patchset modifies the tcp and rdma host drivers' timeout handlers to check if the target supports the Cancel command; if so, it will use it to try to abort the command that timed out. If the number of reserved commands runs low, use the "multiple commands" action to abort all the commands on the specificied queue as a last resort to avoid a controller reset.
If Cancel isn't supported, if the allocation of the command fails, or if the pool of reserved commands is completely exhausted, the host will fall back to the normal controller reset.
example of output in dmesg where a command gets canceled and the target performed 1 immediate abort:
nvme nvme7: I/O tag 105 (1069) type 4 opcode 0x1 (I/O Cmd) QID 13 timeout nvme nvme7: Cancel status: 0x0 imm abrts = 1 def abrts = 0
Patch 7 is a modified nvmet drivers with a module parameter that enables an extremely basic emulation of cancel command (it does nothing, it just reports that no aborts were executed). it could be useful for testing Cancel with blktests.
V2: Reserve 2 commands per queue for cancel commands (the number is fixed but in future it can be made configurable with trivial changes to the code).
John Meneghini (1):
nvme: add definitions for cancel command
Maurizio Lombardi (6):
nvme-core: function to check if a controller supports a specific I/O
cmd
nvme-core: reserve tags for cancel commands
nvme-core: add a function to submit a cancel command
nvme-tcp: use the cancel command to perform an abort if target
supports it
nvme-rdma: use the cancel command to perform an abort if target
supports it
nvmet: emulate basic support for cancel commands
drivers/nvme/host/constants.c | 1 + drivers/nvme/host/core.c | 77 ++++++++++++++++++++++++++++- drivers/nvme/host/nvme.h | 3 ++ drivers/nvme/host/rdma.c | 43 ++++++++++++++-- drivers/nvme/host/tcp.c | 58 ++++++++++++++++++++-- drivers/nvme/target/Makefile | 2 +- drivers/nvme/target/admin-cmd.c | 4 ++ drivers/nvme/target/core.c | 11 +++++ drivers/nvme/target/io-cmd-cancel.c | 52 +++++++++++++++++++ drivers/nvme/target/nvmet.h | 4 ++ include/linux/nvme.h | 22 +++++++++ 11 files changed, 266 insertions(+), 11 deletions(-) create mode 100644 drivers/nvme/target/io-cmd-cancel.c
Signature · 1 line
2.43.5
RFC PATCH v2 1/7 nvme: add definitions for cancel command
From: John Meneghini <[email protected]>
Add new definitions needed to support TP4097a.
--- drivers/nvme/host/constants.c | 1 + drivers/nvme/host/core.c | 1 + include/linux/nvme.h | 22 ++++++++++++++++++++++ 3 files changed, 24 insertions(+)
drivers/nvme/host/constants.c +1 -0
@@ -19,6 +19,7 @@ static const char * const nvme_ops[] = { [nvme_cmd_resv_report] = "Reservation Report", [nvme_cmd_resv_acquire] = "Reservation Acquire", [nvme_cmd_resv_release] = "Reservation Release", + [nvme_cmd_cancel] = "Cancel", [nvme_cmd_zone_mgmt_send] = "Zone Management Send", [nvme_cmd_zone_mgmt_recv] = "Zone Management Receive", [nvme_cmd_zone_append] = "Zone Append",
drivers/nvme/host/core.c +1 -0
@@ -4964,6 +4964,7 @@ static inline void _nvme_check_size(void)BUILD_BUG_ON (sizeof (struct nvme_dsm_cmd ) !=64 );BUILD_BUG_ON (sizeof (struct nvme_write_zeroes_cmd ) !=64 );BUILD_BUG_ON (sizeof (struct nvme_abort_cmd ) !=64 ); +BUILD_BUG_ON (sizeof (struct nvme_cancel_cmd ) !=64 );BUILD_BUG_ON (sizeof (struct nvme_get_log_page_command ) !=64 );BUILD_BUG_ON (sizeof (struct nvme_command ) !=64 );BUILD_BUG_ON (sizeof (struct nvme_id_ctrl ) !=NVME_IDENTIFY_DATA_SIZE );
include/linux/nvme.h +22 -0
@@ -28,6 +28,9 @@/* Special NSSR value, 'NVMe' */ #define NVME_SUBSYS_RESET 0x4E564D65 +/* Maximum number of reserved commands for Cancel */ +#define NVME_RSV_CANCEL_MAX 2 +enum nvme_subsys_type {/* Referral to another discovery type target subsystem */ NVME_NQN_DISC =1 ,
@@ -844,6 +847,7 @@ enum nvme_opcode { nvme_cmd_resv_report =0x0e , nvme_cmd_resv_acquire =0x11 , nvme_cmd_resv_release =0x15 , + nvme_cmd_cancel =0x18 , nvme_cmd_zone_mgmt_send =0x79 , nvme_cmd_zone_mgmt_recv =0x7a , nvme_cmd_zone_append = 0x7d,
@@ -1357,6 +1361,22 @@ struct nvme_abort_cmd {__u32 rsvd11[5 ]; }; +struct nvme_cancel_cmd { +__u8 opcode; +__u8 flags; +__u16 command_id; +__le32 nsid; +__u32 rsvd1[8 ]; +__le16 sqid; +__u16 cid; +__u8 action; +__u8 rsvd11[3 ]; +__u32 rsvd12[4 ]; +}; + +#define NVME_CANCEL_ACTION_MUL_CMD 1 +#define NVME_CANCEL_ACTION_SINGLE_CMD 0 +struct nvme_download_firmware {__u8 opcode;__u8 flags;
@@ -1812,6 +1832,7 @@ struct nvme_command {struct nvme_zone_mgmt_send_cmd zms;struct nvme_zone_mgmt_recv_cmd zmr;struct nvme_abort_cmd abort; +struct nvme_cancel_cmd cancel;struct nvme_get_log_page_command get_log_page;struct nvmf_common_command fabrics;struct nvmf_connect_command connect;
@@ -1954,6 +1975,7 @@ enum {NVME_SC_INVALID_PI =0x181 ,NVME_SC_READ_ONLY =0x182 ,NVME_SC_ONCS_NOT_SUPPORTED =0x183 , + NVME_SC_INVALID_CID = 0x184,/* * I/O Command Set Specific - Fabrics commands:
Signature · 1 line
2.43.5
RFC PATCH v2 2/7 nvme-core: function to check if a controller supports a specific I/O cmd
In reply to Maurizio LombardiAdd a function (nvme_io_command_supported()) that checks if a controller supports a specific I/O command.
--- drivers/nvme/host/core.c | 8 ++++++++ drivers/nvme/host/nvme.h | 1 + 2 files changed, 9 insertions(+)
drivers/nvme/host/core.c +8 -0
@@ -1191,6 +1191,14 @@ u32 nvme_command_effects(struct nvme_ctrl *ctrl, struct nvme_ns *ns, u8 opcode) }EXPORT_SYMBOL_NS_GPL (nvme_command_effects,NVME_TARGET_PASSTHRU ); +bool nvme_io_command_supported (struct nvme_ctrl *ctrl,u8 opcode) +{ +u32 effects =le32_to_cpu (ctrl->effects->iocs[opcode]); + +return effects &NVME_CMD_EFFECTS_CSUPP ; +} +EXPORT_SYMBOL_GPL (nvme_io_command_supported); +u32 nvme_passthru_start (struct nvme_ctrl *ctrl,struct nvme_ns *ns,u8 opcode) {u32 effects =nvme_command_effects (ctrl, ns, opcode);
drivers/nvme/host/nvme.h +1 -0
@@ -1153,6 +1153,7 @@ static inline void nvme_auth_free(struct nvme_ctrl *ctrl) {};u32 nvme_command_effects (struct nvme_ctrl *ctrl,struct nvme_ns *ns,u8 opcode); +bool nvme_io_command_supported (struct nvme_ctrl *ctrl,u8 opcode);u32 nvme_passthru_start (struct nvme_ctrl *ctrl,struct nvme_ns *ns,u8 opcode);int nvme_execute_rq (struct request *rq,bool at_head); void nvme_passthru_end(struct nvme_ctrl *ctrl, struct nvme_ns *ns, u32 effects,
Signature · 1 line
2.43.5
RFC PATCH v2 3/7 nvme-core: reserve tags for cancel commands
In reply to Maurizio LombardiIf the controller supports cancel commands, reserve NVME_RSV_CANCEL_MAX tags for them.
--- drivers/nvme/host/core.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/nvme/host/core.c +6 -1
@@ -4569,9 +4569,14 @@ int nvme_alloc_io_tag_set(struct nvme_ctrl *ctrl, struct blk_mq_tag_set *set,*/ if (ctrl->quirks &NVME_QUIRK_SHARED_TAGS ) set->reserved_tags =NVME_AQ_DEPTH ; -else if (ctrl->ops->flags &NVME_F_FABRICS ) +else if (ctrl->ops->flags &NVME_F_FABRICS ) {/* Reserved for fabric connect */ set->reserved_tags =1 ; +if (nvme_io_command_supported (ctrl, nvme_cmd_cancel)) { +/* Reserved for cancel commands */ + set->reserved_tags +=NVME_RSV_CANCEL_MAX ; + } + } set->numa_node = ctrl->numa_node; set->flags =BLK_MQ_F_SHOULD_MERGE ;if (ctrl->ops->flags &NVME_F_BLOCKING )
Signature · 1 line
2.43.5
RFC PATCH v2 4/7 nvme-core: add a function to submit a cancel command
In reply to Maurizio LombardiAdd a function to send a cancel command to abort the specified request. When the cancel command completes, the host driver will print the number of deferred and immediate aborts performed by the target.
--- drivers/nvme/host/core.c | 61 ++++++++++++++++++++++++++++++++++++++++ drivers/nvme/host/nvme.h | 2 ++ 2 files changed, 63 insertions(+)
drivers/nvme/host/core.c +61 -0
@@ -3069,6 +3069,67 @@ int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, u8 csi,return nvme_submit_sync_cmd (ctrl->admin_q, &c, log, size); } +static enum rq_end_io_ret nvme_cancel_endio (struct request *req,blk_status_t error) +{ +struct nvme_ctrl *ctrl = req->end_io_data; +u32 result; +u16 imm_abrts, def_abrts; +u16 status =nvme_req (req)->status; + +if (!status) { + result =le32_to_cpu (nvme_req (req)->result.u32); + def_abrts =upper_16_bits (result); + imm_abrts =lower_16_bits (result); + +dev_warn (ctrl->device, +"Cancel status: 0x0 imm abrts = %u def abrts = %u" , + imm_abrts, def_abrts); + }else { +dev_warn (ctrl->device,"Cancel status: 0x%x" , status); + } + +blk_mq_free_request (req); +return RQ_END_IO_NONE ; +} + +int nvme_submit_cancel_req (struct nvme_ctrl *ctrl,struct request *rq, +unsigned int sqid,int action) +{ +struct nvme_command c = { }; +struct request *cancel_req; + +if (sqid ==0 ) +return -EINVAL ; + + c.cancel.opcode = nvme_cmd_cancel; + c.cancel.sqid =cpu_to_le32 (sqid); + c.cancel.nsid =NVME_NSID_ALL ; + c.cancel.action = action; +if (action ==NVME_CANCEL_ACTION_SINGLE_CMD ) + c.cancel.cid =nvme_cid (rq); +else + c.cancel.cid =0xFFFF ; + + cancel_req =blk_mq_alloc_request_hctx (rq->q,nvme_req_op (&c), +BLK_MQ_REQ_NOWAIT | +BLK_MQ_REQ_RESERVED , + sqid -1 ); +if (IS_ERR (cancel_req)) { +dev_warn (ctrl->device,"%s: Could not allocate the Cancel " +"command" , __func__); +return PTR_ERR (cancel_req); + } + +nvme_init_request (cancel_req, &c); + cancel_req->end_io = nvme_cancel_endio; + cancel_req->end_io_data = ctrl; + +blk_execute_rq_nowait (cancel_req, false); + +return 0 ; +} +EXPORT_SYMBOL_GPL (nvme_submit_cancel_req); +static int nvme_get_effects_log (struct nvme_ctrl *ctrl,u8 csi,struct nvme_effects_log **log) {
drivers/nvme/host/nvme.h +2 -0
@@ -895,6 +895,8 @@ int nvme_delete_ctrl(struct nvme_ctrl *ctrl);void nvme_queue_scan (struct nvme_ctrl *ctrl);int nvme_get_log (struct nvme_ctrl *ctrl,u32 nsid,u8 log_page,u8 lsp,u8 csi,void *log,size_t size,u64 offset); +int nvme_submit_cancel_req (struct nvme_ctrl *ctrl,struct request *rq, +unsigned int sqid,int action);bool nvme_tryget_ns_head (struct nvme_ns_head *head);void nvme_put_ns_head (struct nvme_ns_head *head); int nvme_cdev_add(struct cdev *cdev, struct device *cdev_device,
Signature · 1 line
2.43.5
RFC PATCH v2 5/7 nvme-tcp: use the cancel command to perform an abort if target supports it
In reply to Maurizio LombardiIf available, use Cancel command to abort the command that timed out instead of resetting the controller.
Limit the number of outstanding cancel commands
to MAX_RSV_CANCEL_MAX per queue;
If the number of reserved commands runs low, the driver will use a Cancel command with action flag set to "Multiple commands" to abort all the commands on the specified queue as a last resort to avoid a controller reset.
If the cancel command is not supported, if any error is encountered or if the pool of reserved commands is exhausted,
the driver will fall back to the normal controller reset.
--- drivers/nvme/host/tcp.c | 58 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 53 insertions(+), 5 deletions(-)
drivers/nvme/host/tcp.c +53 -5
@@ -121,6 +121,7 @@ struct nvme_tcp_request {size_t offset;size_t data_sent;enum nvme_tcp_send_state state; +bool aborted; };enum nvme_tcp_queue_flags {
@@ -172,6 +173,7 @@ struct nvme_tcp_queue {struct completion tls_complete;int tls_err;struct page_frag_cache pf_cache; +atomic_t cancel_free_cmds;void (*state_change)(struct sock *);void (*data_ready)(struct sock *);
@@ -202,6 +204,7 @@ static struct workqueue_struct *nvme_tcp_wq;static const struct blk_mq_ops nvme_tcp_mq_ops;static const struct blk_mq_ops nvme_tcp_admin_mq_ops;static int nvme_tcp_try_send (struct nvme_tcp_queue *queue); +static void nvme_tcp_complete_rq (struct request *rq);static inline struct nvme_tcp_ctrl *to_tcp_ctrl (struct nvme_ctrl *ctrl) {
@@ -600,7 +603,7 @@ static int nvme_tcp_process_nvme_cqe(struct nvme_tcp_queue *queue, req->status = cqe->status;if (!nvme_try_complete_req (rq, req->status, cqe->result)) -nvme_complete_rq (rq); +nvme_tcp_complete_rq (rq); queue->nr_cqe++;return 0 ;
@@ -800,7 +803,7 @@ static inline void nvme_tcp_end_request(struct request *rq, u16 status)union nvme_result res = {};if (!nvme_try_complete_req (rq,cpu_to_le16 (status <<1 ), res)) -nvme_complete_rq (rq); +nvme_tcp_complete_rq (rq); } static int nvme_tcp_recv_data(struct nvme_tcp_queue *queue, struct sk_buff *skb,
@@ -1658,6 +1661,8 @@ static int nvme_tcp_alloc_queue(struct nvme_ctrl *nctrl, int qid,mutex_init (&queue->send_mutex);INIT_WORK (&queue->io_work, nvme_tcp_io_work); +atomic_set (&queue->cancel_free_cmds,NVME_RSV_CANCEL_MAX ); +if (qid >0 ) queue->cmnd_capsule_len = nctrl->ioccsz *16 ;else
@@ -2444,10 +2449,13 @@ static void nvme_tcp_complete_timed_out(struct request *rq)static enum blk_eh_timer_return nvme_tcp_timeout (struct request *rq) {struct nvme_tcp_request *req =blk_mq_rq_to_pdu (rq); -struct nvme_ctrl *ctrl = &req->queue->ctrl->ctrl;struct nvme_tcp_cmd_pdu *pdu =nvme_tcp_req_cmd_pdu (req);struct nvme_command *cmd = &pdu->cmd; -int qid =nvme_tcp_queue_id (req->queue); +struct nvme_tcp_queue *queue = req->queue; +struct nvme_ctrl *ctrl = &queue->ctrl->ctrl; +int qid =nvme_tcp_queue_id (queue); +int error, action; +int cancel_free_cmds; dev_warn(ctrl->device, "I/O tag %d (%04x) type %d opcode %#x (%s) QID %d timeout\n",
@@ -2472,10 +2480,34 @@ static enum blk_eh_timer_return nvme_tcp_timeout(struct request *rq)return BLK_EH_DONE ; } +if (!req->aborted) { +if (!nvme_io_command_supported (ctrl, nvme_cmd_cancel)) + goto err_recovery; + + cancel_free_cmds =atomic_dec_return (&queue->cancel_free_cmds); +if (cancel_free_cmds <0 ) { +/* No free reserved commands */ + goto err_recovery; + } + +if (cancel_free_cmds >0 ) + action =NVME_CANCEL_ACTION_SINGLE_CMD ; +else + action =NVME_CANCEL_ACTION_MUL_CMD ; + + error =nvme_submit_cancel_req (ctrl, rq, qid, action); +if (error) + goto err_recovery; + + req->aborted = true; +return BLK_EH_RESET_TIMER ; + } +/* * LIVE state should trigger the normal error recovery which will * handle completing this request. */ +err_recovery:nvme_tcp_error_recovery (ctrl);return BLK_EH_RESET_TIMER ; }
@@ -2520,6 +2552,7 @@ static blk_status_t nvme_tcp_setup_cmd_pdu(struct nvme_ns *ns, req->pdu_len =0 ; req->pdu_sent =0 ; req->h2cdata_left =0 ; + req->aborted = false; req->data_len =blk_rq_nr_phys_segments (rq) ?blk_rq_payload_bytes (rq) :0 ; req->curr_bio = rq->bio;
@@ -2634,10 +2667,25 @@ static int nvme_tcp_get_address(struct nvme_ctrl *ctrl, char *buf, int size)return len; } +static void nvme_tcp_complete_rq (struct request *rq) +{ +struct nvme_tcp_request *req =blk_mq_rq_to_pdu (rq); +struct nvme_tcp_queue *queue = req->queue; +struct nvme_command *cmd = req->req.cmd; +int c; + +if (cmd && cmd->common.opcode == nvme_cmd_cancel) { + c =atomic_inc_return (&queue->cancel_free_cmds); +WARN_ON_ONCE (c >NVME_RSV_CANCEL_MAX ); + } + +nvme_complete_rq (rq); +} +static const struct blk_mq_ops nvme_tcp_mq_ops = { .queue_rq = nvme_tcp_queue_rq, .commit_rqs = nvme_tcp_commit_rqs, - .complete = nvme_complete_rq, + .complete = nvme_tcp_complete_rq, .init_request = nvme_tcp_init_request, .exit_request = nvme_tcp_exit_request, .init_hctx = nvme_tcp_init_hctx,
Signature · 1 line
2.43.5
RFC PATCH v2 6/7 nvme-rdma: use the cancel command to perform an abort if target supports it
In reply to Maurizio LombardiIf available, use Cancel command to abort the command that timed out instead of resetting the controller.
Limit the number of outstanding cancel commands
to MAX_RSV_CANCEL_MAX per queue;
If the number of reserved commands runs low, the driver will use a Cancel command with action flag set to "Multiple commands" to abort all the commands on the specified queue as a last resort to avoid a controller reset.
If the cancel command is not supported, if any error is encountered or if the pool of reserved commands is exhausted,
the driver will fall back to the normal controller reset.
--- drivers/nvme/host/rdma.c | 43 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 4 deletions(-)
drivers/nvme/host/rdma.c +39 -4
@@ -74,6 +74,7 @@ struct nvme_rdma_request {struct nvme_rdma_sgl data_sgl;struct nvme_rdma_sgl *metadata_sgl;bool use_sig_mr; +bool aborted; };enum nvme_rdma_queue_flags {
@@ -97,6 +98,7 @@ struct nvme_rdma_queue {struct completion cm_done;bool pi_support;int cq_size; +atomic_t cancel_free_cmds;struct mutex queue_lock; };
@@ -575,6 +577,7 @@ static int nvme_rdma_alloc_queue(struct nvme_rdma_ctrl *ctrl, queue = &ctrl->queues[idx];mutex_init (&queue->queue_lock); +atomic_set (&queue->cancel_free_cmds,NVME_RSV_CANCEL_MAX ); queue->ctrl = ctrl;if (idx && ctrl->ctrl.max_integrity_segments) queue->pi_support = true;
@@ -1959,16 +1962,19 @@ static enum blk_eh_timer_return nvme_rdma_timeout(struct request *rq) {struct nvme_rdma_request *req =blk_mq_rq_to_pdu (rq);struct nvme_rdma_queue *queue = req->queue; -struct nvme_rdma_ctrl *ctrl = queue->ctrl; +struct nvme_rdma_ctrl *rdma_ctrl = queue->ctrl; +struct nvme_ctrl *ctrl = &rdma_ctrl->ctrl;struct nvme_command *cmd = req->req.cmd;int qid =nvme_rdma_queue_idx (queue); +int error, action; +int cancel_free_cmds; -dev_warn (ctrl->ctrl.device, +dev_warn (ctrl->device,"I/O tag %d (%04x) opcode %#x (%s) QID %d timeout\n" , rq->tag,nvme_cid (rq), cmd->common.opcode,nvme_fabrics_opcode_str (qid, cmd), qid); -if (nvme_ctrl_state (&ctrl->ctrl) !=NVME_CTRL_LIVE ) { +if (nvme_ctrl_state (ctrl) !=NVME_CTRL_LIVE ) {/* * If we are resetting, connecting or deleting we should * complete immediately because we may block controller
@@ -1986,11 +1992,33 @@ static enum blk_eh_timer_return nvme_rdma_timeout(struct request *rq)return BLK_EH_DONE ; } +if (!req->aborted) { +if (!nvme_io_command_supported (ctrl, nvme_cmd_cancel)) + goto err_recovery; + + cancel_free_cmds =atomic_dec_return (&queue->cancel_free_cmds); +if (cancel_free_cmds <0 ) + goto err_recovery; + +if (cancel_free_cmds >0 ) + action =NVME_CANCEL_ACTION_SINGLE_CMD ; +else + action =NVME_CANCEL_ACTION_MUL_CMD ; + + error =nvme_submit_cancel_req (ctrl, rq, qid, action); +if (error) + goto err_recovery; + + req->aborted = true; +return BLK_EH_RESET_TIMER ; + } +/* * LIVE state should trigger the normal error recovery which will * handle completing this request. */ -nvme_rdma_error_recovery (ctrl); +err_recovery: +nvme_rdma_error_recovery (rdma_ctrl);return BLK_EH_RESET_TIMER ; }
@@ -2014,6 +2042,7 @@ static blk_status_t nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,return nvme_fail_nonready_command (&queue->ctrl->ctrl, rq); dev = queue->device->dev; + req->aborted = false; req->sqe.dma = ib_dma_map_single(dev, req->sqe.data, sizeof(struct nvme_command),
@@ -2118,6 +2147,8 @@ static void nvme_rdma_complete_rq(struct request *rq)struct nvme_rdma_request *req =blk_mq_rq_to_pdu (rq);struct nvme_rdma_queue *queue = req->queue;struct ib_device *ibdev = queue->device->dev; +struct nvme_command *cmd = req->req.cmd; +int c;if (req->use_sig_mr)nvme_rdma_check_pi_status (req);
@@ -2125,6 +2156,10 @@ static void nvme_rdma_complete_rq(struct request *rq)nvme_rdma_unmap_data (queue, rq);ib_dma_unmap_single (ibdev, req->sqe.dma,sizeof (struct nvme_command ),DMA_TO_DEVICE ); +if (cmd && cmd->common.opcode == nvme_cmd_cancel) { + c =atomic_inc_return (&queue->cancel_free_cmds); +WARN_ON_ONCE (c >NVME_RSV_CANCEL_MAX ); + }nvme_complete_rq (rq); }
Signature · 1 line
2.43.5
RFC PATCH v2 7/7 nvmet: emulate basic support for cancel commands
In reply to Maurizio LombardiAdd a module parameter that allows the user to enable a basic cancel command emulation, this could be useful for testing the host driver's cancel command implementation.
It just reports that no abort has been executed, it will however do some basic sanity check on the command sent by the host and return an error if the fields are invalid.
--- drivers/nvme/target/Makefile | 2 +- drivers/nvme/target/admin-cmd.c | 4 +++ drivers/nvme/target/core.c | 11 ++++++ drivers/nvme/target/io-cmd-cancel.c | 52 +++++++++++++++++++++++++++++ drivers/nvme/target/nvmet.h | 4 +++ 5 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 drivers/nvme/target/io-cmd-cancel.c
drivers/nvme/target/Makefile +1 -1
@@ -10,7 +10,7 @@ obj-$(CONFIG_NVME_TARGET_FCLOOP) += nvme-fcloop.o obj-$(CONFIG_NVME_TARGET_TCP) += nvmet-tcp.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 io-cmd-cancel.o nvmet-$(CONFIG_NVME_TARGET_DEBUGFS) += debugfs.o nvmet-$(CONFIG_NVME_TARGET_PASSTHRU) += passthru.o nvmet-$(CONFIG_BLK_DEV_ZONED) += zns.o
drivers/nvme/target/admin-cmd.c +4 -0
@@ -177,6 +177,10 @@ static void nvmet_get_cmd_effects_nvm(struct nvme_effects_log *log) log->iocs[nvme_cmd_flush] = log->iocs[nvme_cmd_dsm] =cpu_to_le32 (NVME_CMD_EFFECTS_CSUPP ); +if (emulate_cancel_support) { + log->iocs[nvme_cmd_cancel] = +cpu_to_le32 (NVME_CMD_EFFECTS_CSUPP ); + } log->iocs[nvme_cmd_write] = log->iocs[nvme_cmd_write_zeroes] =cpu_to_le32 (NVME_CMD_EFFECTS_CSUPP |NVME_CMD_EFFECTS_LBCC );
drivers/nvme/target/core.c +11 -0
@@ -27,6 +27,10 @@ static DEFINE_IDA(cntlid_ida);struct workqueue_struct *nvmet_wq;EXPORT_SYMBOL_GPL (nvmet_wq); +bool emulate_cancel_support; +module_param (emulate_cancel_support, bool,0644 ); +MODULE_PARM_DESC (emulate_cancel_support,"Emulate the cancel command support. Default = false" ); +/* * This read/write semaphore is used to synchronize access to configuration * information on a target system that will result in discovery log page
@@ -914,6 +918,13 @@ static u16 nvmet_parse_io_cmd(struct nvmet_req *req)if (nvmet_is_passthru_req (req))return nvmet_parse_passthru_io_cmd (req); +if (emulate_cancel_support && + req->cmd->common.opcode == nvme_cmd_cancel) { + req->execute = nvmet_execute_cancel; +if (req->cmd->cancel.nsid ==NVME_NSID_ALL ) +return 0 ; + } + ret =nvmet_req_find_ns (req);if (unlikely (ret))return ret;
drivers/nvme/target/io-cmd-cancel.c new file +52 -0
52 lines not on this page · raw message
drivers/nvme/target/nvmet.h +4 -0
@@ -31,6 +31,8 @@#define NVMET_SN_MAX_SIZE 20#define NVMET_FR_MAX_SIZE 8 +extern bool emulate_cancel_support; +/* * Supported optional AENs: */
@@ -610,6 +612,8 @@ void nvmet_bdev_execute_zone_mgmt_recv(struct nvmet_req *req);void nvmet_bdev_execute_zone_mgmt_send (struct nvmet_req *req);void nvmet_bdev_execute_zone_append (struct nvmet_req *req); +void nvmet_execute_cancel (struct nvmet_req *req); +static inline u32 nvmet_rw_data_len (struct nvmet_req *req) { return ((u32)le16_to_cpu(req->cmd->rw.length) + 1) <<
Signature · 1 line
2.43.5