scsi: core: Introduce .queue_reserved_command()

Reserved commands will be used by SCSI LLDs for submitting internal
commands. Since the SCSI host, target and device limits do not apply to
the reserved command use cases, bypass the SCSI host limit checks for
reserved commands. Introduce the .queue_reserved_command() callback for
reserved commands. Additionally, do not activate the SCSI error handler
if a reserved command fails such that reserved commands can be submitted
from inside the SCSI error handler.

[ bvanassche: modified patch title and patch description. Renamed
  .reserved_queuecommand() into .queue_reserved_command(). Changed
  the second argument of __blk_mq_end_request() from 0 into error
  code in the completion path if cmd->result != 0. Rewrote the
  scsi_queue_rq() changes. See also
  https://lore.kernel.org/linux-scsi/1666693096-180008-5-git-send-email-john.garry@huawei.com/ ]

Cc: Hannes Reinecke <hare@suse.de>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Link: https://patch.msgid.link/20251031204029.2883185-6-bvanassche@acm.org
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index ad1476fb50356d312401c54adb94f96fcb64c430..e047747d4ecf8163c939be3f5d43f370204c236e 100644 (file)
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -231,6 +231,12 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
                goto fail;
        }
 
+       if (shost->nr_reserved_cmds && !sht->queue_reserved_command) {
+               shost_printk(KERN_ERR, shost,
+                            "nr_reserved_cmds set but no method to queue\n");
+               goto fail;
+       }
+
        /* Use min_t(int, ...) in case shost->can_queue exceeds SHRT_MAX */
        shost->cmd_per_lun = min_t(int, shost->cmd_per_lun,
                                   shost->can_queue);

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 53ff348b3a4c0afcfc58af520c9f40c8fb162b72..d4e874bbf2ea0371017789e76bec1c1dec0b48e3 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1534,6 +1534,14 @@ static void scsi_complete(struct request *rq)
        struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
        enum scsi_disposition disposition;
 
+       if (blk_mq_is_reserved_rq(rq)) {
+               /* Only pass-through requests are supported in this code path. */
+               WARN_ON_ONCE(!blk_rq_is_passthrough(scsi_cmd_to_rq(cmd)));
+               scsi_mq_uninit_cmd(cmd);
+               __blk_mq_end_request(rq, scsi_result_to_blk_status(cmd->result));
+               return;
+       }
+
        INIT_LIST_HEAD(&cmd->eh_entry);
 
        atomic_inc(&cmd->device->iodone_cnt);
@@ -1823,25 +1831,31 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
        WARN_ON_ONCE(cmd->budget_token < 0);
 
        /*
-        * If the device is not in running state we will reject some or all
-        * commands.
+        * Bypass the SCSI device, SCSI target and SCSI host checks for
+        * reserved commands.
         */
-       if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
-               ret = scsi_device_state_check(sdev, req);
-               if (ret != BLK_STS_OK)
-                       goto out_put_budget;
-       }
+       if (!blk_mq_is_reserved_rq(req)) {
+               /*
+                * If the device is not in running state we will reject some or
+                * all commands.
+                */
+               if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
+                       ret = scsi_device_state_check(sdev, req);
+                       if (ret != BLK_STS_OK)
+                               goto out_put_budget;
+               }
 
-       ret = BLK_STS_RESOURCE;
-       if (!scsi_target_queue_ready(shost, sdev))
-               goto out_put_budget;
-       if (unlikely(scsi_host_in_recovery(shost))) {
-               if (cmd->flags & SCMD_FAIL_IF_RECOVERING)
-                       ret = BLK_STS_OFFLINE;
-               goto out_dec_target_busy;
+               ret = BLK_STS_RESOURCE;
+               if (!scsi_target_queue_ready(shost, sdev))
+                       goto out_put_budget;
+               if (unlikely(scsi_host_in_recovery(shost))) {
+                       if (cmd->flags & SCMD_FAIL_IF_RECOVERING)
+                               ret = BLK_STS_OFFLINE;
+                       goto out_dec_target_busy;
+               }
+               if (!scsi_host_queue_ready(q, shost, sdev, cmd))
+                       goto out_dec_target_busy;
        }
-       if (!scsi_host_queue_ready(q, shost, sdev, cmd))
-               goto out_dec_target_busy;
 
        /*
         * Only clear the driver-private command data if the LLD does not supply
@@ -1870,6 +1884,14 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
        cmd->submitter = SUBMITTED_BY_BLOCK_LAYER;
 
        blk_mq_start_request(req);
+       if (blk_mq_is_reserved_rq(req)) {
+               reason = shost->hostt->queue_reserved_command(shost, cmd);
+               if (reason) {
+                       ret = BLK_STS_RESOURCE;
+                       goto out_put_budget;
+               }
+               return BLK_STS_OK;
+       }
        reason = scsi_dispatch_cmd(cmd);
        if (reason) {
                scsi_set_blocked(cmd, reason);

diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 4f945a20d19854f7193380c85265834b71b8a101..e87cf7eadd268d51019635ac1404b64ed400b508 100644 (file)
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -86,6 +86,12 @@ struct scsi_host_template {
         */
        int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
 
+       /*
+        * Queue a reserved command (BLK_MQ_REQ_RESERVED). The .queuecommand()
+        * documentation also applies to the .queue_reserved_command() callback.
+        */
+       int (*queue_reserved_command)(struct Scsi_Host *, struct scsi_cmnd *);
+
        /*
         * The commit_rqs function is used to trigger a hardware
         * doorbell after some requests have been queued with