Merge branch 'sched/urgent' into sched/core, to avoid conflicts

Signed-off-by: Ingo Molnar <mingo@kernel.org>

17 files changed, 209 insertions, 44 deletions

diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index c8bd092fc945..02832d64d918 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -263,6 +263,9 @@ config SCSI_SCAN_ASYNC
           You can override this choice by specifying "scsi_mod.scan=sync"
           or async on the kernel's command line.
 
+          Note that this setting also affects whether resuming from
+          system suspend will be performed asynchronously.
+
 menu "SCSI Transports"
         depends on SCSI
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index 3455cc5e4bfd..f54843023466 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -2592,12 +2592,16 @@ static int __init bnx2fc_mod_init(void)
                 spin_lock_init(&p->fp_work_lock);
         }
 
+        cpu_notifier_register_begin();
+
         for_each_online_cpu(cpu) {
                 bnx2fc_percpu_thread_create(cpu);
         }
 
         /* Initialize per CPU interrupt thread */
-        register_hotcpu_notifier(&bnx2fc_cpu_notifier);
+        __register_hotcpu_notifier(&bnx2fc_cpu_notifier);
+
+        cpu_notifier_register_done();
 
         cnic_register_driver(CNIC_ULP_FCOE, &bnx2fc_cnic_cb);
 
@@ -2662,13 +2666,17 @@ static void __exit bnx2fc_mod_exit(void)
         if (l2_thread)
                 kthread_stop(l2_thread);
 
-        unregister_hotcpu_notifier(&bnx2fc_cpu_notifier);
+        cpu_notifier_register_begin();
 
         /* Destroy per cpu threads */
         for_each_online_cpu(cpu) {
                 bnx2fc_percpu_thread_destroy(cpu);
         }
 
+        __unregister_hotcpu_notifier(&bnx2fc_cpu_notifier);
+
+        cpu_notifier_register_done();
+
         destroy_workqueue(bnx2fc_wq);
         /*
          * detach from scsi transport
diff --git a/drivers/scsi/bnx2i/bnx2i_init.c b/drivers/scsi/bnx2i/bnx2i_init.c
index 34c294b42c84..80c03b452d61 100644
--- a/drivers/scsi/bnx2i/bnx2i_init.c
+++ b/drivers/scsi/bnx2i/bnx2i_init.c
@@ -537,11 +537,15 @@ static int __init bnx2i_mod_init(void)
                 p->iothread = NULL;
         }
 
+        cpu_notifier_register_begin();
+
         for_each_online_cpu(cpu)
                 bnx2i_percpu_thread_create(cpu);
 
         /* Initialize per CPU interrupt thread */
-        register_hotcpu_notifier(&bnx2i_cpu_notifier);
+        __register_hotcpu_notifier(&bnx2i_cpu_notifier);
+
+        cpu_notifier_register_done();
 
         return 0;
 
@@ -581,11 +585,15 @@ static void __exit bnx2i_mod_exit(void)
         }
         mutex_unlock(&bnx2i_dev_lock);
 
-        unregister_hotcpu_notifier(&bnx2i_cpu_notifier);
+        cpu_notifier_register_begin();
 
         for_each_online_cpu(cpu)
                 bnx2i_percpu_thread_destroy(cpu);
 
+        __unregister_hotcpu_notifier(&bnx2i_cpu_notifier);
+
+        cpu_notifier_register_done();
+
         iscsi_unregister_transport(&bnx2i_iscsi_transport);
         cnic_unregister_driver(CNIC_ULP_ISCSI);
 }
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 843a679d2a5e..00ee0ed642aa 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -2633,14 +2633,18 @@ static int __init fcoe_init(void)
                 skb_queue_head_init(&p->fcoe_rx_list);
         }
 
+        cpu_notifier_register_begin();
+
         for_each_online_cpu(cpu)
                 fcoe_percpu_thread_create(cpu);
 
         /* Initialize per CPU interrupt thread */
-        rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
+        rc = __register_hotcpu_notifier(&fcoe_cpu_notifier);
         if (rc)
                 goto out_free;
 
+        cpu_notifier_register_done();
+
         /* Setup link change notification */
         fcoe_dev_setup();
 
@@ -2655,6 +2659,9 @@ out_free:
         for_each_online_cpu(cpu) {
                 fcoe_percpu_thread_destroy(cpu);
         }
+
+        cpu_notifier_register_done();
+
         mutex_unlock(&fcoe_config_mutex);
         destroy_workqueue(fcoe_wq);
         return rc;
@@ -2687,11 +2694,15 @@ static void __exit fcoe_exit(void)
         }
         rtnl_unlock();
 
-        unregister_hotcpu_notifier(&fcoe_cpu_notifier);
+        cpu_notifier_register_begin();
 
         for_each_online_cpu(cpu)
                 fcoe_percpu_thread_destroy(cpu);
 
+        __unregister_hotcpu_notifier(&fcoe_cpu_notifier);
+
+        cpu_notifier_register_done();
+
         mutex_unlock(&fcoe_config_mutex);
 
         /*
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index bfb6d07d87f0..11854845393b 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -125,7 +125,7 @@ static inline int iscsi_sw_sk_state_check(struct sock *sk)
         return 0;
 }
 
-static void iscsi_sw_tcp_data_ready(struct sock *sk, int flag)
+static void iscsi_sw_tcp_data_ready(struct sock *sk)
 {
         struct iscsi_conn *conn;
         struct iscsi_tcp_conn *tcp_conn;
diff --git a/drivers/scsi/iscsi_tcp.h b/drivers/scsi/iscsi_tcp.h
index 666fe09378fa..f42ecb238af5 100644
--- a/drivers/scsi/iscsi_tcp.h
+++ b/drivers/scsi/iscsi_tcp.h
@@ -40,7 +40,7 @@ struct iscsi_sw_tcp_conn {
 
         struct iscsi_sw_tcp_send out;
         /* old values for socket callbacks */
-        void                    (*old_data_ready)(struct sock *, int);
+        void                    (*old_data_ready)(struct sock *);
         void                    (*old_state_change)(struct sock *);
         void                    (*old_write_space)(struct sock *);
 
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 5b8605ca42fa..26dc005bb0f0 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -387,6 +387,10 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
                 if (rc)
                         return rc;
         }
+
+        if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL)
+                task->protected = true;
+
         if (sc->sc_data_direction == DMA_TO_DEVICE) {
                 unsigned out_len = scsi_out(sc)->length;
                 struct iscsi_r2t_info *r2t = &task->unsol_r2t;
@@ -822,6 +826,33 @@ static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
 
         sc->result = (DID_OK << 16) | rhdr->cmd_status;
 
+        if (task->protected) {
+                sector_t sector;
+                u8 ascq;
+
+                /**
+                 * Transports that didn't implement check_protection
+                 * callback but still published T10-PI support to scsi-mid
+                 * deserve this BUG_ON.
+                 **/
+                BUG_ON(!session->tt->check_protection);
+
+                ascq = session->tt->check_protection(task, &sector);
+                if (ascq) {
+                        sc->result = DRIVER_SENSE << 24 |
+                                     SAM_STAT_CHECK_CONDITION;
+                        scsi_build_sense_buffer(1, sc->sense_buffer,
+                                                ILLEGAL_REQUEST, 0x10, ascq);
+                        sc->sense_buffer[7] = 0xc; /* Additional sense length */
+                        sc->sense_buffer[8] = 0;   /* Information desc type */
+                        sc->sense_buffer[9] = 0xa; /* Additional desc length */
+                        sc->sense_buffer[10] = 0x80; /* Validity bit */
+
+                        put_unaligned_be64(sector, &sc->sense_buffer[12]);
+                        goto out;
+                }
+        }
+
         if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) {
                 sc->result = DID_ERROR << 16;
                 goto out;
@@ -1582,6 +1613,7 @@ static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
         task->have_checked_conn = false;
         task->last_timeout = jiffies;
         task->last_xfer = jiffies;
+        task->protected = false;
         INIT_LIST_HEAD(&task->running);
         return task;
 }
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index 788c4fe2b0c9..68fb66fdb757 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -684,6 +684,20 @@ static void tcm_qla2xxx_queue_tm_rsp(struct se_cmd *se_cmd)
         qlt_xmit_tm_rsp(mcmd);
 }
 
+static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd)
+{
+        struct qla_tgt_cmd *cmd = container_of(se_cmd,
+                                struct qla_tgt_cmd, se_cmd);
+        struct scsi_qla_host *vha = cmd->vha;
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!cmd->sg_mapped)
+                return;
+
+        pci_unmap_sg(ha->pdev, cmd->sg, cmd->sg_cnt, cmd->dma_data_direction);
+        cmd->sg_mapped = 0;
+}
+
 /* Local pointer to allocated TCM configfs fabric module */
 struct target_fabric_configfs *tcm_qla2xxx_fabric_configfs;
 struct target_fabric_configfs *tcm_qla2xxx_npiv_fabric_configfs;
@@ -1468,7 +1482,7 @@ static int tcm_qla2xxx_check_initiator_node_acl(
         }
         se_tpg = &tpg->se_tpg;
 
-        se_sess = transport_init_session();
+        se_sess = transport_init_session(TARGET_PROT_NORMAL);
         if (IS_ERR(se_sess)) {
                 pr_err("Unable to initialize struct se_session\n");
                 return PTR_ERR(se_sess);
@@ -1877,6 +1891,7 @@ static struct target_core_fabric_ops tcm_qla2xxx_ops = {
         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
         .queue_status                   = tcm_qla2xxx_queue_status,
         .queue_tm_rsp                   = tcm_qla2xxx_queue_tm_rsp,
+        .aborted_task                   = tcm_qla2xxx_aborted_task,
         /*
          * Setup function pointers for generic logic in
          * target_core_fabric_configfs.c
@@ -1926,6 +1941,7 @@ static struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
         .queue_status                   = tcm_qla2xxx_queue_status,
         .queue_tm_rsp                   = tcm_qla2xxx_queue_tm_rsp,
+        .aborted_task                   = tcm_qla2xxx_aborted_task,
         /*
          * Setup function pointers for generic logic in
          * target_core_fabric_configfs.c
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index c4d632c27a3e..88d46fe6bf98 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -91,6 +91,15 @@ EXPORT_SYMBOL(scsi_logging_level);
 ASYNC_DOMAIN(scsi_sd_probe_domain);
 EXPORT_SYMBOL(scsi_sd_probe_domain);
 
+/*
+ * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
+ * asynchronous system resume operations.  It is marked 'exclusive' to avoid
+ * being included in the async_synchronize_full() that is invoked by
+ * dpm_resume()
+ */
+ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
+EXPORT_SYMBOL(scsi_sd_pm_domain);
+
 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  * You may not alter any existing entry (although adding new ones is
  * encouraged once assigned by ANSI/INCITS T10
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 5681c05ac506..65a123d9c676 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -184,7 +184,7 @@ void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
  */
 int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
                  int data_direction, void *buffer, unsigned bufflen,
-                 unsigned char *sense, int timeout, int retries, int flags,
+                 unsigned char *sense, int timeout, int retries, u64 flags,
                  int *resid)
 {
         struct request *req;
@@ -235,7 +235,7 @@ EXPORT_SYMBOL(scsi_execute);
 int scsi_execute_req_flags(struct scsi_device *sdev, const unsigned char *cmd,
                      int data_direction, void *buffer, unsigned bufflen,
                      struct scsi_sense_hdr *sshdr, int timeout, int retries,
-                     int *resid, int flags)
+                     int *resid, u64 flags)
 {
         char *sense = NULL;
         int result;
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index 001e9ceda4c3..7454498c4091 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -18,35 +18,77 @@
 
 #ifdef CONFIG_PM_SLEEP
 
-static int scsi_dev_type_suspend(struct device *dev, int (*cb)(struct device *))
+static int do_scsi_suspend(struct device *dev, const struct dev_pm_ops *pm)
 {
+        return pm && pm->suspend ? pm->suspend(dev) : 0;
+}
+
+static int do_scsi_freeze(struct device *dev, const struct dev_pm_ops *pm)
+{
+        return pm && pm->freeze ? pm->freeze(dev) : 0;
+}
+
+static int do_scsi_poweroff(struct device *dev, const struct dev_pm_ops *pm)
+{
+        return pm && pm->poweroff ? pm->poweroff(dev) : 0;
+}
+
+static int do_scsi_resume(struct device *dev, const struct dev_pm_ops *pm)
+{
+        return pm && pm->resume ? pm->resume(dev) : 0;
+}
+
+static int do_scsi_thaw(struct device *dev, const struct dev_pm_ops *pm)
+{
+        return pm && pm->thaw ? pm->thaw(dev) : 0;
+}
+
+static int do_scsi_restore(struct device *dev, const struct dev_pm_ops *pm)
+{
+        return pm && pm->restore ? pm->restore(dev) : 0;
+}
+
+static int scsi_dev_type_suspend(struct device *dev,
+                int (*cb)(struct device *, const struct dev_pm_ops *))
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
         int err;
 
+        /* flush pending in-flight resume operations, suspend is synchronous */
+        async_synchronize_full_domain(&scsi_sd_pm_domain);
+
         err = scsi_device_quiesce(to_scsi_device(dev));
         if (err == 0) {
-                if (cb) {
-                        err = cb(dev);
-                        if (err)
-                                scsi_device_resume(to_scsi_device(dev));
-                }
+                err = cb(dev, pm);
+                if (err)
+                        scsi_device_resume(to_scsi_device(dev));
         }
         dev_dbg(dev, "scsi suspend: %d\n", err);
         return err;
 }
 
-static int scsi_dev_type_resume(struct device *dev, int (*cb)(struct device *))
+static int scsi_dev_type_resume(struct device *dev,
+                int (*cb)(struct device *, const struct dev_pm_ops *))
 {
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
         int err = 0;
 
-        if (cb)
-                err = cb(dev);
+        err = cb(dev, pm);
         scsi_device_resume(to_scsi_device(dev));
         dev_dbg(dev, "scsi resume: %d\n", err);
+
+        if (err == 0) {
+                pm_runtime_disable(dev);
+                pm_runtime_set_active(dev);
+                pm_runtime_enable(dev);
+        }
+
         return err;
 }
 
 static int
-scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *))
+scsi_bus_suspend_common(struct device *dev,
+                int (*cb)(struct device *, const struct dev_pm_ops *))
 {
         int err = 0;
 
@@ -66,20 +108,54 @@ scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *))
         return err;
 }
 
-static int
-scsi_bus_resume_common(struct device *dev, int (*cb)(struct device *))
+static void async_sdev_resume(void *dev, async_cookie_t cookie)
 {
-        int err = 0;
+        scsi_dev_type_resume(dev, do_scsi_resume);
+}
 
-        if (scsi_is_sdev_device(dev))
-                err = scsi_dev_type_resume(dev, cb);
+static void async_sdev_thaw(void *dev, async_cookie_t cookie)
+{
+        scsi_dev_type_resume(dev, do_scsi_thaw);
+}
 
-        if (err == 0) {
+static void async_sdev_restore(void *dev, async_cookie_t cookie)
+{
+        scsi_dev_type_resume(dev, do_scsi_restore);
+}
+
+static int scsi_bus_resume_common(struct device *dev,
+                int (*cb)(struct device *, const struct dev_pm_ops *))
+{
+        async_func_t fn;
+
+        if (!scsi_is_sdev_device(dev))
+                fn = NULL;
+        else if (cb == do_scsi_resume)
+                fn = async_sdev_resume;
+        else if (cb == do_scsi_thaw)
+                fn = async_sdev_thaw;
+        else if (cb == do_scsi_restore)
+                fn = async_sdev_restore;
+        else
+                fn = NULL;
+
+        if (fn) {
+                async_schedule_domain(fn, dev, &scsi_sd_pm_domain);
+
+                /*
+                 * If a user has disabled async probing a likely reason
+                 * is due to a storage enclosure that does not inject
+                 * staggered spin-ups.  For safety, make resume
+                 * synchronous as well in that case.
+                 */
+                if (strncmp(scsi_scan_type, "async", 5) != 0)
+                        async_synchronize_full_domain(&scsi_sd_pm_domain);
+        } else {
                 pm_runtime_disable(dev);
                 pm_runtime_set_active(dev);
                 pm_runtime_enable(dev);
         }
-        return err;
+        return 0;
 }
 
 static int scsi_bus_prepare(struct device *dev)
@@ -97,38 +173,32 @@ static int scsi_bus_prepare(struct device *dev)
 
 static int scsi_bus_suspend(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_suspend_common(dev, pm ? pm->suspend : NULL);
+        return scsi_bus_suspend_common(dev, do_scsi_suspend);
 }
 
 static int scsi_bus_resume(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_resume_common(dev, pm ? pm->resume : NULL);
+        return scsi_bus_resume_common(dev, do_scsi_resume);
 }
 
 static int scsi_bus_freeze(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_suspend_common(dev, pm ? pm->freeze : NULL);
+        return scsi_bus_suspend_common(dev, do_scsi_freeze);
 }
 
 static int scsi_bus_thaw(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_resume_common(dev, pm ? pm->thaw : NULL);
+        return scsi_bus_resume_common(dev, do_scsi_thaw);
 }
 
 static int scsi_bus_poweroff(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_suspend_common(dev, pm ? pm->poweroff : NULL);
+        return scsi_bus_suspend_common(dev, do_scsi_poweroff);
 }
 
 static int scsi_bus_restore(struct device *dev)
 {
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        return scsi_bus_resume_common(dev, pm ? pm->restore : NULL);
+        return scsi_bus_resume_common(dev, do_scsi_restore);
 }
 
 #else /* CONFIG_PM_SLEEP */
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index f079a598bed4..48e5b657e79f 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -112,6 +112,7 @@ extern void scsi_exit_procfs(void);
 #endif /* CONFIG_PROC_FS */
 
 /* scsi_scan.c */
+extern char scsi_scan_type[];
 extern int scsi_complete_async_scans(void);
 extern int scsi_scan_host_selected(struct Scsi_Host *, unsigned int,
                                    unsigned int, unsigned int, int);
@@ -166,6 +167,7 @@ static inline int scsi_autopm_get_host(struct Scsi_Host *h) { return 0; }
 static inline void scsi_autopm_put_host(struct Scsi_Host *h) {}
 #endif /* CONFIG_PM_RUNTIME */
 
+extern struct async_domain scsi_sd_pm_domain;
 extern struct async_domain scsi_sd_probe_domain;
 
 /* 
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 27f96d5b7680..e02b3aab56ce 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -97,7 +97,7 @@ MODULE_PARM_DESC(max_luns,
 #define SCSI_SCAN_TYPE_DEFAULT "sync"
 #endif
 
-static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
+char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
 
 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
 MODULE_PARM_DESC(scan, "sync, async or none");
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index fd8ffe6bcfdd..0102a2d70dd8 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -1225,7 +1225,7 @@ struct bus_type iscsi_flashnode_bus = {
  * Adds a sysfs entry for the flashnode session attributes
  *
  * Returns:
- *  pointer to allocated flashnode sess on sucess
+ *  pointer to allocated flashnode sess on success
  *  %NULL on failure
  */
 struct iscsi_bus_flash_session *
@@ -1423,7 +1423,7 @@ static int iscsi_iter_destroy_flashnode_conn_fn(struct device *dev, void *data)
 }
 
 /**
- * iscsi_destroy_flashnode_sess - destory flashnode session entry
+ * iscsi_destroy_flashnode_sess - destroy flashnode session entry
  * @fnode_sess: pointer to flashnode session entry to be destroyed
  *
  * Deletes the flashnode session entry and all children flashnode connection
@@ -1453,7 +1453,7 @@ static int iscsi_iter_destroy_flashnode_fn(struct device *dev, void *data)
 }
 
 /**
- * iscsi_destroy_all_flashnode - destory all flashnode session entries
+ * iscsi_destroy_all_flashnode - destroy all flashnode session entries
  * @shost: pointer to host data
  *
  * Destroys all the flashnode session entries and all corresponding children
diff --git a/drivers/scsi/scsi_transport_srp.c b/drivers/scsi/scsi_transport_srp.c
index d47ffc8d3e43..13e898332e45 100644
--- a/drivers/scsi/scsi_transport_srp.c
+++ b/drivers/scsi/scsi_transport_srp.c
@@ -810,6 +810,7 @@ EXPORT_SYMBOL_GPL(srp_remove_host);
 
 /**
  * srp_stop_rport_timers - stop the transport layer recovery timers
+ * @rport: SRP remote port for which to stop the timers.
  *
  * Must be called after srp_remove_host() and scsi_remove_host(). The caller
  * must hold a reference on the rport (rport->dev) and on the SCSI host
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 89e6c04ac595..efcbcd182863 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -3026,6 +3026,7 @@ static int sd_remove(struct device *dev)
         devt = disk_devt(sdkp->disk);
         scsi_autopm_get_device(sdkp->device);
 
+        async_synchronize_full_domain(&scsi_sd_pm_domain);
         async_synchronize_full_domain(&scsi_sd_probe_domain);
         blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
         blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index d92fe4037e94..6b349e301869 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -3000,7 +3000,11 @@ sym_dequeue_from_squeue(struct sym_hcb *np, int i, int target, int lun, int task
                 if ((target == -1 || cp->target == target) &&
                     (lun    == -1 || cp->lun    == lun)    &&
                     (task   == -1 || cp->tag    == task)) {
+#ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
                         sym_set_cam_status(cp->cmd, DID_SOFT_ERROR);
+#else
+                        sym_set_cam_status(cp->cmd, DID_REQUEUE);
+#endif
                         sym_remque(&cp->link_ccbq);
                         sym_insque_tail(&cp->link_ccbq, &np->comp_ccbq);
                 }