1 files changed, 68 insertions, 38 deletions

diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index f9ecc3dea7df..f14945996ede 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -205,12 +205,11 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
         int display_failure_msg = 1, ret;
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 
-        sdev = kmalloc(sizeof(*sdev) + shost->transportt->device_size,
+        sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
                        GFP_ATOMIC);
         if (!sdev)
                 goto out;
 
-        memset(sdev, 0, sizeof(*sdev));
         sdev->vendor = scsi_null_device_strs;
         sdev->model = scsi_null_device_strs;
         sdev->rev = scsi_null_device_strs;
@@ -252,6 +251,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
                 /* release fn is set up in scsi_sysfs_device_initialise, so
                  * have to free and put manually here */
                 put_device(&starget->dev);
+                kfree(sdev);
                 goto out;
         }
 
@@ -288,10 +288,7 @@ static void scsi_target_dev_release(struct device *dev)
 {
         struct device *parent = dev->parent;
         struct scsi_target *starget = to_scsi_target(dev);
-        struct Scsi_Host *shost = dev_to_shost(parent);
 
-        if (shost->hostt->target_destroy)
-                shost->hostt->target_destroy(starget);
         kfree(starget);
         put_device(parent);
 }
@@ -333,13 +330,13 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
                 + shost->transportt->target_size;
         struct scsi_target *starget;
         struct scsi_target *found_target;
+        int error;
 
-        starget = kmalloc(size, GFP_KERNEL);
+        starget = kzalloc(size, GFP_KERNEL);
         if (!starget) {
                 printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__);
                 return NULL;
         }
-        memset(starget, 0, size);
         dev = &starget->dev;
         device_initialize(dev);
         starget->reap_ref = 1;
@@ -351,6 +348,8 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         starget->channel = channel;
         INIT_LIST_HEAD(&starget->siblings);
         INIT_LIST_HEAD(&starget->devices);
+        starget->state = STARGET_RUNNING;
+ retry:
         spin_lock_irqsave(shost->host_lock, flags);
 
         found_target = __scsi_find_target(parent, channel, id);
@@ -361,10 +360,20 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         spin_unlock_irqrestore(shost->host_lock, flags);
         /* allocate and add */
         transport_setup_device(dev);
-        device_add(dev);
+        error = device_add(dev);
+        if (error) {
+                dev_err(dev, "target device_add failed, error %d\n", error);
+                spin_lock_irqsave(shost->host_lock, flags);
+                list_del_init(&starget->siblings);
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                transport_destroy_device(dev);
+                put_device(parent);
+                kfree(starget);
+                return NULL;
+        }
         transport_add_device(dev);
         if (shost->hostt->target_alloc) {
-                int error = shost->hostt->target_alloc(starget);
+                error = shost->hostt->target_alloc(starget);
 
                 if(error) {
                         dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
@@ -383,8 +392,15 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         found_target->reap_ref++;
         spin_unlock_irqrestore(shost->host_lock, flags);
         put_device(parent);
-        kfree(starget);
-        return found_target;
+        if (found_target->state != STARGET_DEL) {
+                kfree(starget);
+                return found_target;
+        }
+        /* Unfortunately, we found a dying target; need to
+         * wait until it's dead before we can get a new one */
+        put_device(&found_target->dev);
+        flush_scheduled_work();
+        goto retry;
 }
 
 static void scsi_target_reap_usercontext(void *data)
@@ -393,21 +409,15 @@ static void scsi_target_reap_usercontext(void *data)
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
         unsigned long flags;
 
+        transport_remove_device(&starget->dev);
+        device_del(&starget->dev);
+        transport_destroy_device(&starget->dev);
         spin_lock_irqsave(shost->host_lock, flags);
-
-        if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
-                list_del_init(&starget->siblings);
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                transport_remove_device(&starget->dev);
-                device_del(&starget->dev);
-                transport_destroy_device(&starget->dev);
-                put_device(&starget->dev);
-                return;
-
-        }
+        if (shost->hostt->target_destroy)
+                shost->hostt->target_destroy(starget);
+        list_del_init(&starget->siblings);
         spin_unlock_irqrestore(shost->host_lock, flags);
-
-        return;
+        put_device(&starget->dev);
 }
 
 /**
@@ -421,7 +431,23 @@ static void scsi_target_reap_usercontext(void *data)
  */
 void scsi_target_reap(struct scsi_target *starget)
 {
-        scsi_execute_in_process_context(scsi_target_reap_usercontext, starget);
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        unsigned long flags;
+
+        spin_lock_irqsave(shost->host_lock, flags);
+
+        if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
+                BUG_ON(starget->state == STARGET_DEL);
+                starget->state = STARGET_DEL;
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                execute_in_process_context(scsi_target_reap_usercontext,
+                                           starget, &starget->ew);
+                return;
+
+        }
+        spin_unlock_irqrestore(shost->host_lock, flags);
+
+        return;
 }
 
 /**
@@ -689,12 +715,8 @@ static int scsi_add_lun(struct scsi_device *sdev, char *inq_result, int *bflags)
         if (inq_result[7] & 0x10)
                 sdev->sdtr = 1;
 
-        sprintf(sdev->devfs_name, "scsi/host%d/bus%d/target%d/lun%d",
-                                sdev->host->host_no, sdev->channel,
-                                sdev->id, sdev->lun);
-
         /*
-         * End driverfs/devfs code.
+         * End sysfs code.
          */
 
         if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
@@ -871,6 +893,19 @@ static int scsi_probe_and_add_lun(struct scsi_target *starget,
                 goto out_free_result;
         }
 
+        /*
+         * Non-standard SCSI targets may set the PDT to 0x1f (unknown or
+         * no device type) instead of using the Peripheral Qualifier to
+         * indicate that no LUN is present.  For example, USB UFI does this.
+         */
+        if (starget->pdt_1f_for_no_lun && (result[0] & 0x1f) == 0x1f) {
+                SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
+                                        "scsi scan: peripheral device type"
+                                        " of 31, no device added\n"));
+                res = SCSI_SCAN_TARGET_PRESENT;
+                goto out_free_result;
+        }
+
         res = scsi_add_lun(sdev, result, &bflags);
         if (res == SCSI_SCAN_LUN_PRESENT) {
                 if (bflags & BLIST_KEY) {
@@ -1261,9 +1296,8 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
                                       uint id, uint lun, void *hostdata)
 {
-        struct scsi_device *sdev;
+        struct scsi_device *sdev = ERR_PTR(-ENODEV);
         struct device *parent = &shost->shost_gendev;
-        int res;
         struct scsi_target *starget;
 
         starget = scsi_alloc_target(parent, channel, id);
@@ -1272,12 +1306,8 @@ struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
 
         get_device(&starget->dev);
         mutex_lock(&shost->scan_mutex);
-        if (scsi_host_scan_allowed(shost)) {
-                res = scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1,
-                                             hostdata);
-                if (res != SCSI_SCAN_LUN_PRESENT)
-                        sdev = ERR_PTR(-ENODEV);
-        }
+        if (scsi_host_scan_allowed(shost))
+                scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
         mutex_unlock(&shost->scan_mutex);
         scsi_target_reap(starget);
         put_device(&starget->dev);