isci: kill "host quiesce" mechanism

The midlayer is already throttling i/o in the places where host_quiesce
was trying to prevent further i/o to the device.  It's also problematic
in that it holds a lock over GFP_KERNEL allocations.

Signed-off-by: Dan Williams <dan.j.williams@intel.com>

4 files changed, 8 insertions, 91 deletions

diff --git a/drivers/scsi/isci/port.h b/drivers/scsi/isci/port.h
index b01b0c63e53f..b864d70363e7 100644
--- a/drivers/scsi/isci/port.h
+++ b/drivers/scsi/isci/port.h
@@ -73,7 +73,6 @@ enum isci_status {
 	isci_ready_for_io = 0x03,
 	isci_stopping     = 0x04,
 	isci_stopped      = 0x05,
-	isci_host_quiesce = 0x06
 };
 
 /**
diff --git a/drivers/scsi/isci/remote_device.c b/drivers/scsi/isci/remote_device.c
index 0eb5c7330fac..fc1f24449170 100644
--- a/drivers/scsi/isci/remote_device.c
+++ b/drivers/scsi/isci/remote_device.c
@@ -267,36 +267,13 @@ isci_remote_device_alloc(struct isci_host *isci_host, struct isci_port *port)
 
 	INIT_LIST_HEAD(&isci_device->reqs_in_process);
 	INIT_LIST_HEAD(&isci_device->node);
-	isci_device->host_quiesce          = false;
 
 	spin_lock_init(&isci_device->state_lock);
-	spin_lock_init(&isci_device->host_quiesce_lock);
 	isci_remote_device_change_state(isci_device, isci_freed);
 
 	return isci_device;
 
 }
-/**
- * isci_device_set_host_quiesce_lock_state() - This function sets the host I/O
- *    quiesce lock state for the remote_device object.
- * @isci_device,: This parameter points to the isci_remote_device object
- * @isci_device: This parameter specifies the new quiesce state.
- *
- */
-void isci_device_set_host_quiesce_lock_state(
-	struct isci_remote_device *isci_device,
-	bool lock_state)
-{
-	unsigned long flags;
-
-	dev_dbg(&isci_device->isci_port->isci_host->pdev->dev,
-		"%s: isci_device=%p, lock_state=%d\n",
-		__func__, isci_device, lock_state);
-
-	spin_lock_irqsave(&isci_device->host_quiesce_lock, flags);
-	isci_device->host_quiesce = lock_state;
-	spin_unlock_irqrestore(&isci_device->host_quiesce_lock, flags);
-}
 
 /**
  * isci_remote_device_ready() - This function is called by the scic when the
@@ -314,8 +291,8 @@ void isci_remote_device_ready(struct isci_remote_device *isci_device)
 		"%s: isci_device = %p\n", __func__, isci_device);
 
 	/* device ready is actually a "ready for io" state. */
-	if ((isci_starting == isci_remote_device_get_state(isci_device)) ||
-	    (isci_ready == isci_remote_device_get_state(isci_device))) {
+	if (isci_device->status == isci_starting ||
+	    isci_device->status == isci_ready) {
 		spin_lock_irqsave(&isci_device->isci_port->remote_device_lock,
 				  flags);
 		isci_remote_device_change_state(isci_device, isci_ready_for_io);
diff --git a/drivers/scsi/isci/remote_device.h b/drivers/scsi/isci/remote_device.h
index cd43c15f009d..af03039c12f1 100644
--- a/drivers/scsi/isci/remote_device.h
+++ b/drivers/scsi/isci/remote_device.h
@@ -68,8 +68,6 @@ struct isci_remote_device {
 	struct list_head reqs_in_process;
 	struct work_struct stop_work;
 	spinlock_t state_lock;
-	spinlock_t host_quiesce_lock;
-	bool host_quiesce;
 };
 
 static inline struct scic_sds_remote_device *to_sci_dev(struct isci_remote_device *idev)
@@ -85,22 +83,6 @@ static inline struct scic_sds_remote_device *to_sci_dev(struct isci_remote_devic
 
 
 /**
- * This function gets the status of the remote_device object.
- * @isci_device: This parameter points to the isci_remote_device object
- *
- * status of the object as a isci_status enum.
- */
-static inline
-enum isci_status isci_remote_device_get_state(
-	struct isci_remote_device *isci_device)
-{
-	return (isci_device->host_quiesce)
-	       ? isci_host_quiesce
-	       : isci_device->status;
-}
-
-
-/**
  * isci_dev_from_domain_dev() - This accessor retrieves the remote_device
  *    object reference from the Linux domain_device reference.
  * @domdev,: This parameter points to the Linux domain_device object .
@@ -146,10 +128,6 @@ bool isci_device_is_reset_pending(
 void isci_device_clear_reset_pending(
 	struct isci_remote_device *isci_device);
 
-void isci_device_set_host_quiesce_lock_state(
-	struct isci_remote_device *isci_device,
-	bool lock_state);
-
 void isci_remote_device_change_state(
 	struct isci_remote_device *isci_device,
 	enum isci_status status);
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index c637bbc215c6..98204b031649 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -81,7 +81,6 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 	struct isci_request *request = NULL;
 	struct isci_remote_device *device;
 	unsigned long flags;
-	unsigned long quiesce_flags = 0;
 	int ret;
 	enum sci_status status;
 
@@ -151,21 +150,7 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 
 		isci_host = isci_host_from_sas_ha(task->dev->port->ha);
 
-		/* check if the controller hasn't started or if the device
-		 * is ready but not accepting IO.
-		 */
-		if (device) {
-
-			spin_lock_irqsave(&device->host_quiesce_lock,
-					  quiesce_flags);
-		}
-		/* From this point onward, any process that needs to guarantee
-		 * that there is no kernel I/O being started will have to wait
-		 * for the quiesce spinlock.
-		 */
-
-		if ((device && ((isci_remote_device_get_state(device) == isci_ready) ||
-		    (isci_remote_device_get_state(device) == isci_host_quiesce)))) {
+		if (device && device->status == isci_ready) {
 
 			/* Forces a retry from scsi mid layer. */
 			dev_warn(task->dev->port->ha->dev,
@@ -179,8 +164,7 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 			if (device)
 				dev_dbg(task->dev->port->ha->dev,
 					"%s: device->status = 0x%x\n",
-					__func__,
-					isci_remote_device_get_state(device));
+					__func__, device->status);
 
 			/* Indicate QUEUE_FULL so that the scsi midlayer
 			 * retries.
@@ -194,7 +178,7 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 			isci_host_can_dequeue(isci_host, 1);
 		}
 		/* the device is going down... */
-		else if (!device || (isci_ready_for_io != isci_remote_device_get_state(device))) {
+		else if (!device || device->status != isci_ready_for_io) {
 
 			dev_dbg(task->dev->port->ha->dev,
 				"%s: task %p: isci_host->status = %d, "
@@ -207,8 +191,7 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 			if (device)
 				dev_dbg(task->dev->port->ha->dev,
 					"%s: device->status = 0x%x\n",
-					__func__,
-					isci_remote_device_get_state(device));
+					__func__, device->status);
 
 			/* Indicate SAS_TASK_UNDELIVERED, so that the scsi
 			 * midlayer removes the target.
@@ -247,11 +230,6 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
 				isci_host_can_dequeue(isci_host, 1);
 			}
 		}
-		if (device) {
-			spin_unlock_irqrestore(&device->host_quiesce_lock,
-					       quiesce_flags
-					       );
-		}
 		task = list_entry(task->list.next, struct sas_task, list);
 	} while (--num > 0);
 	return 0;
@@ -442,14 +420,11 @@ int isci_task_execute_tmf(
 	/* sanity check, return TMF_RESP_FUNC_FAILED
 	 * if the device is not there and ready.
 	 */
-	if (!isci_device ||
-	    ((isci_ready_for_io != isci_remote_device_get_state(isci_device)) &&
-	    (isci_host_quiesce != isci_remote_device_get_state(isci_device)))) {
+	if (!isci_device || isci_device->status != isci_ready_for_io) {
 		dev_dbg(&isci_host->pdev->dev,
 			"%s: isci_device = %p not ready (%d)\n",
 			__func__,
-			isci_device,
-			isci_remote_device_get_state(isci_device));
+			isci_device, isci_device->status);
 		return TMF_RESP_FUNC_FAILED;
 	} else
 		dev_dbg(&isci_host->pdev->dev,
@@ -986,9 +961,6 @@ int isci_task_lu_reset(
 		return TMF_RESP_FUNC_FAILED;
 	}
 
-	/* Stop I/O to the remote device. */
-	isci_device_set_host_quiesce_lock_state(isci_device, true);
-
 	/* Send the task management part of the reset. */
 	if (sas_protocol_ata(domain_device->tproto)) {
 		ret = isci_task_send_lu_reset_sata(
@@ -1004,9 +976,6 @@ int isci_task_lu_reset(
 						isci_device,
 						terminating);
 
-	/* Resume I/O to the remote device. */
-	isci_device_set_host_quiesce_lock_state(isci_device, false);
-
 	return ret;
 }
 
@@ -1627,9 +1596,6 @@ int isci_bus_reset_handler(struct scsi_cmnd *cmd)
 	if (isci_host != NULL)
 		spin_unlock_irqrestore(&isci_host->scic_lock, flags);
 
-	/* Stop I/O to the remote device. */
-	isci_device_set_host_quiesce_lock_state(isci_dev, true);
-
 	/* Make sure all pending requests are able to be fully terminated. */
 	isci_device_clear_reset_pending(isci_dev);
 
@@ -1671,8 +1637,5 @@ int isci_bus_reset_handler(struct scsi_cmnd *cmd)
 		"%s: cmd %p, isci_dev %p complete.\n",
 		__func__, cmd, isci_dev);
 
-	/* Resume I/O to the remote device. */
-	isci_device_set_host_quiesce_lock_state(isci_dev, false);
-
 	return TMF_RESP_FUNC_COMPLETE;
 }