target_core_uring passes reads, writes and flushes to the server. Thin provisioned storage also needs to know which blocks the initiator no longer uses. Add TCMUR_OP_UNMAP and send one for each range of an UNMAP command or of a WRITE SAME with the UNMAP bit. The core expects execute_unmap() to return once the range is unmapped, so queue a struct tcmur_cmd that lives on the stack and wait for the server to commit it. Signed-off-by: Qiliang Yuan --- drivers/target/target_core_uring.c | 39 ++++++++++++++++++++++++++++++++++ include/uapi/linux/target_core_uring.h | 1 + 2 files changed, 40 insertions(+) diff --git a/drivers/target/target_core_uring.c b/drivers/target/target_core_uring.c index f39bf7bf36d0f..366c5e9820956 100644 --- a/drivers/target/target_core_uring.c +++ b/drivers/target/target_core_uring.c @@ -49,6 +49,7 @@ struct tcmur_dev; * @ref: Held by the tag or the pending list and by data copies in * progress * @deadline: When to give up waiting for the server + * @done: Complete this instead of @se_cmd when the last reference goes * @status: SAM status to complete @se_cmd with */ struct tcmur_cmd { @@ -59,6 +60,7 @@ struct tcmur_cmd { struct tcmur_io_desc desc; refcount_t ref; unsigned long deadline; + struct completion *done; u8 status; }; @@ -148,6 +150,11 @@ static void tcmur_cmd_put(struct tcmur_cmd *tcmd) if (!refcount_dec_and_test(&tcmd->ref)) return; + if (tcmd->done) { + complete(tcmd->done); + return; + } + target_complete_cmd(tcmd->se_cmd, tcmd->status); kmem_cache_free(tcmur_cmd_cache, tcmd); } @@ -268,6 +275,36 @@ static sense_reason_t tcmur_execute_sync_cache(struct se_cmd *se_cmd) se_cmd->data_length, NULL, 0); } +static sense_reason_t tcmur_execute_unmap(struct se_cmd *se_cmd, sector_t lba, + sector_t nolb) +{ + u32 block_size = se_cmd->se_dev->dev_attrib.block_size; + DECLARE_COMPLETION_ONSTACK(done); + struct tcmur_cmd tcmd = { + .se_cmd = se_cmd, + .done = &done, + .desc.op = TCMUR_OP_UNMAP, + .desc.offset = lba * block_size, + .desc.len = nolb * block_size, + }; + + /* Wait here, as the core completes the command after all ranges */ + tcmur_queue_cmd(TCMUR_DEV(se_cmd->se_dev), &tcmd); + wait_for_completion(&done); + + return tcmd.status ? TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE : 0; +} + +static bool tcmur_configure_unmap(struct se_device *dev) +{ + dev->dev_attrib.max_unmap_lba_count = UINT_MAX / + dev->dev_attrib.hw_block_size; + dev->dev_attrib.max_unmap_block_desc_count = 1; + dev->dev_attrib.unmap_granularity = 1; + dev->dev_attrib.unmap_granularity_alignment = 0; + return true; +} + static void tcmur_tmr_notify(struct se_device *dev, enum tcm_tmreq_table tmf, struct list_head *aborted_cmds) { @@ -941,6 +978,7 @@ static sector_t tcmur_get_blocks(struct se_device *dev) static struct exec_cmd_ops tcmur_exec_cmd_ops = { .execute_rw = tcmur_execute_rw, .execute_sync_cache = tcmur_execute_sync_cache, + .execute_unmap = tcmur_execute_unmap, }; static sense_reason_t tcmur_parse_cdb(struct se_cmd *se_cmd) @@ -959,6 +997,7 @@ static const struct target_backend_ops tcmur_ops = { .configure_device = tcmur_configure_device, .destroy_device = tcmur_destroy_device, .free_device = tcmur_free_device, + .configure_unmap = tcmur_configure_unmap, .parse_cdb = tcmur_parse_cdb, .tmr_notify = tcmur_tmr_notify, .set_configfs_dev_params = tcmur_set_configfs_dev_params, diff --git a/include/uapi/linux/target_core_uring.h b/include/uapi/linux/target_core_uring.h index a1d8ae47ebf7d..9df10558cfa9e 100644 --- a/include/uapi/linux/target_core_uring.h +++ b/include/uapi/linux/target_core_uring.h @@ -68,6 +68,7 @@ enum tcmur_io_op { TCMUR_OP_READ, TCMUR_OP_WRITE, TCMUR_OP_FLUSH, + TCMUR_OP_UNMAP, }; /* Put the write on stable storage before completing it */ -- 2.43.0