Commands of a target_core_uring device wait on a pending list until a server fetches them, and then for the server to commit them. Without a server, or with one that hangs, they wait forever, and so does everything that waits for them, such as removing the LUN. Add the cmd_time_out parameter, 30 seconds by default, and fail the commands that are older. A delayed work scans the queues when the oldest command is due. A timed out command that the server works on is completed, but the server keeps the tag until it commits it. Signed-off-by: Qiliang Yuan --- drivers/target/target_core_uring.c | 80 +++++++++++++++++++++++++++++++++++++- 1 file changed, 78 insertions(+), 2 deletions(-) diff --git a/drivers/target/target_core_uring.c b/drivers/target/target_core_uring.c index 2978dd08c99cf..0f83bdc55e06a 100644 --- a/drivers/target/target_core_uring.c +++ b/drivers/target/target_core_uring.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -31,6 +32,7 @@ #define TCMUR_MAX_IO_SIZE (4U << 20) #define TCMUR_DEF_QUEUE_DEPTH 128 #define TCMUR_DEF_BLOCK_SIZE 512 +#define TCMUR_DEF_CMD_TIMEOUT 30 /* Set while the file is open, to allow one server at a time */ #define TCMUR_DEV_OPEN 0 @@ -46,6 +48,7 @@ struct tcmur_dev; * @desc: What the server is asked to do * @ref: Held by the tag or the pending list and by data copies in * progress + * @deadline: When to give up waiting for the server * @status: SAM status to complete @se_cmd with */ struct tcmur_cmd { @@ -55,6 +58,7 @@ struct tcmur_cmd { u32 sgl_nents; struct tcmur_io_desc desc; refcount_t ref; + unsigned long deadline; u8 status; }; @@ -102,8 +106,10 @@ struct tcmur_dev { u32 block_size; u16 nr_queues; u16 queue_depth; + unsigned int cmd_timeout; struct tcmur_queue *queues; + struct delayed_work timeout_work; }; /** @@ -190,6 +196,8 @@ static void tcmur_queue_cmd(struct tcmur_dev *udev, struct tcmur_cmd *tcmd) struct tcmur_io *io; refcount_set(&tcmd->ref, 1); + if (udev->cmd_timeout) + tcmd->deadline = jiffies + udev->cmd_timeout * HZ; spin_lock(&q->lock); io = list_first_entry_or_null(&q->idle, struct tcmur_io, node); @@ -205,6 +213,9 @@ static void tcmur_queue_cmd(struct tcmur_dev *udev, struct tcmur_cmd *tcmd) if (ucmd) io_uring_cmd_complete_in_task(ucmd, tcmur_fetch_tw_cb); + if (udev->cmd_timeout) + schedule_delayed_work(&udev->timeout_work, + udev->cmd_timeout * HZ); } static sense_reason_t tcmur_submit(struct se_cmd *se_cmd, u32 op, u64 offset, @@ -244,6 +255,58 @@ static sense_reason_t tcmur_execute_rw(struct se_cmd *se_cmd, se_cmd->data_length, sgl, sgl_nents); } +static void tcmur_timeout_work(struct work_struct *work) +{ + struct tcmur_dev *udev = container_of(work, struct tcmur_dev, + timeout_work.work); + unsigned long now = jiffies, next = 0; + struct tcmur_cmd *tcmd, *tmp; + struct tcmur_queue *q; + struct tcmur_io *io; + bool rearm = false; + LIST_HEAD(expired); + unsigned int i, j; + + for (i = 0; i < udev->nr_queues; i++) { + q = &udev->queues[i]; + + spin_lock(&q->lock); + list_for_each_entry_safe(tcmd, tmp, &q->pending, node) { + if (time_after(tcmd->deadline, now)) { + if (!rearm || time_before(tcmd->deadline, next)) + next = tcmd->deadline; + rearm = true; + break; + } + list_move_tail(&tcmd->node, &expired); + } + for (j = 0; j < udev->queue_depth; j++) { + io = &q->ios[j]; + tcmd = io->cmd; + if (!tcmd) + continue; + if (time_after(tcmd->deadline, now)) { + if (!rearm || time_before(tcmd->deadline, next)) + next = tcmd->deadline; + rearm = true; + continue; + } + /* Leave the tag to the server until it commits it */ + io->cmd = NULL; + list_add_tail(&tcmd->node, &expired); + } + spin_unlock(&q->lock); + } + + if (!list_empty(&expired)) + pr_warn_ratelimited("tcmur%d: command timed out\n", + udev->dev_id); + tcmur_end_cmds(&expired, SAM_STAT_CHECK_CONDITION); + + if (rearm) + schedule_delayed_work(&udev->timeout_work, next - now); +} + /* Take a reference on the command the server works on in (@q_id, @tag) */ static struct tcmur_cmd *tcmur_get_cmd(struct tcmur_dev *udev, u16 q_id, u16 tag) @@ -331,7 +394,10 @@ static int tcmur_commit(struct tcmur_queue *q, struct tcmur_io *io, int result) io->owned = false; spin_unlock(&q->lock); - tcmur_cmd_end(tcmd, result ? SAM_STAT_CHECK_CONDITION : SAM_STAT_GOOD); + /* Skip a command that timed out already */ + if (tcmd) + tcmur_cmd_end(tcmd, result ? SAM_STAT_CHECK_CONDITION : + SAM_STAT_GOOD); return 0; } @@ -639,6 +705,8 @@ static struct se_device *tcmur_alloc_device(struct se_hba *hba, udev->nr_queues = 1; udev->queue_depth = TCMUR_DEF_QUEUE_DEPTH; udev->block_size = TCMUR_DEF_BLOCK_SIZE; + udev->cmd_timeout = TCMUR_DEF_CMD_TIMEOUT; + INIT_DELAYED_WORK(&udev->timeout_work, tcmur_timeout_work); device_initialize(&udev->cdev_dev); udev->cdev_dev.class = &tcmur_class; @@ -723,6 +791,8 @@ static void tcmur_destroy_device(struct se_device *dev) } spin_unlock(&q->lock); } + + cancel_delayed_work_sync(&udev->timeout_work); } static void tcmur_free_device(struct se_device *dev) @@ -731,7 +801,8 @@ static void tcmur_free_device(struct se_device *dev) } enum { - Opt_dev_size, Opt_block_size, Opt_nr_queues, Opt_queue_depth, Opt_err, + Opt_dev_size, Opt_block_size, Opt_nr_queues, Opt_queue_depth, + Opt_cmd_time_out, Opt_err, }; static const match_table_t tcmur_tokens = { @@ -739,6 +810,7 @@ static const match_table_t tcmur_tokens = { { Opt_block_size, "block_size=%u" }, { Opt_nr_queues, "nr_queues=%u" }, { Opt_queue_depth, "queue_depth=%u" }, + { Opt_cmd_time_out, "cmd_time_out=%u" }, { Opt_err, NULL } }; @@ -794,6 +866,9 @@ static ssize_t tcmur_set_configfs_dev_params(struct se_device *dev, else udev->queue_depth = val; break; + case Opt_cmd_time_out: + udev->cmd_timeout = val; + break; } } @@ -812,6 +887,7 @@ static ssize_t tcmur_show_configfs_dev_params(struct se_device *dev, char *b) udev->block_size); bl += sprintf(b + bl, " Queues: %u Queue depth: %u", udev->nr_queues, udev->queue_depth); + bl += sprintf(b + bl, " Command timeout: %u", udev->cmd_timeout); bl += sprintf(b + bl, "\n"); return bl; } -- 2.43.0