libsas: remove task_collector mode

The task_collector mode (or "latency_injector", (C) Dan Willians) is an
optional I/O path in libsas that queues up scsi commands instead of
directly sending it to the hardware.  It generall increases latencies
to in the optiomal case slightly reduce mmio traffic to the hardware.

Only the obsolete aic94xx driver and the mvsas driver allowed to use
it without recompiling the kernel, and most drivers didn't support it
at all.

Remove the giant blob of code to allow better optimizations for scsi-mq
in the future.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Acked-by: Dan Williams <dan.j.williams@intel.com>

3 files changed, 70 insertions, 80 deletions

diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index a81e546595dd..724c6265b667 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -260,8 +260,6 @@ static int isci_register_sas_ha(struct isci_host *isci_host)
         sas_ha->sas_port = sas_ports;
         sas_ha->num_phys = SCI_MAX_PHYS;
 
-        sas_ha->lldd_queue_size = ISCI_CAN_QUEUE_VAL;
-        sas_ha->lldd_max_execute_num = 1;
         sas_ha->strict_wide_ports = 1;
 
         sas_register_ha(sas_ha);
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index 5d6fda72d659..3f63c6318b0d 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -117,104 +117,97 @@ static inline int isci_device_io_ready(struct isci_remote_device *idev,
  *    functions. This function is called by libsas to send a task down to
  *    hardware.
  * @task: This parameter specifies the SAS task to send.
- * @num: This parameter specifies the number of tasks to queue.
  * @gfp_flags: This parameter specifies the context of this call.
  *
  * status, zero indicates success.
  */
-int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
+int isci_task_execute_task(struct sas_task *task, gfp_t gfp_flags)
 {
         struct isci_host *ihost = dev_to_ihost(task->dev);
         struct isci_remote_device *idev;
         unsigned long flags;
+        enum sci_status status = SCI_FAILURE;
         bool io_ready;
         u16 tag;
 
-        dev_dbg(&ihost->pdev->dev, "%s: num=%d\n", __func__, num);
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        idev = isci_lookup_device(task->dev);
+        io_ready = isci_device_io_ready(idev, task);
+        tag = isci_alloc_tag(ihost);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-        for_each_sas_task(num, task) {
-                enum sci_status status = SCI_FAILURE;
+        dev_dbg(&ihost->pdev->dev,
+                "task: %p, dev: %p idev: %p:%#lx cmd = %p\n",
+                task, task->dev, idev, idev ? idev->flags : 0,
+                task->uldd_task);
 
-                spin_lock_irqsave(&ihost->scic_lock, flags);
-                idev = isci_lookup_device(task->dev);
-                io_ready = isci_device_io_ready(idev, task);
-                tag = isci_alloc_tag(ihost);
-                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        if (!idev) {
+                isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
+                                 SAS_DEVICE_UNKNOWN);
+        } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
+                /* Indicate QUEUE_FULL so that the scsi midlayer
+                 * retries.
+                  */
+                isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
+                                 SAS_QUEUE_FULL);
+        } else {
+                /* There is a device and it's ready for I/O. */
+                spin_lock_irqsave(&task->task_state_lock, flags);
 
-                dev_dbg(&ihost->pdev->dev,
-                        "task: %p, num: %d dev: %p idev: %p:%#lx cmd = %p\n",
-                        task, num, task->dev, idev, idev ? idev->flags : 0,
-                        task->uldd_task);
-
-                if (!idev) {
-                        isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
-                                         SAS_DEVICE_UNKNOWN);
-                } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
-                        /* Indicate QUEUE_FULL so that the scsi midlayer
-                         * retries.
-                          */
-                        isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
-                                         SAS_QUEUE_FULL);
+                if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
+                        /* The I/O was aborted. */
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        isci_task_refuse(ihost, task,
+                                         SAS_TASK_UNDELIVERED,
+                                         SAM_STAT_TASK_ABORTED);
                 } else {
-                        /* There is a device and it's ready for I/O. */
-                        spin_lock_irqsave(&task->task_state_lock, flags);
-
-                        if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
-                                /* The I/O was aborted. */
-                                spin_unlock_irqrestore(&task->task_state_lock,
-                                                       flags);
-
-                                isci_task_refuse(ihost, task,
-                                                 SAS_TASK_UNDELIVERED,
-                                                 SAM_STAT_TASK_ABORTED);
-                        } else {
-                                task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+                        task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        /* build and send the request. */
+                        status = isci_request_execute(ihost, idev, task, tag);
+
+                        if (status != SCI_SUCCESS) {
+                                spin_lock_irqsave(&task->task_state_lock, flags);
+                                /* Did not really start this command. */
+                                task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
                                 spin_unlock_irqrestore(&task->task_state_lock, flags);
 
-                                /* build and send the request. */
-                                status = isci_request_execute(ihost, idev, task, tag);
-
-                                if (status != SCI_SUCCESS) {
-
-                                        spin_lock_irqsave(&task->task_state_lock, flags);
-                                        /* Did not really start this command. */
-                                        task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
-                                        spin_unlock_irqrestore(&task->task_state_lock, flags);
-
-                                        if (test_bit(IDEV_GONE, &idev->flags)) {
-
-                                                /* Indicate that the device
-                                                 * is gone.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_UNDELIVERED,
-                                                        SAS_DEVICE_UNKNOWN);
-                                        } else {
-                                                /* Indicate QUEUE_FULL so that
-                                                 * the scsi midlayer retries.
-                                                 * If the request failed for
-                                                 * remote device reasons, it
-                                                 * gets returned as
-                                                 * SAS_TASK_UNDELIVERED next
-                                                 * time through.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_COMPLETE,
-                                                        SAS_QUEUE_FULL);
-                                        }
+                                if (test_bit(IDEV_GONE, &idev->flags)) {
+                                        /* Indicate that the device
+                                         * is gone.
+                                         */
+                                        isci_task_refuse(ihost, task,
+                                                SAS_TASK_UNDELIVERED,
+                                                SAS_DEVICE_UNKNOWN);
+                                } else {
+                                        /* Indicate QUEUE_FULL so that
+                                         * the scsi midlayer retries.
+                                         * If the request failed for
+                                         * remote device reasons, it
+                                         * gets returned as
+                                         * SAS_TASK_UNDELIVERED next
+                                         * time through.
+                                         */
+                                        isci_task_refuse(ihost, task,
+                                                SAS_TASK_COMPLETE,
+                                                SAS_QUEUE_FULL);
                                 }
                         }
                 }
-                if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
-                        spin_lock_irqsave(&ihost->scic_lock, flags);
-                        /* command never hit the device, so just free
-                         * the tci and skip the sequence increment
-                         */
-                        isci_tci_free(ihost, ISCI_TAG_TCI(tag));
-                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-                }
-                isci_put_device(idev);
         }
+
+        if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
+                spin_lock_irqsave(&ihost->scic_lock, flags);
+                /* command never hit the device, so just free
+                 * the tci and skip the sequence increment
+                 */
+                isci_tci_free(ihost, ISCI_TAG_TCI(tag));
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        }
+
+        isci_put_device(idev);
         return 0;
 }
 
diff --git a/drivers/scsi/isci/task.h b/drivers/scsi/isci/task.h
index 9c06cbad1d26..8f4531f22ac2 100644
--- a/drivers/scsi/isci/task.h
+++ b/drivers/scsi/isci/task.h
@@ -131,7 +131,6 @@ static inline void isci_print_tmf(struct isci_host *ihost, struct isci_tmf *tmf)
 
 int isci_task_execute_task(
         struct sas_task *task,
-        int num,
         gfp_t gfp_flags);
 
 int isci_task_abort_task(