[SCSI] libsas: async ata scanning

libsas ata error handling is already async but this does not help the
scan case.  Move initial link recovery out from under host->scan_mutex,
and delay synchronization with eh until after all port probe/recovery
work has been queued.

Device ordering is maintained with scan order by still calling
sas_rphy_add() in order of domain discovery.

Since we now scan the domain list when invoking libata-eh we need to be
careful to check for fully initialized ata ports.

Acked-by: Jack Wang <jack_wang@usish.com>
Acked-by: Jeff Garzik <jgarzik@redhat.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

4 files changed, 83 insertions, 40 deletions

diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index a9ec1643ee93..eb8b77c86169 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -585,11 +585,10 @@ static struct ata_port_info sata_port_info = {
         .port_ops = &sas_sata_ops
 };
 
-int sas_ata_init_host_and_port(struct domain_device *found_dev,
-                               struct scsi_target *starget)
+int sas_ata_init_host_and_port(struct domain_device *found_dev)
 {
-        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
-        struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
+        struct sas_ha_struct *ha = found_dev->port->ha;
+        struct Scsi_Host *shost = ha->core.shost;
         struct ata_port *ap;
 
         ata_host_init(&found_dev->sata_dev.ata_host,
@@ -607,6 +606,8 @@ int sas_ata_init_host_and_port(struct domain_device *found_dev,
         ap->private_data = found_dev;
         ap->cbl = ATA_CBL_SATA;
         ap->scsi_host = shost;
+        /* publish initialized ata port */
+        smp_wmb();
         found_dev->sata_dev.ap = ap;
 
         return 0;
@@ -683,6 +684,38 @@ static void sas_get_ata_command_set(struct domain_device *dev)
                 dev->sata_dev.command_set = ATAPI_COMMAND_SET;
 }
 
+void sas_probe_sata(struct asd_sas_port *port)
+{
+        struct domain_device *dev, *n;
+        int err;
+
+        mutex_lock(&port->ha->disco_mutex);
+        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
+                if (!dev_is_sata(dev))
+                        continue;
+
+                err = sas_ata_init_host_and_port(dev);
+                if (err)
+                        sas_fail_probe(dev, __func__, err);
+                else
+                        ata_sas_async_port_init(dev->sata_dev.ap);
+        }
+        mutex_unlock(&port->ha->disco_mutex);
+
+        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
+                if (!dev_is_sata(dev))
+                        continue;
+
+                sas_ata_wait_eh(dev);
+
+                /* if libata could not bring the link up, don't surface
+                 * the device
+                 */
+                if (ata_dev_disabled(sas_to_ata_dev(dev)))
+                        sas_fail_probe(dev, __func__, -ENODEV);
+        }
+}
+
 /**
  * sas_discover_sata -- discover an STP/SATA domain device
  * @dev: pointer to struct domain_device of interest
@@ -724,11 +757,23 @@ static void async_sas_ata_eh(void *data, async_cookie_t cookie)
         sas_put_device(dev);
 }
 
+static bool sas_ata_dev_eh_valid(struct domain_device *dev)
+{
+        struct ata_port *ap;
+
+        if (!dev_is_sata(dev))
+                return false;
+        ap = dev->sata_dev.ap;
+        /* consume fully initialized ata ports */
+        smp_rmb();
+        return !!ap;
+}
+
 void sas_ata_strategy_handler(struct Scsi_Host *shost)
 {
-        struct scsi_device *sdev;
         struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
         LIST_HEAD(async);
+        int i;
 
         /* it's ok to defer revalidation events during ata eh, these
          * disks are in one of three states:
@@ -740,14 +785,21 @@ void sas_ata_strategy_handler(struct Scsi_Host *shost)
          */
         sas_disable_revalidation(sas_ha);
 
-        shost_for_each_device(sdev, shost) {
-                struct domain_device *ddev = sdev_to_domain_dev(sdev);
-
-                if (!dev_is_sata(ddev))
-                        continue;
+        spin_lock_irq(&sas_ha->phy_port_lock);
+        for (i = 0; i < sas_ha->num_phys; i++) {
+                struct asd_sas_port *port = sas_ha->sas_port[i];
+                struct domain_device *dev;
 
-                async_schedule_domain(async_sas_ata_eh, ddev, &async);
+                spin_lock(&port->dev_list_lock);
+                list_for_each_entry(dev, &port->dev_list, dev_list_node) {
+                        if (!sas_ata_dev_eh_valid(dev))
+                                continue;
+                        async_schedule_domain(async_sas_ata_eh, dev, &async);
+                }
+                spin_unlock(&port->dev_list_lock);
         }
+        spin_unlock_irq(&sas_ha->phy_port_lock);
+
         async_synchronize_full_domain(&async);
 
         sas_enable_revalidation(sas_ha);
diff --git a/drivers/scsi/libsas/sas_discover.c b/drivers/scsi/libsas/sas_discover.c
index 18fa364aa00f..0d58a8beaa3d 100644
--- a/drivers/scsi/libsas/sas_discover.c
+++ b/drivers/scsi/libsas/sas_discover.c
@@ -207,22 +207,22 @@ static void sas_probe_devices(struct work_struct *work)
 
         clear_bit(DISCE_PROBE, &port->disc.pending);
 
-        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
-                int err;
-
+        /* devices must be domain members before link recovery and probe */
+        list_for_each_entry(dev, &port->disco_list, disco_list_node) {
                 spin_lock_irq(&port->dev_list_lock);
                 list_add_tail(&dev->dev_list_node, &port->dev_list);
                 spin_unlock_irq(&port->dev_list_lock);
+        }
 
-                err = sas_rphy_add(dev->rphy);
+        sas_probe_sata(port);
 
-                if (err) {
-                        SAS_DPRINTK("%s: for %s device %16llx returned %d\n",
-                                    __func__, dev->parent ? "exp-attached" :
-                                                            "direct-attached",
-                                    SAS_ADDR(dev->sas_addr), err);
-                        sas_unregister_dev(port, dev);
-                } else
+        list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
+                int err;
+
+                err = sas_rphy_add(dev->rphy);
+                if (err)
+                        sas_fail_probe(dev, __func__, err);
+                else
                         list_del_init(&dev->disco_list_node);
         }
 }
diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
index e028d7a44202..d0d9bf10f79c 100644
--- a/drivers/scsi/libsas/sas_internal.h
+++ b/drivers/scsi/libsas/sas_internal.h
@@ -113,6 +113,15 @@ static inline int sas_smp_host_handler(struct Scsi_Host *shost,
 }
 #endif
 
+static inline void sas_fail_probe(struct domain_device *dev, const char *func, int err)
+{
+        SAS_DPRINTK("%s: for %s device %16llx returned %d\n",
+                    func, dev->parent ? "exp-attached" :
+                                            "direct-attached",
+                    SAS_ADDR(dev->sas_addr), err);
+        sas_unregister_dev(dev->port, dev);
+}
+
 static inline void sas_fill_in_rphy(struct domain_device *dev,
                                     struct sas_rphy *rphy)
 {
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index e58ca50517d5..3701ff7e7267 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -762,17 +762,10 @@ int sas_target_alloc(struct scsi_target *starget)
 {
         struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent);
         struct domain_device *found_dev = sas_find_dev_by_rphy(rphy);
-        int res;
 
         if (!found_dev)
                 return -ENODEV;
 
-        if (dev_is_sata(found_dev)) {
-                res = sas_ata_init_host_and_port(found_dev, starget);
-                if (res)
-                        return res;
-        }
-
         kref_get(&found_dev->kref);
         starget->hostdata = found_dev;
         return 0;
@@ -1012,16 +1005,6 @@ void sas_task_abort(struct sas_task *task)
         }
 }
 
-int sas_slave_alloc(struct scsi_device *scsi_dev)
-{
-        struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
-
-        if (dev_is_sata(dev))
-                return ata_sas_port_init(dev->sata_dev.ap);
-
-        return 0;
-}
-
 void sas_target_destroy(struct scsi_target *starget)
 {
         struct domain_device *found_dev = starget->hostdata;
@@ -1082,6 +1065,5 @@ EXPORT_SYMBOL_GPL(sas_task_abort);
 EXPORT_SYMBOL_GPL(sas_phy_reset);
 EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler);
 EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler);
-EXPORT_SYMBOL_GPL(sas_slave_alloc);
 EXPORT_SYMBOL_GPL(sas_target_destroy);
 EXPORT_SYMBOL_GPL(sas_ioctl);