Merge branch 'for-3.12' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata

[firefly-linux-kernel-4.4.55.git] / drivers / scsi / scsi_lib.c

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 86d522004a208255b17861b4c1cb556bbe7c973e..d1549b74e2d1b91eeb4f8ebf459ec4f13db73275 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -68,28 +68,6 @@ static struct scsi_host_sg_pool scsi_sg_pools[] = {
 
 struct kmem_cache *scsi_sdb_cache;
 
-#ifdef CONFIG_ACPI
-#include <acpi/acpi_bus.h>
-
-static bool acpi_scsi_bus_match(struct device *dev)
-{
-       return dev->bus == &scsi_bus_type;
-}
-
-int scsi_register_acpi_bus_type(struct acpi_bus_type *bus)
-{
-        bus->match = acpi_scsi_bus_match;
-        return register_acpi_bus_type(bus);
-}
-EXPORT_SYMBOL_GPL(scsi_register_acpi_bus_type);
-
-void scsi_unregister_acpi_bus_type(struct acpi_bus_type *bus)
-{
-       unregister_acpi_bus_type(bus);
-}
-EXPORT_SYMBOL_GPL(scsi_unregister_acpi_bus_type);
-#endif
-
 /*
  * When to reinvoke queueing after a resource shortage. It's 3 msecs to
  * not change behaviour from the previous unplug mechanism, experimentation
@@ -434,6 +412,8 @@ static void scsi_run_queue(struct request_queue *q)
        list_splice_init(&shost->starved_list, &starved_list);
 
        while (!list_empty(&starved_list)) {
+               struct request_queue *slq;
+
                /*
                 * As long as shost is accepting commands and we have
                 * starved queues, call blk_run_queue. scsi_request_fn
@@ -456,11 +436,25 @@ static void scsi_run_queue(struct request_queue *q)
                        continue;
                }
 
-               spin_unlock(shost->host_lock);
-               spin_lock(sdev->request_queue->queue_lock);
-               __blk_run_queue(sdev->request_queue);
-               spin_unlock(sdev->request_queue->queue_lock);
-               spin_lock(shost->host_lock);
+               /*
+                * Once we drop the host lock, a racing scsi_remove_device()
+                * call may remove the sdev from the starved list and destroy
+                * it and the queue.  Mitigate by taking a reference to the
+                * queue and never touching the sdev again after we drop the
+                * host lock.  Note: if __scsi_remove_device() invokes
+                * blk_cleanup_queue() before the queue is run from this
+                * function then blk_run_queue() will return immediately since
+                * blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
+                */
+               slq = sdev->request_queue;
+               if (!blk_get_queue(slq))
+                       continue;
+               spin_unlock_irqrestore(shost->host_lock, flags);
+
+               blk_run_queue(slq);
+               blk_put_queue(slq);
+
+               spin_lock_irqsave(shost->host_lock, flags);
        }
        /* put any unprocessed entries back */
        list_splice(&starved_list, &shost->starved_list);
@@ -700,6 +694,20 @@ void scsi_release_buffers(struct scsi_cmnd *cmd)
 }
 EXPORT_SYMBOL(scsi_release_buffers);
 
+/**
+ * __scsi_error_from_host_byte - translate SCSI error code into errno
+ * @cmd:       SCSI command (unused)
+ * @result:    scsi error code
+ *
+ * Translate SCSI error code into standard UNIX errno.
+ * Return values:
+ * -ENOLINK    temporary transport failure
+ * -EREMOTEIO  permanent target failure, do not retry
+ * -EBADE      permanent nexus failure, retry on other path
+ * -ENOSPC     No write space available
+ * -ENODATA    Medium error
+ * -EIO                unspecified I/O error
+ */
 static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)
 {
        int error = 0;
@@ -716,6 +724,14 @@ static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)
                set_host_byte(cmd, DID_OK);
                error = -EBADE;
                break;
+       case DID_ALLOC_FAILURE:
+               set_host_byte(cmd, DID_OK);
+               error = -ENOSPC;
+               break;
+       case DID_MEDIUM_ERROR:
+               set_host_byte(cmd, DID_OK);
+               error = -ENODATA;
+               break;
        default:
                error = -EIO;
                break;
@@ -2177,6 +2193,7 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
                case SDEV_OFFLINE:
                case SDEV_TRANSPORT_OFFLINE:
                case SDEV_CANCEL:
+               case SDEV_CREATED_BLOCK:
                        break;
                default:
                        goto illegal;
@@ -2214,7 +2231,21 @@ static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
        case SDEV_EVT_MEDIA_CHANGE:
                envp[idx++] = "SDEV_MEDIA_CHANGE=1";
                break;
-
+       case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
+               envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";
+               break;
+       case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
+               envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";
+               break;
+       case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
+              envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";
+               break;
+       case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
+               envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";
+               break;
+       case SDEV_EVT_LUN_CHANGE_REPORTED:
+               envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";
+               break;
        default:
                /* do nothing */
                break;
@@ -2235,10 +2266,15 @@ static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
 void scsi_evt_thread(struct work_struct *work)
 {
        struct scsi_device *sdev;
+       enum scsi_device_event evt_type;
        LIST_HEAD(event_list);
 
        sdev = container_of(work, struct scsi_device, event_work);
 
+       for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)
+               if (test_and_clear_bit(evt_type, sdev->pending_events))
+                       sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);
+
        while (1) {
                struct scsi_event *evt;
                struct list_head *this, *tmp;
@@ -2308,6 +2344,11 @@ struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
        /* evt_type-specific initialization, if any */
        switch (evt_type) {
        case SDEV_EVT_MEDIA_CHANGE:
+       case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
+       case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
+       case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
+       case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
+       case SDEV_EVT_LUN_CHANGE_REPORTED:
        default:
                /* do nothing */
                break;