[SCSI] tidy up scsi_error_handler

adjust comments, remove a useless cast and remove a write-only variable.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 0c5b02d4c7f85dc963181baa0e3583fe52a1e262..56353e8781303f9e2daeca6a72a3917b3e089fce 100644 (file)
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1571,48 +1571,41 @@ static void scsi_unjam_host(struct Scsi_Host *shost)
 }
 
 /**
- * scsi_error_handler - Handle errors/timeouts of SCSI cmds.
+ * scsi_error_handler - SCSI error handler thread
  * @data:      Host for which we are running.
  *
  * Notes:
- *    This is always run in the context of a kernel thread.  The idea is
- *    that we start this thing up when the kernel starts up (one per host
- *    that we detect), and it immediately goes to sleep and waits for some
- *    event (i.e. failure).  When this takes place, we have the job of
- *    trying to unjam the bus and restarting things.
+ *    This is the main error handling loop.  This is run as a kernel thread
+ *    for every SCSI host and handles all error handling activity.
  **/
 int scsi_error_handler(void *data)
 {
-       struct Scsi_Host *shost = (struct Scsi_Host *) data;
-       int rtn;
+       struct Scsi_Host *shost = data;
 
        current->flags |= PF_NOFREEZE;
 
-       
        /*
-        * Note - we always use TASK_INTERRUPTIBLE even if the module
-        * was loaded as part of the kernel.  The reason is that
-        * UNINTERRUPTIBLE would cause this thread to be counted in
-        * the load average as a running process, and an interruptible
-        * wait doesn't.
+        * We use TASK_INTERRUPTIBLE so that the thread is not
+        * counted against the load average as a running process.
+        * We never actually get interrupted because kthread_run
+        * disables singal delivery for the created thread.
         */
        set_current_state(TASK_INTERRUPTIBLE);
        while (!kthread_should_stop()) {
                if (shost->host_failed == 0 ||
                    shost->host_failed != shost->host_busy) {
-                       SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler"
-                                                         " scsi_eh_%d"
-                                                         " sleeping\n",
-                                                         shost->host_no));
+                       SCSI_LOG_ERROR_RECOVERY(1,
+                               printk("Error handler scsi_eh_%d sleeping\n",
+                                       shost->host_no));
                        schedule();
                        set_current_state(TASK_INTERRUPTIBLE);
                        continue;
                }
 
                __set_current_state(TASK_RUNNING);
-               SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler"
-                                                 " scsi_eh_%d waking"
-                                                 " up\n",shost->host_no));
+               SCSI_LOG_ERROR_RECOVERY(1,
+                       printk("Error handler scsi_eh_%d waking up\n",
+                               shost->host_no));
 
                shost->eh_active = 1;
 
@@ -1622,7 +1615,7 @@ int scsi_error_handler(void *data)
                 * If we fail, we end up taking the thing offline.
                 */
                if (shost->hostt->eh_strategy_handler) 
-                       rtn = shost->hostt->eh_strategy_handler(shost);
+                       shost->hostt->eh_strategy_handler(shost);
                else
                        scsi_unjam_host(shost);
 
@@ -1638,15 +1631,10 @@ int scsi_error_handler(void *data)
                scsi_restart_operations(shost);
                set_current_state(TASK_INTERRUPTIBLE);
        }
-
        __set_current_state(TASK_RUNNING);
 
-       SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler scsi_eh_%d"
-                                         " exiting\n",shost->host_no));
-
-       /*
-        * Make sure that nobody tries to wake us up again.
-        */
+       SCSI_LOG_ERROR_RECOVERY(1,
+               printk("Error handler scsi_eh_%d exiting\n", shost->host_no));
        shost->ehandler = NULL;
        return 0;
 }