Merge tag 'for-5.16/block-2021-11-09' of git://git.kernel.dk/linux-block

[linux-2.6-microblaze.git] / drivers / scsi / scsi_lib.c

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 1344553..b731c29 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -2665,6 +2665,40 @@ scsi_target_resume(struct scsi_target *starget)
 }
 EXPORT_SYMBOL(scsi_target_resume);
 
+static int __scsi_internal_device_block_nowait(struct scsi_device *sdev)
+{
+       if (scsi_device_set_state(sdev, SDEV_BLOCK))
+               return scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);
+
+       return 0;
+}
+
+void scsi_start_queue(struct scsi_device *sdev)
+{
+       if (cmpxchg(&sdev->queue_stopped, 1, 0))
+               blk_mq_unquiesce_queue(sdev->request_queue);
+}
+
+static void scsi_stop_queue(struct scsi_device *sdev, bool nowait)
+{
+       /*
+        * The atomic variable of ->queue_stopped covers that
+        * blk_mq_quiesce_queue* is balanced with blk_mq_unquiesce_queue.
+        *
+        * However, we still need to wait until quiesce is done
+        * in case that queue has been stopped.
+        */
+       if (!cmpxchg(&sdev->queue_stopped, 0, 1)) {
+               if (nowait)
+                       blk_mq_quiesce_queue_nowait(sdev->request_queue);
+               else
+                       blk_mq_quiesce_queue(sdev->request_queue);
+       } else {
+               if (!nowait)
+                       blk_mq_wait_quiesce_done(sdev->request_queue);
+       }
+}
+
 /**
  * scsi_internal_device_block_nowait - try to transition to the SDEV_BLOCK state
  * @sdev: device to block
@@ -2681,24 +2715,16 @@ EXPORT_SYMBOL(scsi_target_resume);
  */
 int scsi_internal_device_block_nowait(struct scsi_device *sdev)
 {
-       struct request_queue *q = sdev->request_queue;
-       int err = 0;
-
-       err = scsi_device_set_state(sdev, SDEV_BLOCK);
-       if (err) {
-               err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);
-
-               if (err)
-                       return err;
-       }
+       int ret = __scsi_internal_device_block_nowait(sdev);
 
        /*
         * The device has transitioned to SDEV_BLOCK.  Stop the
         * block layer from calling the midlayer with this device's
         * request queue.
         */
-       blk_mq_quiesce_queue_nowait(q);
-       return 0;
+       if (!ret)
+               scsi_stop_queue(sdev, true);
+       return ret;
 }
 EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait);
 
@@ -2719,25 +2745,17 @@ EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait);
  */
 static int scsi_internal_device_block(struct scsi_device *sdev)
 {
-       struct request_queue *q = sdev->request_queue;
        int err;
 
        mutex_lock(&sdev->state_mutex);
-       err = scsi_internal_device_block_nowait(sdev);
+       err = __scsi_internal_device_block_nowait(sdev);
        if (err == 0)
-               blk_mq_quiesce_queue(q);
+               scsi_stop_queue(sdev, false);
        mutex_unlock(&sdev->state_mutex);
 
        return err;
 }
 
-void scsi_start_queue(struct scsi_device *sdev)
-{
-       struct request_queue *q = sdev->request_queue;
-
-       blk_mq_unquiesce_queue(q);
-}
-
 /**
  * scsi_internal_device_unblock_nowait - resume a device after a block request
  * @sdev:      device to resume