LCOV - code coverage report
Current view: top level - drivers/scsi - scsi_error.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 172 855 20.1 %
Date: 2022-04-01 13:59:58 Functions: 19 48 39.6 %
Branches: 64 670 9.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  scsi_error.c Copyright (C) 1997 Eric Youngdale
       4                 :            :  *
       5                 :            :  *  SCSI error/timeout handling
       6                 :            :  *      Initial versions: Eric Youngdale.  Based upon conversations with
       7                 :            :  *                        Leonard Zubkoff and David Miller at Linux Expo,
       8                 :            :  *                        ideas originating from all over the place.
       9                 :            :  *
      10                 :            :  *      Restructured scsi_unjam_host and associated functions.
      11                 :            :  *      September 04, 2002 Mike Anderson (andmike@us.ibm.com)
      12                 :            :  *
      13                 :            :  *      Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
      14                 :            :  *      minor cleanups.
      15                 :            :  *      September 30, 2002 Mike Anderson (andmike@us.ibm.com)
      16                 :            :  */
      17                 :            : 
      18                 :            : #include <linux/module.h>
      19                 :            : #include <linux/sched.h>
      20                 :            : #include <linux/gfp.h>
      21                 :            : #include <linux/timer.h>
      22                 :            : #include <linux/string.h>
      23                 :            : #include <linux/kernel.h>
      24                 :            : #include <linux/freezer.h>
      25                 :            : #include <linux/kthread.h>
      26                 :            : #include <linux/interrupt.h>
      27                 :            : #include <linux/blkdev.h>
      28                 :            : #include <linux/delay.h>
      29                 :            : #include <linux/jiffies.h>
      30                 :            : 
      31                 :            : #include <scsi/scsi.h>
      32                 :            : #include <scsi/scsi_cmnd.h>
      33                 :            : #include <scsi/scsi_dbg.h>
      34                 :            : #include <scsi/scsi_device.h>
      35                 :            : #include <scsi/scsi_driver.h>
      36                 :            : #include <scsi/scsi_eh.h>
      37                 :            : #include <scsi/scsi_common.h>
      38                 :            : #include <scsi/scsi_transport.h>
      39                 :            : #include <scsi/scsi_host.h>
      40                 :            : #include <scsi/scsi_ioctl.h>
      41                 :            : #include <scsi/scsi_dh.h>
      42                 :            : #include <scsi/scsi_devinfo.h>
      43                 :            : #include <scsi/sg.h>
      44                 :            : 
      45                 :            : #include "scsi_priv.h"
      46                 :            : #include "scsi_logging.h"
      47                 :            : #include "scsi_transport_api.h"
      48                 :            : 
      49                 :            : #include <trace/events/scsi.h>
      50                 :            : 
      51                 :            : #include <asm/unaligned.h>
      52                 :            : 
      53                 :            : static void scsi_eh_done(struct scsi_cmnd *scmd);
      54                 :            : 
      55                 :            : /*
      56                 :            :  * These should *probably* be handled by the host itself.
      57                 :            :  * Since it is allowed to sleep, it probably should.
      58                 :            :  */
      59                 :            : #define BUS_RESET_SETTLE_TIME   (10)
      60                 :            : #define HOST_RESET_SETTLE_TIME  (10)
      61                 :            : 
      62                 :            : static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
      63                 :            : static int scsi_try_to_abort_cmd(struct scsi_host_template *,
      64                 :            :                                  struct scsi_cmnd *);
      65                 :            : 
      66                 :       1714 : void scsi_eh_wakeup(struct Scsi_Host *shost)
      67                 :            : {
      68                 :       1714 :         lockdep_assert_held(shost->host_lock);
      69                 :            : 
      70         [ +  + ]:       1714 :         if (scsi_host_busy(shost) == shost->host_failed) {
      71                 :        935 :                 trace_scsi_eh_wakeup(shost);
      72                 :        935 :                 wake_up_process(shost->ehandler);
      73                 :       1714 :                 SCSI_LOG_ERROR_RECOVERY(5, shost_printk(KERN_INFO, shost,
      74                 :       1714 :                         "Waking error handler thread\n"));
      75                 :            :         }
      76                 :       1714 : }
      77                 :            : 
      78                 :            : /**
      79                 :            :  * scsi_schedule_eh - schedule EH for SCSI host
      80                 :            :  * @shost:      SCSI host to invoke error handling on.
      81                 :            :  *
      82                 :            :  * Schedule SCSI EH without scmd.
      83                 :            :  */
      84                 :        156 : void scsi_schedule_eh(struct Scsi_Host *shost)
      85                 :            : {
      86                 :        156 :         unsigned long flags;
      87                 :            : 
      88                 :        156 :         spin_lock_irqsave(shost->host_lock, flags);
      89                 :            : 
      90   [ -  +  -  - ]:        156 :         if (scsi_host_set_state(shost, SHOST_RECOVERY) == 0 ||
      91                 :          0 :             scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY) == 0) {
      92                 :        156 :                 shost->host_eh_scheduled++;
      93                 :        156 :                 scsi_eh_wakeup(shost);
      94                 :            :         }
      95                 :            : 
      96                 :        156 :         spin_unlock_irqrestore(shost->host_lock, flags);
      97                 :        156 : }
      98                 :            : EXPORT_SYMBOL_GPL(scsi_schedule_eh);
      99                 :            : 
     100                 :        779 : static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
     101                 :            : {
     102   [ #  #  #  #  :          0 :         if (!shost->last_reset || shost->eh_deadline == -1)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     103                 :            :                 return 0;
     104                 :            : 
     105                 :            :         /*
     106                 :            :          * 32bit accesses are guaranteed to be atomic
     107                 :            :          * (on all supported architectures), so instead
     108                 :            :          * of using a spinlock we can as well double check
     109                 :            :          * if eh_deadline has been set to 'off' during the
     110                 :            :          * time_before call.
     111                 :            :          */
     112   [ #  #  #  #  :          0 :         if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     113                 :            :             shost->eh_deadline > -1)
     114                 :            :                 return 0;
     115                 :            : 
     116                 :            :         return 1;
     117                 :            : }
     118                 :            : 
     119                 :            : /**
     120                 :            :  * scmd_eh_abort_handler - Handle command aborts
     121                 :            :  * @work:       command to be aborted.
     122                 :            :  *
     123                 :            :  * Note: this function must be called only for a command that has timed out.
     124                 :            :  * Because the block layer marks a request as complete before it calls
     125                 :            :  * scsi_times_out(), a .scsi_done() call from the LLD for a command that has
     126                 :            :  * timed out do not have any effect. Hence it is safe to call
     127                 :            :  * scsi_finish_command() from this function.
     128                 :            :  */
     129                 :            : void
     130                 :        779 : scmd_eh_abort_handler(struct work_struct *work)
     131                 :            : {
     132                 :        779 :         struct scsi_cmnd *scmd =
     133                 :        779 :                 container_of(work, struct scsi_cmnd, abort_work.work);
     134                 :        779 :         struct scsi_device *sdev = scmd->device;
     135                 :        779 :         int rtn;
     136                 :            : 
     137         [ -  + ]:        779 :         if (scsi_host_eh_past_deadline(sdev->host)) {
     138                 :            :                 SCSI_LOG_ERROR_RECOVERY(3,
     139                 :            :                         scmd_printk(KERN_INFO, scmd,
     140                 :            :                                     "eh timeout, not aborting\n"));
     141                 :            :         } else {
     142                 :        779 :                 SCSI_LOG_ERROR_RECOVERY(3,
     143                 :            :                         scmd_printk(KERN_INFO, scmd,
     144                 :        779 :                                     "aborting command\n"));
     145                 :        779 :                 rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
     146         [ #  # ]:          0 :                 if (rtn == SUCCESS) {
     147         [ #  # ]:          0 :                         set_host_byte(scmd, DID_TIME_OUT);
     148         [ #  # ]:          0 :                         if (scsi_host_eh_past_deadline(sdev->host)) {
     149                 :            :                                 SCSI_LOG_ERROR_RECOVERY(3,
     150                 :            :                                         scmd_printk(KERN_INFO, scmd,
     151                 :            :                                                     "eh timeout, not retrying "
     152                 :            :                                                     "aborted command\n"));
     153         [ #  # ]:          0 :                         } else if (!scsi_noretry_cmd(scmd) &&
     154         [ #  # ]:          0 :                             (++scmd->retries <= scmd->allowed)) {
     155                 :          0 :                                 SCSI_LOG_ERROR_RECOVERY(3,
     156                 :            :                                         scmd_printk(KERN_WARNING, scmd,
     157                 :          0 :                                                     "retry aborted command\n"));
     158                 :          0 :                                 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
     159                 :          0 :                                 return;
     160                 :            :                         } else {
     161                 :          0 :                                 SCSI_LOG_ERROR_RECOVERY(3,
     162                 :            :                                         scmd_printk(KERN_WARNING, scmd,
     163                 :          0 :                                                     "finish aborted command\n"));
     164                 :          0 :                                 scsi_finish_command(scmd);
     165                 :          0 :                                 return;
     166                 :            :                         }
     167                 :            :                 } else {
     168                 :        779 :                         SCSI_LOG_ERROR_RECOVERY(3,
     169                 :            :                                 scmd_printk(KERN_INFO, scmd,
     170                 :            :                                             "cmd abort %s\n",
     171                 :            :                                             (rtn == FAST_IO_FAIL) ?
     172                 :        779 :                                             "not send" : "failed"));
     173                 :            :                 }
     174                 :            :         }
     175                 :            : 
     176                 :        779 :         scsi_eh_scmd_add(scmd);
     177                 :            : }
     178                 :            : 
     179                 :            : /**
     180                 :            :  * scsi_abort_command - schedule a command abort
     181                 :            :  * @scmd:       scmd to abort.
     182                 :            :  *
     183                 :            :  * We only need to abort commands after a command timeout
     184                 :            :  */
     185                 :            : static int
     186                 :        779 : scsi_abort_command(struct scsi_cmnd *scmd)
     187                 :            : {
     188                 :        779 :         struct scsi_device *sdev = scmd->device;
     189                 :        779 :         struct Scsi_Host *shost = sdev->host;
     190                 :        779 :         unsigned long flags;
     191                 :            : 
     192         [ -  + ]:        779 :         if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
     193                 :            :                 /*
     194                 :            :                  * Retry after abort failed, escalate to next level.
     195                 :            :                  */
     196                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3,
     197                 :            :                         scmd_printk(KERN_INFO, scmd,
     198                 :          0 :                                     "previous abort failed\n"));
     199         [ #  # ]:          0 :                 BUG_ON(delayed_work_pending(&scmd->abort_work));
     200                 :            :                 return FAILED;
     201                 :            :         }
     202                 :            : 
     203                 :        779 :         spin_lock_irqsave(shost->host_lock, flags);
     204   [ -  +  -  - ]:        779 :         if (shost->eh_deadline != -1 && !shost->last_reset)
     205                 :          0 :                 shost->last_reset = jiffies;
     206                 :        779 :         spin_unlock_irqrestore(shost->host_lock, flags);
     207                 :            : 
     208                 :        779 :         scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
     209                 :        779 :         SCSI_LOG_ERROR_RECOVERY(3,
     210                 :        779 :                 scmd_printk(KERN_INFO, scmd, "abort scheduled\n"));
     211                 :        779 :         queue_delayed_work(shost->tmf_work_q, &scmd->abort_work, HZ / 100);
     212                 :        779 :         return SUCCESS;
     213                 :            : }
     214                 :            : 
     215                 :            : /**
     216                 :            :  * scsi_eh_reset - call into ->eh_action to reset internal counters
     217                 :            :  * @scmd:       scmd to run eh on.
     218                 :            :  *
     219                 :            :  * The scsi driver might be carrying internal state about the
     220                 :            :  * devices, so we need to call into the driver to reset the
     221                 :            :  * internal state once the error handler is started.
     222                 :            :  */
     223                 :        779 : static void scsi_eh_reset(struct scsi_cmnd *scmd)
     224                 :            : {
     225   [ -  +  -  + ]:        779 :         if (!blk_rq_is_passthrough(scmd->request)) {
     226         [ #  # ]:          0 :                 struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
     227         [ #  # ]:          0 :                 if (sdrv->eh_reset)
     228                 :          0 :                         sdrv->eh_reset(scmd);
     229                 :            :         }
     230                 :        779 : }
     231                 :            : 
     232                 :        779 : static void scsi_eh_inc_host_failed(struct rcu_head *head)
     233                 :            : {
     234                 :        779 :         struct scsi_cmnd *scmd = container_of(head, typeof(*scmd), rcu);
     235                 :        779 :         struct Scsi_Host *shost = scmd->device->host;
     236                 :        779 :         unsigned long flags;
     237                 :            : 
     238                 :        779 :         spin_lock_irqsave(shost->host_lock, flags);
     239                 :        779 :         shost->host_failed++;
     240                 :        779 :         scsi_eh_wakeup(shost);
     241                 :        779 :         spin_unlock_irqrestore(shost->host_lock, flags);
     242                 :        779 : }
     243                 :            : 
     244                 :            : /**
     245                 :            :  * scsi_eh_scmd_add - add scsi cmd to error handling.
     246                 :            :  * @scmd:       scmd to run eh on.
     247                 :            :  */
     248                 :        779 : void scsi_eh_scmd_add(struct scsi_cmnd *scmd)
     249                 :            : {
     250                 :        779 :         struct Scsi_Host *shost = scmd->device->host;
     251                 :        779 :         unsigned long flags;
     252                 :        779 :         int ret;
     253                 :            : 
     254         [ -  + ]:        779 :         WARN_ON_ONCE(!shost->ehandler);
     255                 :            : 
     256                 :        779 :         spin_lock_irqsave(shost->host_lock, flags);
     257         [ -  + ]:        779 :         if (scsi_host_set_state(shost, SHOST_RECOVERY)) {
     258                 :          0 :                 ret = scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY);
     259         [ #  # ]:          0 :                 WARN_ON_ONCE(ret);
     260                 :            :         }
     261   [ -  +  -  - ]:        779 :         if (shost->eh_deadline != -1 && !shost->last_reset)
     262                 :          0 :                 shost->last_reset = jiffies;
     263                 :            : 
     264                 :        779 :         scsi_eh_reset(scmd);
     265                 :        779 :         list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
     266                 :        779 :         spin_unlock_irqrestore(shost->host_lock, flags);
     267                 :            :         /*
     268                 :            :          * Ensure that all tasks observe the host state change before the
     269                 :            :          * host_failed change.
     270                 :            :          */
     271                 :        779 :         call_rcu(&scmd->rcu, scsi_eh_inc_host_failed);
     272                 :        779 : }
     273                 :            : 
     274                 :            : /**
     275                 :            :  * scsi_times_out - Timeout function for normal scsi commands.
     276                 :            :  * @req:        request that is timing out.
     277                 :            :  *
     278                 :            :  * Notes:
     279                 :            :  *     We do not need to lock this.  There is the potential for a race
     280                 :            :  *     only in that the normal completion handling might run, but if the
     281                 :            :  *     normal completion function determines that the timer has already
     282                 :            :  *     fired, then it mustn't do anything.
     283                 :            :  */
     284                 :        779 : enum blk_eh_timer_return scsi_times_out(struct request *req)
     285                 :            : {
     286                 :        779 :         struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
     287                 :        779 :         enum blk_eh_timer_return rtn = BLK_EH_DONE;
     288                 :        779 :         struct Scsi_Host *host = scmd->device->host;
     289                 :            : 
     290                 :        779 :         trace_scsi_dispatch_cmd_timeout(scmd);
     291         [ -  + ]:        779 :         scsi_log_completion(scmd, TIMEOUT_ERROR);
     292                 :            : 
     293   [ -  +  -  - ]:        779 :         if (host->eh_deadline != -1 && !host->last_reset)
     294                 :          0 :                 host->last_reset = jiffies;
     295                 :            : 
     296         [ -  + ]:        779 :         if (host->hostt->eh_timed_out)
     297                 :          0 :                 rtn = host->hostt->eh_timed_out(scmd);
     298                 :            : 
     299         [ #  # ]:          0 :         if (rtn == BLK_EH_DONE) {
     300                 :            :                 /*
     301                 :            :                  * Set the command to complete first in order to prevent a real
     302                 :            :                  * completion from releasing the command while error handling
     303                 :            :                  * is using it. If the command was already completed, then the
     304                 :            :                  * lower level driver beat the timeout handler, and it is safe
     305                 :            :                  * to return without escalating error recovery.
     306                 :            :                  *
     307                 :            :                  * If timeout handling lost the race to a real completion, the
     308                 :            :                  * block layer may ignore that due to a fake timeout injection,
     309                 :            :                  * so return RESET_TIMER to allow error handling another shot
     310                 :            :                  * at this command.
     311                 :            :                  */
     312         [ +  - ]:        779 :                 if (test_and_set_bit(SCMD_STATE_COMPLETE, &scmd->state))
     313                 :            :                         return BLK_EH_RESET_TIMER;
     314         [ -  + ]:        779 :                 if (scsi_abort_command(scmd) != SUCCESS) {
     315                 :          0 :                         set_host_byte(scmd, DID_TIME_OUT);
     316                 :          0 :                         scsi_eh_scmd_add(scmd);
     317                 :            :                 }
     318                 :            :         }
     319                 :            : 
     320                 :            :         return rtn;
     321                 :            : }
     322                 :            : 
     323                 :            : /**
     324                 :            :  * scsi_block_when_processing_errors - Prevent cmds from being queued.
     325                 :            :  * @sdev:       Device on which we are performing recovery.
     326                 :            :  *
     327                 :            :  * Description:
     328                 :            :  *     We block until the host is out of error recovery, and then check to
     329                 :            :  *     see whether the host or the device is offline.
     330                 :            :  *
     331                 :            :  * Return value:
     332                 :            :  *     0 when dev was taken offline by error recovery. 1 OK to proceed.
     333                 :            :  */
     334                 :       2886 : int scsi_block_when_processing_errors(struct scsi_device *sdev)
     335                 :            : {
     336                 :       2886 :         int online;
     337                 :            : 
     338   [ +  -  -  - ]:       2886 :         wait_event(sdev->host->host_wait, !scsi_host_in_recovery(sdev->host));
     339                 :            : 
     340                 :       2886 :         online = scsi_device_online(sdev);
     341                 :            : 
     342                 :       2886 :         return online;
     343                 :            : }
     344                 :            : EXPORT_SYMBOL(scsi_block_when_processing_errors);
     345                 :            : 
     346                 :            : #ifdef CONFIG_SCSI_LOGGING
     347                 :            : /**
     348                 :            :  * scsi_eh_prt_fail_stats - Log info on failures.
     349                 :            :  * @shost:      scsi host being recovered.
     350                 :            :  * @work_q:     Queue of scsi cmds to process.
     351                 :            :  */
     352                 :            : static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
     353                 :            :                                           struct list_head *work_q)
     354                 :            : {
     355                 :            :         struct scsi_cmnd *scmd;
     356                 :            :         struct scsi_device *sdev;
     357                 :            :         int total_failures = 0;
     358                 :            :         int cmd_failed = 0;
     359                 :            :         int cmd_cancel = 0;
     360                 :            :         int devices_failed = 0;
     361                 :            : 
     362                 :            :         shost_for_each_device(sdev, shost) {
     363                 :            :                 list_for_each_entry(scmd, work_q, eh_entry) {
     364                 :            :                         if (scmd->device == sdev) {
     365                 :            :                                 ++total_failures;
     366                 :            :                                 if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
     367                 :            :                                         ++cmd_cancel;
     368                 :            :                                 else
     369                 :            :                                         ++cmd_failed;
     370                 :            :                         }
     371                 :            :                 }
     372                 :            : 
     373                 :            :                 if (cmd_cancel || cmd_failed) {
     374                 :            :                         SCSI_LOG_ERROR_RECOVERY(3,
     375                 :            :                                 shost_printk(KERN_INFO, shost,
     376                 :            :                                             "%s: cmds failed: %d, cancel: %d\n",
     377                 :            :                                             __func__, cmd_failed,
     378                 :            :                                             cmd_cancel));
     379                 :            :                         cmd_cancel = 0;
     380                 :            :                         cmd_failed = 0;
     381                 :            :                         ++devices_failed;
     382                 :            :                 }
     383                 :            :         }
     384                 :            : 
     385                 :            :         SCSI_LOG_ERROR_RECOVERY(2, shost_printk(KERN_INFO, shost,
     386                 :            :                                    "Total of %d commands on %d"
     387                 :            :                                    " devices require eh work\n",
     388                 :            :                                    total_failures, devices_failed));
     389                 :            : }
     390                 :            : #endif
     391                 :            : 
     392                 :            :  /**
     393                 :            :  * scsi_report_lun_change - Set flag on all *other* devices on the same target
     394                 :            :  *                          to indicate that a UNIT ATTENTION is expected.
     395                 :            :  * @sdev:       Device reporting the UNIT ATTENTION
     396                 :            :  */
     397                 :          0 : static void scsi_report_lun_change(struct scsi_device *sdev)
     398                 :            : {
     399                 :          0 :         sdev->sdev_target->expecting_lun_change = 1;
     400                 :            : }
     401                 :            : 
     402                 :            : /**
     403                 :            :  * scsi_report_sense - Examine scsi sense information and log messages for
     404                 :            :  *                     certain conditions, also issue uevents for some of them.
     405                 :            :  * @sdev:       Device reporting the sense code
     406                 :            :  * @sshdr:      sshdr to be examined
     407                 :            :  */
     408                 :       1013 : static void scsi_report_sense(struct scsi_device *sdev,
     409                 :            :                               struct scsi_sense_hdr *sshdr)
     410                 :            : {
     411                 :       1013 :         enum scsi_device_event evt_type = SDEV_EVT_MAXBITS;     /* i.e. none */
     412                 :            : 
     413         [ -  + ]:       1013 :         if (sshdr->sense_key == UNIT_ATTENTION) {
     414   [ #  #  #  # ]:          0 :                 if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
     415                 :          0 :                         evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
     416                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     417                 :            :                                     "Inquiry data has changed");
     418   [ #  #  #  # ]:          0 :                 } else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
     419                 :          0 :                         evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
     420                 :          0 :                         scsi_report_lun_change(sdev);
     421                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     422                 :            :                                     "Warning! Received an indication that the "
     423                 :            :                                     "LUN assignments on this target have "
     424                 :            :                                     "changed. The Linux SCSI layer does not "
     425                 :            :                                     "automatically remap LUN assignments.\n");
     426         [ #  # ]:          0 :                 } else if (sshdr->asc == 0x3f)
     427                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     428                 :            :                                     "Warning! Received an indication that the "
     429                 :            :                                     "operating parameters on this target have "
     430                 :            :                                     "changed. The Linux SCSI layer does not "
     431                 :            :                                     "automatically adjust these parameters.\n");
     432                 :            : 
     433   [ #  #  #  # ]:          0 :                 if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
     434                 :          0 :                         evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
     435                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     436                 :            :                                     "Warning! Received an indication that the "
     437                 :            :                                     "LUN reached a thin provisioning soft "
     438                 :            :                                     "threshold.\n");
     439                 :            :                 }
     440                 :            : 
     441         [ #  # ]:          0 :                 if (sshdr->asc == 0x29) {
     442                 :          0 :                         evt_type = SDEV_EVT_POWER_ON_RESET_OCCURRED;
     443                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     444                 :            :                                     "Power-on or device reset occurred\n");
     445                 :            :                 }
     446                 :            : 
     447   [ #  #  #  # ]:          0 :                 if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
     448                 :          0 :                         evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
     449                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     450                 :            :                                     "Mode parameters changed");
     451   [ #  #  #  # ]:          0 :                 } else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
     452                 :          0 :                         evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
     453                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     454                 :            :                                     "Asymmetric access state changed");
     455   [ #  #  #  # ]:          0 :                 } else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
     456                 :          0 :                         evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
     457                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     458                 :            :                                     "Capacity data has changed");
     459         [ #  # ]:          0 :                 } else if (sshdr->asc == 0x2a)
     460                 :          0 :                         sdev_printk(KERN_WARNING, sdev,
     461                 :            :                                     "Parameters changed");
     462                 :            :         }
     463                 :            : 
     464         [ #  # ]:          0 :         if (evt_type != SDEV_EVT_MAXBITS) {
     465                 :          0 :                 set_bit(evt_type, sdev->pending_events);
     466                 :          0 :                 schedule_work(&sdev->event_work);
     467                 :            :         }
     468                 :       1013 : }
     469                 :            : 
     470                 :            : /**
     471                 :            :  * scsi_check_sense - Examine scsi cmd sense
     472                 :            :  * @scmd:       Cmd to have sense checked.
     473                 :            :  *
     474                 :            :  * Return value:
     475                 :            :  *      SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE
     476                 :            :  *
     477                 :            :  * Notes:
     478                 :            :  *      When a deferred error is detected the current command has
     479                 :            :  *      not been executed and needs retrying.
     480                 :            :  */
     481                 :       1013 : int scsi_check_sense(struct scsi_cmnd *scmd)
     482                 :            : {
     483                 :       1013 :         struct scsi_device *sdev = scmd->device;
     484                 :       1013 :         struct scsi_sense_hdr sshdr;
     485                 :            : 
     486         [ +  - ]:       1013 :         if (! scsi_command_normalize_sense(scmd, &sshdr))
     487                 :            :                 return FAILED;  /* no valid sense data */
     488                 :            : 
     489                 :       1013 :         scsi_report_sense(sdev, &sshdr);
     490                 :            : 
     491   [ +  -  +  - ]:       2026 :         if (scsi_sense_is_deferred(&sshdr))
     492                 :            :                 return NEEDS_RETRY;
     493                 :            : 
     494   [ -  +  -  - ]:       1013 :         if (sdev->handler && sdev->handler->check_sense) {
     495                 :          0 :                 int rc;
     496                 :            : 
     497                 :          0 :                 rc = sdev->handler->check_sense(sdev, &sshdr);
     498         [ #  # ]:          0 :                 if (rc != SCSI_RETURN_NOT_HANDLED)
     499                 :            :                         return rc;
     500                 :            :                 /* handler does not care. Drop down to default handling */
     501                 :            :         }
     502                 :            : 
     503   [ +  +  -  + ]:       1013 :         if (scmd->cmnd[0] == TEST_UNIT_READY && scmd->scsi_done != scsi_eh_done)
     504                 :            :                 /*
     505                 :            :                  * nasty: for mid-layer issued TURs, we need to return the
     506                 :            :                  * actual sense data without any recovery attempt.  For eh
     507                 :            :                  * issued ones, we need to try to recover and interpret
     508                 :            :                  */
     509                 :            :                 return SUCCESS;
     510                 :            : 
     511                 :            :         /*
     512                 :            :          * Previous logic looked for FILEMARK, EOM or ILI which are
     513                 :            :          * mainly associated with tapes and returned SUCCESS.
     514                 :            :          */
     515         [ -  + ]:        234 :         if (sshdr.response_code == 0x70) {
     516                 :            :                 /* fixed format */
     517         [ #  # ]:          0 :                 if (scmd->sense_buffer[2] & 0xe0)
     518                 :            :                         return SUCCESS;
     519                 :            :         } else {
     520                 :            :                 /*
     521                 :            :                  * descriptor format: look for "stream commands sense data
     522                 :            :                  * descriptor" (see SSC-3). Assume single sense data
     523                 :            :                  * descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
     524                 :            :                  */
     525         [ +  - ]:        234 :                 if ((sshdr.additional_length > 3) &&
     526         [ -  + ]:        234 :                     (scmd->sense_buffer[8] == 0x4) &&
     527         [ #  # ]:          0 :                     (scmd->sense_buffer[11] & 0xe0))
     528                 :            :                         return SUCCESS;
     529                 :            :         }
     530                 :            : 
     531   [ -  -  -  -  :        234 :         switch (sshdr.sense_key) {
             -  -  -  + ]
     532                 :            :         case NO_SENSE:
     533                 :            :                 return SUCCESS;
     534                 :            :         case RECOVERED_ERROR:
     535                 :            :                 return /* soft_error */ SUCCESS;
     536                 :            : 
     537                 :          0 :         case ABORTED_COMMAND:
     538         [ #  # ]:          0 :                 if (sshdr.asc == 0x10) /* DIF */
     539                 :            :                         return SUCCESS;
     540                 :            : 
     541   [ #  #  #  # ]:          0 :                 if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF)
     542                 :            :                         return ADD_TO_MLQUEUE;
     543   [ #  #  #  # ]:          0 :                 if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
     544         [ #  # ]:          0 :                     sdev->sdev_bflags & BLIST_RETRY_ASC_C1)
     545                 :          0 :                         return ADD_TO_MLQUEUE;
     546                 :            : 
     547                 :            :                 return NEEDS_RETRY;
     548                 :          0 :         case NOT_READY:
     549                 :            :         case UNIT_ATTENTION:
     550                 :            :                 /*
     551                 :            :                  * if we are expecting a cc/ua because of a bus reset that we
     552                 :            :                  * performed, treat this just as a retry.  otherwise this is
     553                 :            :                  * information that we should pass up to the upper-level driver
     554                 :            :                  * so that we can deal with it there.
     555                 :            :                  */
     556         [ #  # ]:          0 :                 if (scmd->device->expecting_cc_ua) {
     557                 :            :                         /*
     558                 :            :                          * Because some device does not queue unit
     559                 :            :                          * attentions correctly, we carefully check
     560                 :            :                          * additional sense code and qualifier so as
     561                 :            :                          * not to squash media change unit attention.
     562                 :            :                          */
     563   [ #  #  #  # ]:          0 :                         if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
     564                 :          0 :                                 scmd->device->expecting_cc_ua = 0;
     565                 :          0 :                                 return NEEDS_RETRY;
     566                 :            :                         }
     567                 :            :                 }
     568                 :            :                 /*
     569                 :            :                  * we might also expect a cc/ua if another LUN on the target
     570                 :            :                  * reported a UA with an ASC/ASCQ of 3F 0E -
     571                 :            :                  * REPORTED LUNS DATA HAS CHANGED.
     572                 :            :                  */
     573         [ #  # ]:          0 :                 if (scmd->device->sdev_target->expecting_lun_change &&
     574   [ #  #  #  # ]:          0 :                     sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
     575                 :            :                         return NEEDS_RETRY;
     576                 :            :                 /*
     577                 :            :                  * if the device is in the process of becoming ready, we
     578                 :            :                  * should retry.
     579                 :            :                  */
     580   [ #  #  #  # ]:          0 :                 if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
     581                 :            :                         return NEEDS_RETRY;
     582                 :            :                 /*
     583                 :            :                  * if the device is not started, we need to wake
     584                 :            :                  * the error handler to start the motor
     585                 :            :                  */
     586   [ #  #  #  # ]:          0 :                 if (scmd->device->allow_restart &&
     587         [ #  # ]:          0 :                     (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
     588                 :          0 :                         return FAILED;
     589                 :            :                 /*
     590                 :            :                  * Pass the UA upwards for a determination in the completion
     591                 :            :                  * functions.
     592                 :            :                  */
     593                 :            :                 return SUCCESS;
     594                 :            : 
     595                 :            :                 /* these are not supported */
     596                 :          0 :         case DATA_PROTECT:
     597   [ #  #  #  # ]:          0 :                 if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
     598                 :            :                         /* Thin provisioning hard threshold reached */
     599                 :          0 :                         set_host_byte(scmd, DID_ALLOC_FAILURE);
     600                 :          0 :                         return SUCCESS;
     601                 :            :                 }
     602                 :            :                 /* FALLTHROUGH */
     603                 :            :         case COPY_ABORTED:
     604                 :            :         case VOLUME_OVERFLOW:
     605                 :            :         case MISCOMPARE:
     606                 :            :         case BLANK_CHECK:
     607                 :          0 :                 set_host_byte(scmd, DID_TARGET_FAILURE);
     608                 :          0 :                 return SUCCESS;
     609                 :            : 
     610                 :          0 :         case MEDIUM_ERROR:
     611         [ #  # ]:          0 :                 if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
     612         [ #  # ]:          0 :                     sshdr.asc == 0x13 || /* AMNF DATA FIELD */
     613                 :            :                     sshdr.asc == 0x14) { /* RECORD NOT FOUND */
     614                 :          0 :                         set_host_byte(scmd, DID_MEDIUM_ERROR);
     615                 :          0 :                         return SUCCESS;
     616                 :            :                 }
     617                 :            :                 return NEEDS_RETRY;
     618                 :            : 
     619                 :          0 :         case HARDWARE_ERROR:
     620         [ #  # ]:          0 :                 if (scmd->device->retry_hwerror)
     621                 :            :                         return ADD_TO_MLQUEUE;
     622                 :            :                 else
     623                 :          0 :                         set_host_byte(scmd, DID_TARGET_FAILURE);
     624                 :            :                 /* FALLTHROUGH */
     625                 :            : 
     626                 :          0 :         case ILLEGAL_REQUEST:
     627                 :          0 :                 if (sshdr.asc == 0x20 || /* Invalid command operation code */
     628                 :            :                     sshdr.asc == 0x21 || /* Logical block address out of range */
     629         [ #  # ]:          0 :                     sshdr.asc == 0x22 || /* Invalid function */
     630         [ #  # ]:          0 :                     sshdr.asc == 0x24 || /* Invalid field in cdb */
     631         [ #  # ]:          0 :                     sshdr.asc == 0x26 || /* Parameter value invalid */
     632                 :            :                     sshdr.asc == 0x27) { /* Write protected */
     633                 :          0 :                         set_host_byte(scmd, DID_TARGET_FAILURE);
     634                 :            :                 }
     635                 :            :                 return SUCCESS;
     636                 :            : 
     637                 :            :         default:
     638                 :            :                 return SUCCESS;
     639                 :            :         }
     640                 :            : }
     641                 :            : EXPORT_SYMBOL_GPL(scsi_check_sense);
     642                 :            : 
     643                 :      86696 : static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
     644                 :            : {
     645                 :      86696 :         struct scsi_host_template *sht = sdev->host->hostt;
     646                 :      86696 :         struct scsi_device *tmp_sdev;
     647                 :            : 
     648         [ -  + ]:      86696 :         if (!sht->track_queue_depth ||
     649         [ #  # ]:          0 :             sdev->queue_depth >= sdev->max_queue_depth)
     650                 :            :                 return;
     651                 :            : 
     652         [ #  # ]:          0 :         if (time_before(jiffies,
     653                 :            :             sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
     654                 :            :                 return;
     655                 :            : 
     656         [ #  # ]:          0 :         if (time_before(jiffies,
     657                 :            :             sdev->last_queue_full_time + sdev->queue_ramp_up_period))
     658                 :            :                 return;
     659                 :            : 
     660                 :            :         /*
     661                 :            :          * Walk all devices of a target and do
     662                 :            :          * ramp up on them.
     663                 :            :          */
     664         [ #  # ]:          0 :         shost_for_each_device(tmp_sdev, sdev->host) {
     665         [ #  # ]:          0 :                 if (tmp_sdev->channel != sdev->channel ||
     666                 :          0 :                     tmp_sdev->id != sdev->id ||
     667         [ #  # ]:          0 :                     tmp_sdev->queue_depth == sdev->max_queue_depth)
     668                 :          0 :                         continue;
     669                 :            : 
     670                 :          0 :                 scsi_change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1);
     671                 :          0 :                 sdev->last_queue_ramp_up = jiffies;
     672                 :            :         }
     673                 :            : }
     674                 :            : 
     675                 :          0 : static void scsi_handle_queue_full(struct scsi_device *sdev)
     676                 :            : {
     677                 :          0 :         struct scsi_host_template *sht = sdev->host->hostt;
     678                 :          0 :         struct scsi_device *tmp_sdev;
     679                 :            : 
     680         [ #  # ]:          0 :         if (!sht->track_queue_depth)
     681                 :            :                 return;
     682                 :            : 
     683         [ #  # ]:          0 :         shost_for_each_device(tmp_sdev, sdev->host) {
     684         [ #  # ]:          0 :                 if (tmp_sdev->channel != sdev->channel ||
     685                 :            :                     tmp_sdev->id != sdev->id)
     686                 :          0 :                         continue;
     687                 :            :                 /*
     688                 :            :                  * We do not know the number of commands that were at
     689                 :            :                  * the device when we got the queue full so we start
     690                 :            :                  * from the highest possible value and work our way down.
     691                 :            :                  */
     692                 :          0 :                 scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
     693                 :            :         }
     694                 :            : }
     695                 :            : 
     696                 :            : /**
     697                 :            :  * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
     698                 :            :  * @scmd:       SCSI cmd to examine.
     699                 :            :  *
     700                 :            :  * Notes:
     701                 :            :  *    This is *only* called when we are examining the status of commands
     702                 :            :  *    queued during error recovery.  the main difference here is that we
     703                 :            :  *    don't allow for the possibility of retries here, and we are a lot
     704                 :            :  *    more restrictive about what we consider acceptable.
     705                 :            :  */
     706                 :          0 : static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
     707                 :            : {
     708                 :            :         /*
     709                 :            :          * first check the host byte, to see if there is anything in there
     710                 :            :          * that would indicate what we need to do.
     711                 :            :          */
     712         [ #  # ]:          0 :         if (host_byte(scmd->result) == DID_RESET) {
     713                 :            :                 /*
     714                 :            :                  * rats.  we are already in the error handler, so we now
     715                 :            :                  * get to try and figure out what to do next.  if the sense
     716                 :            :                  * is valid, we have a pretty good idea of what to do.
     717                 :            :                  * if not, we mark it as FAILED.
     718                 :            :                  */
     719                 :          0 :                 return scsi_check_sense(scmd);
     720                 :            :         }
     721         [ #  # ]:          0 :         if (host_byte(scmd->result) != DID_OK)
     722                 :            :                 return FAILED;
     723                 :            : 
     724                 :            :         /*
     725                 :            :          * next, check the message byte.
     726                 :            :          */
     727         [ #  # ]:          0 :         if (msg_byte(scmd->result) != COMMAND_COMPLETE)
     728                 :            :                 return FAILED;
     729                 :            : 
     730                 :            :         /*
     731                 :            :          * now, check the status byte to see if this indicates
     732                 :            :          * anything special.
     733                 :            :          */
     734   [ #  #  #  #  :          0 :         switch (status_byte(scmd->result)) {
                #  #  # ]
     735                 :          0 :         case GOOD:
     736                 :          0 :                 scsi_handle_queue_ramp_up(scmd->device);
     737                 :            :                 /* FALLTHROUGH */
     738                 :            :         case COMMAND_TERMINATED:
     739                 :            :                 return SUCCESS;
     740                 :          0 :         case CHECK_CONDITION:
     741                 :          0 :                 return scsi_check_sense(scmd);
     742                 :            :         case CONDITION_GOOD:
     743                 :            :         case INTERMEDIATE_GOOD:
     744                 :            :         case INTERMEDIATE_C_GOOD:
     745                 :            :                 /*
     746                 :            :                  * who knows?  FIXME(eric)
     747                 :            :                  */
     748                 :            :                 return SUCCESS;
     749                 :          0 :         case RESERVATION_CONFLICT:
     750         [ #  # ]:          0 :                 if (scmd->cmnd[0] == TEST_UNIT_READY)
     751                 :            :                         /* it is a success, we probed the device and
     752                 :            :                          * found it */
     753                 :          0 :                         return SUCCESS;
     754                 :            :                 /* otherwise, we failed to send the command */
     755                 :            :                 return FAILED;
     756                 :          0 :         case QUEUE_FULL:
     757                 :          0 :                 scsi_handle_queue_full(scmd->device);
     758                 :            :                 /* fall through */
     759                 :            :         case BUSY:
     760                 :            :                 return NEEDS_RETRY;
     761                 :          0 :         default:
     762                 :          0 :                 return FAILED;
     763                 :            :         }
     764                 :            :         return FAILED;
     765                 :            : }
     766                 :            : 
     767                 :            : /**
     768                 :            :  * scsi_eh_done - Completion function for error handling.
     769                 :            :  * @scmd:       Cmd that is done.
     770                 :            :  */
     771                 :          0 : static void scsi_eh_done(struct scsi_cmnd *scmd)
     772                 :            : {
     773                 :          0 :         struct completion *eh_action;
     774                 :            : 
     775                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
     776                 :          0 :                         "%s result: %x\n", __func__, scmd->result));
     777                 :            : 
     778                 :          0 :         eh_action = scmd->device->host->eh_action;
     779         [ #  # ]:          0 :         if (eh_action)
     780                 :          0 :                 complete(eh_action);
     781                 :          0 : }
     782                 :            : 
     783                 :            : /**
     784                 :            :  * scsi_try_host_reset - ask host adapter to reset itself
     785                 :            :  * @scmd:       SCSI cmd to send host reset.
     786                 :            :  */
     787                 :          0 : static int scsi_try_host_reset(struct scsi_cmnd *scmd)
     788                 :            : {
     789                 :          0 :         unsigned long flags;
     790                 :          0 :         int rtn;
     791                 :          0 :         struct Scsi_Host *host = scmd->device->host;
     792                 :          0 :         struct scsi_host_template *hostt = host->hostt;
     793                 :            : 
     794                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3,
     795                 :          0 :                 shost_printk(KERN_INFO, host, "Snd Host RST\n"));
     796                 :            : 
     797         [ #  # ]:          0 :         if (!hostt->eh_host_reset_handler)
     798                 :            :                 return FAILED;
     799                 :            : 
     800                 :          0 :         rtn = hostt->eh_host_reset_handler(scmd);
     801                 :            : 
     802         [ #  # ]:          0 :         if (rtn == SUCCESS) {
     803         [ #  # ]:          0 :                 if (!hostt->skip_settle_delay)
     804                 :          0 :                         ssleep(HOST_RESET_SETTLE_TIME);
     805                 :          0 :                 spin_lock_irqsave(host->host_lock, flags);
     806                 :          0 :                 scsi_report_bus_reset(host, scmd_channel(scmd));
     807                 :          0 :                 spin_unlock_irqrestore(host->host_lock, flags);
     808                 :            :         }
     809                 :            : 
     810                 :            :         return rtn;
     811                 :            : }
     812                 :            : 
     813                 :            : /**
     814                 :            :  * scsi_try_bus_reset - ask host to perform a bus reset
     815                 :            :  * @scmd:       SCSI cmd to send bus reset.
     816                 :            :  */
     817                 :          0 : static int scsi_try_bus_reset(struct scsi_cmnd *scmd)
     818                 :            : {
     819                 :          0 :         unsigned long flags;
     820                 :          0 :         int rtn;
     821                 :          0 :         struct Scsi_Host *host = scmd->device->host;
     822                 :          0 :         struct scsi_host_template *hostt = host->hostt;
     823                 :            : 
     824                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
     825                 :          0 :                 "%s: Snd Bus RST\n", __func__));
     826                 :            : 
     827         [ #  # ]:          0 :         if (!hostt->eh_bus_reset_handler)
     828                 :            :                 return FAILED;
     829                 :            : 
     830                 :          0 :         rtn = hostt->eh_bus_reset_handler(scmd);
     831                 :            : 
     832         [ #  # ]:          0 :         if (rtn == SUCCESS) {
     833         [ #  # ]:          0 :                 if (!hostt->skip_settle_delay)
     834                 :          0 :                         ssleep(BUS_RESET_SETTLE_TIME);
     835                 :          0 :                 spin_lock_irqsave(host->host_lock, flags);
     836                 :          0 :                 scsi_report_bus_reset(host, scmd_channel(scmd));
     837                 :          0 :                 spin_unlock_irqrestore(host->host_lock, flags);
     838                 :            :         }
     839                 :            : 
     840                 :            :         return rtn;
     841                 :            : }
     842                 :            : 
     843                 :          0 : static void __scsi_report_device_reset(struct scsi_device *sdev, void *data)
     844                 :            : {
     845                 :          0 :         sdev->was_reset = 1;
     846                 :          0 :         sdev->expecting_cc_ua = 1;
     847                 :          0 : }
     848                 :            : 
     849                 :            : /**
     850                 :            :  * scsi_try_target_reset - Ask host to perform a target reset
     851                 :            :  * @scmd:       SCSI cmd used to send a target reset
     852                 :            :  *
     853                 :            :  * Notes:
     854                 :            :  *    There is no timeout for this operation.  if this operation is
     855                 :            :  *    unreliable for a given host, then the host itself needs to put a
     856                 :            :  *    timer on it, and set the host back to a consistent state prior to
     857                 :            :  *    returning.
     858                 :            :  */
     859                 :          0 : static int scsi_try_target_reset(struct scsi_cmnd *scmd)
     860                 :            : {
     861                 :          0 :         unsigned long flags;
     862                 :          0 :         int rtn;
     863                 :          0 :         struct Scsi_Host *host = scmd->device->host;
     864                 :          0 :         struct scsi_host_template *hostt = host->hostt;
     865                 :            : 
     866         [ #  # ]:          0 :         if (!hostt->eh_target_reset_handler)
     867                 :            :                 return FAILED;
     868                 :            : 
     869                 :          0 :         rtn = hostt->eh_target_reset_handler(scmd);
     870         [ #  # ]:          0 :         if (rtn == SUCCESS) {
     871                 :          0 :                 spin_lock_irqsave(host->host_lock, flags);
     872                 :          0 :                 __starget_for_each_device(scsi_target(scmd->device), NULL,
     873                 :            :                                           __scsi_report_device_reset);
     874                 :          0 :                 spin_unlock_irqrestore(host->host_lock, flags);
     875                 :            :         }
     876                 :            : 
     877                 :            :         return rtn;
     878                 :            : }
     879                 :            : 
     880                 :            : /**
     881                 :            :  * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
     882                 :            :  * @scmd:       SCSI cmd used to send BDR
     883                 :            :  *
     884                 :            :  * Notes:
     885                 :            :  *    There is no timeout for this operation.  if this operation is
     886                 :            :  *    unreliable for a given host, then the host itself needs to put a
     887                 :            :  *    timer on it, and set the host back to a consistent state prior to
     888                 :            :  *    returning.
     889                 :            :  */
     890                 :          0 : static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
     891                 :            : {
     892                 :          0 :         int rtn;
     893                 :          0 :         struct scsi_host_template *hostt = scmd->device->host->hostt;
     894                 :            : 
     895                 :          0 :         if (!hostt->eh_device_reset_handler)
     896                 :            :                 return FAILED;
     897                 :            : 
     898                 :          0 :         rtn = hostt->eh_device_reset_handler(scmd);
     899   [ #  #  #  #  :          0 :         if (rtn == SUCCESS)
                   #  # ]
     900                 :          0 :                 __scsi_report_device_reset(scmd->device, NULL);
     901                 :            :         return rtn;
     902                 :            : }
     903                 :            : 
     904                 :            : /**
     905                 :            :  * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
     906                 :            :  * @hostt:      SCSI driver host template
     907                 :            :  * @scmd:       SCSI cmd used to send a target reset
     908                 :            :  *
     909                 :            :  * Return value:
     910                 :            :  *      SUCCESS, FAILED, or FAST_IO_FAIL
     911                 :            :  *
     912                 :            :  * Notes:
     913                 :            :  *    SUCCESS does not necessarily indicate that the command
     914                 :            :  *    has been aborted; it only indicates that the LLDDs
     915                 :            :  *    has cleared all references to that command.
     916                 :            :  *    LLDDs should return FAILED only if an abort was required
     917                 :            :  *    but could not be executed. LLDDs should return FAST_IO_FAIL
     918                 :            :  *    if the device is temporarily unavailable (eg due to a
     919                 :            :  *    link down on FibreChannel)
     920                 :            :  */
     921                 :        779 : static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt,
     922                 :            :                                  struct scsi_cmnd *scmd)
     923                 :            : {
     924         [ -  + ]:        779 :         if (!hostt->eh_abort_handler)
     925                 :            :                 return FAILED;
     926                 :            : 
     927                 :          0 :         return hostt->eh_abort_handler(scmd);
     928                 :            : }
     929                 :            : 
     930                 :          0 : static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)
     931                 :            : {
     932   [ #  #  #  # ]:          0 :         if (scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd) != SUCCESS)
     933   [ #  #  #  # ]:          0 :                 if (scsi_try_bus_device_reset(scmd) != SUCCESS)
     934         [ #  # ]:          0 :                         if (scsi_try_target_reset(scmd) != SUCCESS)
     935         [ #  # ]:          0 :                                 if (scsi_try_bus_reset(scmd) != SUCCESS)
     936                 :          0 :                                         scsi_try_host_reset(scmd);
     937                 :          0 : }
     938                 :            : 
     939                 :            : /**
     940                 :            :  * scsi_eh_prep_cmnd  - Save a scsi command info as part of error recovery
     941                 :            :  * @scmd:       SCSI command structure to hijack
     942                 :            :  * @ses:        structure to save restore information
     943                 :            :  * @cmnd:       CDB to send. Can be NULL if no new cmnd is needed
     944                 :            :  * @cmnd_size:  size in bytes of @cmnd (must be <= BLK_MAX_CDB)
     945                 :            :  * @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
     946                 :            :  *
     947                 :            :  * This function is used to save a scsi command information before re-execution
     948                 :            :  * as part of the error recovery process.  If @sense_bytes is 0 the command
     949                 :            :  * sent must be one that does not transfer any data.  If @sense_bytes != 0
     950                 :            :  * @cmnd is ignored and this functions sets up a REQUEST_SENSE command
     951                 :            :  * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
     952                 :            :  */
     953                 :          0 : void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses,
     954                 :            :                         unsigned char *cmnd, int cmnd_size, unsigned sense_bytes)
     955                 :            : {
     956                 :          0 :         struct scsi_device *sdev = scmd->device;
     957                 :            : 
     958                 :            :         /*
     959                 :            :          * We need saved copies of a number of fields - this is because
     960                 :            :          * error handling may need to overwrite these with different values
     961                 :            :          * to run different commands, and once error handling is complete,
     962                 :            :          * we will need to restore these values prior to running the actual
     963                 :            :          * command.
     964                 :            :          */
     965                 :          0 :         ses->cmd_len = scmd->cmd_len;
     966                 :          0 :         ses->cmnd = scmd->cmnd;
     967                 :          0 :         ses->data_direction = scmd->sc_data_direction;
     968                 :          0 :         ses->sdb = scmd->sdb;
     969                 :          0 :         ses->result = scmd->result;
     970                 :          0 :         ses->resid_len = scmd->req.resid_len;
     971                 :          0 :         ses->underflow = scmd->underflow;
     972                 :          0 :         ses->prot_op = scmd->prot_op;
     973                 :          0 :         ses->eh_eflags = scmd->eh_eflags;
     974                 :            : 
     975                 :          0 :         scmd->prot_op = SCSI_PROT_NORMAL;
     976                 :          0 :         scmd->eh_eflags = 0;
     977                 :          0 :         scmd->cmnd = ses->eh_cmnd;
     978                 :          0 :         memset(scmd->cmnd, 0, BLK_MAX_CDB);
     979                 :          0 :         memset(&scmd->sdb, 0, sizeof(scmd->sdb));
     980                 :          0 :         scmd->result = 0;
     981                 :          0 :         scmd->req.resid_len = 0;
     982                 :            : 
     983         [ #  # ]:          0 :         if (sense_bytes) {
     984                 :          0 :                 scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
     985                 :            :                                          sense_bytes);
     986                 :          0 :                 sg_init_one(&ses->sense_sgl, scmd->sense_buffer,
     987                 :            :                             scmd->sdb.length);
     988                 :          0 :                 scmd->sdb.table.sgl = &ses->sense_sgl;
     989                 :          0 :                 scmd->sc_data_direction = DMA_FROM_DEVICE;
     990                 :          0 :                 scmd->sdb.table.nents = scmd->sdb.table.orig_nents = 1;
     991                 :          0 :                 scmd->cmnd[0] = REQUEST_SENSE;
     992                 :          0 :                 scmd->cmnd[4] = scmd->sdb.length;
     993                 :          0 :                 scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
     994                 :            :         } else {
     995                 :          0 :                 scmd->sc_data_direction = DMA_NONE;
     996         [ #  # ]:          0 :                 if (cmnd) {
     997         [ #  # ]:          0 :                         BUG_ON(cmnd_size > BLK_MAX_CDB);
     998                 :          0 :                         memcpy(scmd->cmnd, cmnd, cmnd_size);
     999                 :          0 :                         scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
    1000                 :            :                 }
    1001                 :            :         }
    1002                 :            : 
    1003                 :          0 :         scmd->underflow = 0;
    1004                 :            : 
    1005         [ #  # ]:          0 :         if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN)
    1006                 :          0 :                 scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
    1007                 :          0 :                         (sdev->lun << 5 & 0xe0);
    1008                 :            : 
    1009                 :            :         /*
    1010                 :            :          * Zero the sense buffer.  The scsi spec mandates that any
    1011                 :            :          * untransferred sense data should be interpreted as being zero.
    1012                 :            :          */
    1013                 :          0 :         memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
    1014                 :          0 : }
    1015                 :            : EXPORT_SYMBOL(scsi_eh_prep_cmnd);
    1016                 :            : 
    1017                 :            : /**
    1018                 :            :  * scsi_eh_restore_cmnd  - Restore a scsi command info as part of error recovery
    1019                 :            :  * @scmd:       SCSI command structure to restore
    1020                 :            :  * @ses:        saved information from a coresponding call to scsi_eh_prep_cmnd
    1021                 :            :  *
    1022                 :            :  * Undo any damage done by above scsi_eh_prep_cmnd().
    1023                 :            :  */
    1024                 :          0 : void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)
    1025                 :            : {
    1026                 :            :         /*
    1027                 :            :          * Restore original data
    1028                 :            :          */
    1029                 :          0 :         scmd->cmd_len = ses->cmd_len;
    1030                 :          0 :         scmd->cmnd = ses->cmnd;
    1031                 :          0 :         scmd->sc_data_direction = ses->data_direction;
    1032                 :          0 :         scmd->sdb = ses->sdb;
    1033                 :          0 :         scmd->result = ses->result;
    1034                 :          0 :         scmd->req.resid_len = ses->resid_len;
    1035                 :          0 :         scmd->underflow = ses->underflow;
    1036                 :          0 :         scmd->prot_op = ses->prot_op;
    1037                 :          0 :         scmd->eh_eflags = ses->eh_eflags;
    1038                 :          0 : }
    1039                 :            : EXPORT_SYMBOL(scsi_eh_restore_cmnd);
    1040                 :            : 
    1041                 :            : /**
    1042                 :            :  * scsi_send_eh_cmnd  - submit a scsi command as part of error recovery
    1043                 :            :  * @scmd:       SCSI command structure to hijack
    1044                 :            :  * @cmnd:       CDB to send
    1045                 :            :  * @cmnd_size:  size in bytes of @cmnd
    1046                 :            :  * @timeout:    timeout for this request
    1047                 :            :  * @sense_bytes: size of sense data to copy or 0
    1048                 :            :  *
    1049                 :            :  * This function is used to send a scsi command down to a target device
    1050                 :            :  * as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
    1051                 :            :  *
    1052                 :            :  * Return value:
    1053                 :            :  *    SUCCESS or FAILED or NEEDS_RETRY
    1054                 :            :  */
    1055                 :          0 : static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
    1056                 :            :                              int cmnd_size, int timeout, unsigned sense_bytes)
    1057                 :            : {
    1058                 :          0 :         struct scsi_device *sdev = scmd->device;
    1059                 :          0 :         struct Scsi_Host *shost = sdev->host;
    1060                 :          0 :         DECLARE_COMPLETION_ONSTACK(done);
    1061                 :          0 :         unsigned long timeleft = timeout, delay;
    1062                 :          0 :         struct scsi_eh_save ses;
    1063                 :          0 :         const unsigned long stall_for = msecs_to_jiffies(100);
    1064                 :          0 :         int rtn;
    1065                 :            : 
    1066                 :          0 : retry:
    1067                 :          0 :         scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
    1068                 :          0 :         shost->eh_action = &done;
    1069                 :            : 
    1070                 :          0 :         scsi_log_send(scmd);
    1071                 :          0 :         scmd->scsi_done = scsi_eh_done;
    1072                 :            : 
    1073                 :            :         /*
    1074                 :            :          * Lock sdev->state_mutex to avoid that scsi_device_quiesce() can
    1075                 :            :          * change the SCSI device state after we have examined it and before
    1076                 :            :          * .queuecommand() is called.
    1077                 :            :          */
    1078                 :          0 :         mutex_lock(&sdev->state_mutex);
    1079   [ #  #  #  # ]:          0 :         while (sdev->sdev_state == SDEV_BLOCK && timeleft > 0) {
    1080                 :          0 :                 mutex_unlock(&sdev->state_mutex);
    1081                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(5, sdev_printk(KERN_DEBUG, sdev,
    1082                 :            :                         "%s: state %d <> %d\n", __func__, sdev->sdev_state,
    1083                 :          0 :                         SDEV_BLOCK));
    1084                 :          0 :                 delay = min(timeleft, stall_for);
    1085                 :          0 :                 timeleft -= delay;
    1086                 :          0 :                 msleep(jiffies_to_msecs(delay));
    1087                 :          0 :                 mutex_lock(&sdev->state_mutex);
    1088                 :            :         }
    1089         [ #  # ]:          0 :         if (sdev->sdev_state != SDEV_BLOCK)
    1090                 :          0 :                 rtn = shost->hostt->queuecommand(shost, scmd);
    1091                 :            :         else
    1092                 :            :                 rtn = SCSI_MLQUEUE_DEVICE_BUSY;
    1093                 :          0 :         mutex_unlock(&sdev->state_mutex);
    1094                 :            : 
    1095         [ #  # ]:          0 :         if (rtn) {
    1096         [ #  # ]:          0 :                 if (timeleft > stall_for) {
    1097                 :          0 :                         scsi_eh_restore_cmnd(scmd, &ses);
    1098                 :          0 :                         timeleft -= stall_for;
    1099                 :          0 :                         msleep(jiffies_to_msecs(stall_for));
    1100                 :          0 :                         goto retry;
    1101                 :            :                 }
    1102                 :            :                 /* signal not to enter either branch of the if () below */
    1103                 :            :                 timeleft = 0;
    1104                 :            :                 rtn = FAILED;
    1105                 :            :         } else {
    1106                 :          0 :                 timeleft = wait_for_completion_timeout(&done, timeout);
    1107                 :          0 :                 rtn = SUCCESS;
    1108                 :            :         }
    1109                 :            : 
    1110                 :          0 :         shost->eh_action = NULL;
    1111                 :            : 
    1112         [ #  # ]:          0 :         scsi_log_completion(scmd, rtn);
    1113                 :            : 
    1114                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
    1115                 :            :                         "%s timeleft: %ld\n",
    1116                 :          0 :                         __func__, timeleft));
    1117                 :            : 
    1118                 :            :         /*
    1119                 :            :          * If there is time left scsi_eh_done got called, and we will examine
    1120                 :            :          * the actual status codes to see whether the command actually did
    1121                 :            :          * complete normally, else if we have a zero return and no time left,
    1122                 :            :          * the command must still be pending, so abort it and return FAILED.
    1123                 :            :          * If we never actually managed to issue the command, because
    1124                 :            :          * ->queuecommand() kept returning non zero, use the rtn = FAILED
    1125                 :            :          * value above (so don't execute either branch of the if)
    1126                 :            :          */
    1127         [ #  # ]:          0 :         if (timeleft) {
    1128                 :          0 :                 rtn = scsi_eh_completed_normally(scmd);
    1129                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
    1130                 :          0 :                         "%s: scsi_eh_completed_normally %x\n", __func__, rtn));
    1131                 :            : 
    1132      [ #  #  # ]:          0 :                 switch (rtn) {
    1133                 :            :                 case SUCCESS:
    1134                 :            :                 case NEEDS_RETRY:
    1135                 :            :                 case FAILED:
    1136                 :            :                         break;
    1137                 :          0 :                 case ADD_TO_MLQUEUE:
    1138                 :          0 :                         rtn = NEEDS_RETRY;
    1139                 :          0 :                         break;
    1140                 :          0 :                 default:
    1141                 :          0 :                         rtn = FAILED;
    1142                 :          0 :                         break;
    1143                 :            :                 }
    1144         [ #  # ]:          0 :         } else if (rtn != FAILED) {
    1145                 :          0 :                 scsi_abort_eh_cmnd(scmd);
    1146                 :          0 :                 rtn = FAILED;
    1147                 :            :         }
    1148                 :            : 
    1149                 :          0 :         scsi_eh_restore_cmnd(scmd, &ses);
    1150                 :            : 
    1151                 :          0 :         return rtn;
    1152                 :            : }
    1153                 :            : 
    1154                 :            : /**
    1155                 :            :  * scsi_request_sense - Request sense data from a particular target.
    1156                 :            :  * @scmd:       SCSI cmd for request sense.
    1157                 :            :  *
    1158                 :            :  * Notes:
    1159                 :            :  *    Some hosts automatically obtain this information, others require
    1160                 :            :  *    that we obtain it on our own. This function will *not* return until
    1161                 :            :  *    the command either times out, or it completes.
    1162                 :            :  */
    1163                 :          0 : static int scsi_request_sense(struct scsi_cmnd *scmd)
    1164                 :            : {
    1165                 :          0 :         return scsi_send_eh_cmnd(scmd, NULL, 0, scmd->device->eh_timeout, ~0);
    1166                 :            : }
    1167                 :            : 
    1168                 :          0 : static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)
    1169                 :            : {
    1170   [ #  #  #  # ]:          0 :         if (!blk_rq_is_passthrough(scmd->request)) {
    1171         [ #  # ]:          0 :                 struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
    1172         [ #  # ]:          0 :                 if (sdrv->eh_action)
    1173                 :          0 :                         rtn = sdrv->eh_action(scmd, rtn);
    1174                 :            :         }
    1175                 :          0 :         return rtn;
    1176                 :            : }
    1177                 :            : 
    1178                 :            : /**
    1179                 :            :  * scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
    1180                 :            :  * @scmd:       Original SCSI cmd that eh has finished.
    1181                 :            :  * @done_q:     Queue for processed commands.
    1182                 :            :  *
    1183                 :            :  * Notes:
    1184                 :            :  *    We don't want to use the normal command completion while we are are
    1185                 :            :  *    still handling errors - it may cause other commands to be queued,
    1186                 :            :  *    and that would disturb what we are doing.  Thus we really want to
    1187                 :            :  *    keep a list of pending commands for final completion, and once we
    1188                 :            :  *    are ready to leave error handling we handle completion for real.
    1189                 :            :  */
    1190                 :        779 : void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
    1191                 :            : {
    1192                 :        779 :         list_move_tail(&scmd->eh_entry, done_q);
    1193                 :          0 : }
    1194                 :            : EXPORT_SYMBOL(scsi_eh_finish_cmd);
    1195                 :            : 
    1196                 :            : /**
    1197                 :            :  * scsi_eh_get_sense - Get device sense data.
    1198                 :            :  * @work_q:     Queue of commands to process.
    1199                 :            :  * @done_q:     Queue of processed commands.
    1200                 :            :  *
    1201                 :            :  * Description:
    1202                 :            :  *    See if we need to request sense information.  if so, then get it
    1203                 :            :  *    now, so we have a better idea of what to do.
    1204                 :            :  *
    1205                 :            :  * Notes:
    1206                 :            :  *    This has the unfortunate side effect that if a shost adapter does
    1207                 :            :  *    not automatically request sense information, we end up shutting
    1208                 :            :  *    it down before we request it.
    1209                 :            :  *
    1210                 :            :  *    All drivers should request sense information internally these days,
    1211                 :            :  *    so for now all I have to say is tough noogies if you end up in here.
    1212                 :            :  *
    1213                 :            :  *    XXX: Long term this code should go away, but that needs an audit of
    1214                 :            :  *         all LLDDs first.
    1215                 :            :  */
    1216                 :          0 : int scsi_eh_get_sense(struct list_head *work_q,
    1217                 :            :                       struct list_head *done_q)
    1218                 :            : {
    1219                 :          0 :         struct scsi_cmnd *scmd, *next;
    1220                 :          0 :         struct Scsi_Host *shost;
    1221                 :          0 :         int rtn;
    1222                 :            : 
    1223                 :            :         /*
    1224                 :            :          * If SCSI_EH_ABORT_SCHEDULED has been set, it is timeout IO,
    1225                 :            :          * should not get sense.
    1226                 :            :          */
    1227         [ #  # ]:          0 :         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
    1228         [ #  # ]:          0 :                 if ((scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) ||
    1229         [ #  # ]:          0 :                     SCSI_SENSE_VALID(scmd))
    1230                 :          0 :                         continue;
    1231                 :            : 
    1232                 :          0 :                 shost = scmd->device->host;
    1233         [ #  # ]:          0 :                 if (scsi_host_eh_past_deadline(shost)) {
    1234                 :            :                         SCSI_LOG_ERROR_RECOVERY(3,
    1235                 :            :                                 scmd_printk(KERN_INFO, scmd,
    1236                 :            :                                             "%s: skip request sense, past eh deadline\n",
    1237                 :            :                                              current->comm));
    1238                 :            :                         break;
    1239                 :            :                 }
    1240         [ #  # ]:          0 :                 if (status_byte(scmd->result) != CHECK_CONDITION)
    1241                 :            :                         /*
    1242                 :            :                          * don't request sense if there's no check condition
    1243                 :            :                          * status because the error we're processing isn't one
    1244                 :            :                          * that has a sense code (and some devices get
    1245                 :            :                          * confused by sense requests out of the blue)
    1246                 :            :                          */
    1247                 :          0 :                         continue;
    1248                 :            : 
    1249                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
    1250                 :            :                                                   "%s: requesting sense\n",
    1251                 :          0 :                                                   current->comm));
    1252                 :          0 :                 rtn = scsi_request_sense(scmd);
    1253         [ #  # ]:          0 :                 if (rtn != SUCCESS)
    1254                 :          0 :                         continue;
    1255                 :            : 
    1256                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
    1257                 :          0 :                         "sense requested, result %x\n", scmd->result));
    1258                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
    1259                 :            : 
    1260                 :          0 :                 rtn = scsi_decide_disposition(scmd);
    1261                 :            : 
    1262                 :            :                 /*
    1263                 :            :                  * if the result was normal, then just pass it along to the
    1264                 :            :                  * upper level.
    1265                 :            :                  */
    1266         [ #  # ]:          0 :                 if (rtn == SUCCESS)
    1267                 :            :                         /* we don't want this command reissued, just
    1268                 :            :                          * finished with the sense data, so set
    1269                 :            :                          * retries to the max allowed to ensure it
    1270                 :            :                          * won't get reissued */
    1271                 :          0 :                         scmd->retries = scmd->allowed;
    1272         [ #  # ]:          0 :                 else if (rtn != NEEDS_RETRY)
    1273                 :          0 :                         continue;
    1274                 :            : 
    1275                 :          0 :                 scsi_eh_finish_cmd(scmd, done_q);
    1276                 :            :         }
    1277                 :            : 
    1278                 :          0 :         return list_empty(work_q);
    1279                 :            : }
    1280                 :            : EXPORT_SYMBOL_GPL(scsi_eh_get_sense);
    1281                 :            : 
    1282                 :            : /**
    1283                 :            :  * scsi_eh_tur - Send TUR to device.
    1284                 :            :  * @scmd:       &scsi_cmnd to send TUR
    1285                 :            :  *
    1286                 :            :  * Return value:
    1287                 :            :  *    0 - Device is ready. 1 - Device NOT ready.
    1288                 :            :  */
    1289                 :          0 : static int scsi_eh_tur(struct scsi_cmnd *scmd)
    1290                 :            : {
    1291                 :          0 :         static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
    1292                 :          0 :         int retry_cnt = 1, rtn;
    1293                 :            : 
    1294                 :          0 : retry_tur:
    1295                 :          0 :         rtn = scsi_send_eh_cmnd(scmd, tur_command, 6,
    1296                 :          0 :                                 scmd->device->eh_timeout, 0);
    1297                 :            : 
    1298                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
    1299                 :          0 :                 "%s return: %x\n", __func__, rtn));
    1300                 :            : 
    1301      [ #  #  # ]:          0 :         switch (rtn) {
    1302                 :          0 :         case NEEDS_RETRY:
    1303         [ #  # ]:          0 :                 if (retry_cnt--)
    1304                 :          0 :                         goto retry_tur;
    1305                 :            :                 /*FALLTHRU*/
    1306                 :            :         case SUCCESS:
    1307                 :            :                 return 0;
    1308                 :          0 :         default:
    1309                 :          0 :                 return 1;
    1310                 :            :         }
    1311                 :            : }
    1312                 :            : 
    1313                 :            : /**
    1314                 :            :  * scsi_eh_test_devices - check if devices are responding from error recovery.
    1315                 :            :  * @cmd_list:   scsi commands in error recovery.
    1316                 :            :  * @work_q:     queue for commands which still need more error recovery
    1317                 :            :  * @done_q:     queue for commands which are finished
    1318                 :            :  * @try_stu:    boolean on if a STU command should be tried in addition to TUR.
    1319                 :            :  *
    1320                 :            :  * Decription:
    1321                 :            :  *    Tests if devices are in a working state.  Commands to devices now in
    1322                 :            :  *    a working state are sent to the done_q while commands to devices which
    1323                 :            :  *    are still failing to respond are returned to the work_q for more
    1324                 :            :  *    processing.
    1325                 :            :  **/
    1326                 :          0 : static int scsi_eh_test_devices(struct list_head *cmd_list,
    1327                 :            :                                 struct list_head *work_q,
    1328                 :            :                                 struct list_head *done_q, int try_stu)
    1329                 :            : {
    1330                 :          0 :         struct scsi_cmnd *scmd, *next;
    1331                 :          0 :         struct scsi_device *sdev;
    1332                 :          0 :         int finish_cmds;
    1333                 :            : 
    1334         [ #  # ]:          0 :         while (!list_empty(cmd_list)) {
    1335                 :          0 :                 scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
    1336                 :          0 :                 sdev = scmd->device;
    1337                 :            : 
    1338         [ #  # ]:          0 :                 if (!try_stu) {
    1339         [ #  # ]:          0 :                         if (scsi_host_eh_past_deadline(sdev->host)) {
    1340                 :            :                                 /* Push items back onto work_q */
    1341         [ #  # ]:          0 :                                 list_splice_init(cmd_list, work_q);
    1342                 :            :                                 SCSI_LOG_ERROR_RECOVERY(3,
    1343                 :            :                                         sdev_printk(KERN_INFO, sdev,
    1344                 :            :                                                     "%s: skip test device, past eh deadline",
    1345                 :            :                                                     current->comm));
    1346                 :            :                                 break;
    1347                 :            :                         }
    1348                 :            :                 }
    1349                 :            : 
    1350   [ #  #  #  # ]:          0 :                 finish_cmds = !scsi_device_online(scmd->device) ||
    1351   [ #  #  #  # ]:          0 :                         (try_stu && !scsi_eh_try_stu(scmd) &&
    1352   [ #  #  #  # ]:          0 :                          !scsi_eh_tur(scmd)) ||
    1353                 :          0 :                         !scsi_eh_tur(scmd);
    1354                 :            : 
    1355         [ #  # ]:          0 :                 list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
    1356         [ #  # ]:          0 :                         if (scmd->device == sdev) {
    1357   [ #  #  #  # ]:          0 :                                 if (finish_cmds &&
    1358         [ #  # ]:          0 :                                     (try_stu ||
    1359                 :          0 :                                      scsi_eh_action(scmd, SUCCESS) == SUCCESS))
    1360                 :          0 :                                         scsi_eh_finish_cmd(scmd, done_q);
    1361                 :            :                                 else
    1362                 :          0 :                                         list_move_tail(&scmd->eh_entry, work_q);
    1363                 :            :                         }
    1364                 :            :         }
    1365                 :          0 :         return list_empty(work_q);
    1366                 :            : }
    1367                 :            : 
    1368                 :            : /**
    1369                 :            :  * scsi_eh_try_stu - Send START_UNIT to device.
    1370                 :            :  * @scmd:       &scsi_cmnd to send START_UNIT
    1371                 :            :  *
    1372                 :            :  * Return value:
    1373                 :            :  *    0 - Device is ready. 1 - Device NOT ready.
    1374                 :            :  */
    1375                 :          0 : static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
    1376                 :            : {
    1377                 :          0 :         static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0};
    1378                 :            : 
    1379         [ #  # ]:          0 :         if (scmd->device->allow_restart) {
    1380                 :            :                 int i, rtn = NEEDS_RETRY;
    1381                 :            : 
    1382         [ #  # ]:          0 :                 for (i = 0; rtn == NEEDS_RETRY && i < 2; i++)
    1383                 :          0 :                         rtn = scsi_send_eh_cmnd(scmd, stu_command, 6, scmd->device->request_queue->rq_timeout, 0);
    1384                 :            : 
    1385         [ #  # ]:          0 :                 if (rtn == SUCCESS)
    1386                 :          0 :                         return 0;
    1387                 :            :         }
    1388                 :            : 
    1389                 :            :         return 1;
    1390                 :            : }
    1391                 :            : 
    1392                 :            :  /**
    1393                 :            :  * scsi_eh_stu - send START_UNIT if needed
    1394                 :            :  * @shost:      &scsi host being recovered.
    1395                 :            :  * @work_q:     &list_head for pending commands.
    1396                 :            :  * @done_q:     &list_head for processed commands.
    1397                 :            :  *
    1398                 :            :  * Notes:
    1399                 :            :  *    If commands are failing due to not ready, initializing command required,
    1400                 :            :  *      try revalidating the device, which will end up sending a start unit.
    1401                 :            :  */
    1402                 :          0 : static int scsi_eh_stu(struct Scsi_Host *shost,
    1403                 :            :                               struct list_head *work_q,
    1404                 :            :                               struct list_head *done_q)
    1405                 :            : {
    1406                 :          0 :         struct scsi_cmnd *scmd, *stu_scmd, *next;
    1407                 :          0 :         struct scsi_device *sdev;
    1408                 :            : 
    1409         [ #  # ]:          0 :         shost_for_each_device(sdev, shost) {
    1410         [ #  # ]:          0 :                 if (scsi_host_eh_past_deadline(shost)) {
    1411                 :            :                         SCSI_LOG_ERROR_RECOVERY(3,
    1412                 :            :                                 sdev_printk(KERN_INFO, sdev,
    1413                 :            :                                             "%s: skip START_UNIT, past eh deadline\n",
    1414                 :            :                                             current->comm));
    1415                 :            :                         break;
    1416                 :            :                 }
    1417                 :          0 :                 stu_scmd = NULL;
    1418         [ #  # ]:          0 :                 list_for_each_entry(scmd, work_q, eh_entry)
    1419   [ #  #  #  #  :          0 :                         if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
                   #  # ]
    1420                 :          0 :                             scsi_check_sense(scmd) == FAILED ) {
    1421                 :            :                                 stu_scmd = scmd;
    1422                 :            :                                 break;
    1423                 :            :                         }
    1424                 :            : 
    1425         [ #  # ]:          0 :                 if (!stu_scmd)
    1426                 :          0 :                         continue;
    1427                 :            : 
    1428                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3,
    1429                 :            :                         sdev_printk(KERN_INFO, sdev,
    1430                 :            :                                      "%s: Sending START_UNIT\n",
    1431                 :          0 :                                     current->comm));
    1432                 :            : 
    1433         [ #  # ]:          0 :                 if (!scsi_eh_try_stu(stu_scmd)) {
    1434   [ #  #  #  # ]:          0 :                         if (!scsi_device_online(sdev) ||
    1435                 :          0 :                             !scsi_eh_tur(stu_scmd)) {
    1436         [ #  # ]:          0 :                                 list_for_each_entry_safe(scmd, next,
    1437                 :            :                                                           work_q, eh_entry) {
    1438   [ #  #  #  # ]:          0 :                                         if (scmd->device == sdev &&
    1439                 :          0 :                                             scsi_eh_action(scmd, SUCCESS) == SUCCESS)
    1440                 :          0 :                                                 scsi_eh_finish_cmd(scmd, done_q);
    1441                 :            :                                 }
    1442                 :            :                         }
    1443                 :            :                 } else {
    1444                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1445                 :            :                                 sdev_printk(KERN_INFO, sdev,
    1446                 :            :                                             "%s: START_UNIT failed\n",
    1447                 :          0 :                                             current->comm));
    1448                 :            :                 }
    1449                 :            :         }
    1450                 :            : 
    1451                 :          0 :         return list_empty(work_q);
    1452                 :            : }
    1453                 :            : 
    1454                 :            : 
    1455                 :            : /**
    1456                 :            :  * scsi_eh_bus_device_reset - send bdr if needed
    1457                 :            :  * @shost:      scsi host being recovered.
    1458                 :            :  * @work_q:     &list_head for pending commands.
    1459                 :            :  * @done_q:     &list_head for processed commands.
    1460                 :            :  *
    1461                 :            :  * Notes:
    1462                 :            :  *    Try a bus device reset.  Still, look to see whether we have multiple
    1463                 :            :  *    devices that are jammed or not - if we have multiple devices, it
    1464                 :            :  *    makes no sense to try bus_device_reset - we really would need to try
    1465                 :            :  *    a bus_reset instead.
    1466                 :            :  */
    1467                 :          0 : static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
    1468                 :            :                                     struct list_head *work_q,
    1469                 :            :                                     struct list_head *done_q)
    1470                 :            : {
    1471                 :          0 :         struct scsi_cmnd *scmd, *bdr_scmd, *next;
    1472                 :          0 :         struct scsi_device *sdev;
    1473                 :          0 :         int rtn;
    1474                 :            : 
    1475         [ #  # ]:          0 :         shost_for_each_device(sdev, shost) {
    1476         [ #  # ]:          0 :                 if (scsi_host_eh_past_deadline(shost)) {
    1477                 :            :                         SCSI_LOG_ERROR_RECOVERY(3,
    1478                 :            :                                 sdev_printk(KERN_INFO, sdev,
    1479                 :            :                                             "%s: skip BDR, past eh deadline\n",
    1480                 :            :                                              current->comm));
    1481                 :            :                         break;
    1482                 :            :                 }
    1483                 :          0 :                 bdr_scmd = NULL;
    1484         [ #  # ]:          0 :                 list_for_each_entry(scmd, work_q, eh_entry)
    1485         [ #  # ]:          0 :                         if (scmd->device == sdev) {
    1486                 :            :                                 bdr_scmd = scmd;
    1487                 :            :                                 break;
    1488                 :            :                         }
    1489                 :            : 
    1490         [ #  # ]:          0 :                 if (!bdr_scmd)
    1491                 :          0 :                         continue;
    1492                 :            : 
    1493                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3,
    1494                 :            :                         sdev_printk(KERN_INFO, sdev,
    1495                 :          0 :                                      "%s: Sending BDR\n", current->comm));
    1496         [ #  # ]:          0 :                 rtn = scsi_try_bus_device_reset(bdr_scmd);
    1497         [ #  # ]:          0 :                 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
    1498   [ #  #  #  # ]:          0 :                         if (!scsi_device_online(sdev) ||
    1499         [ #  # ]:          0 :                             rtn == FAST_IO_FAIL ||
    1500                 :          0 :                             !scsi_eh_tur(bdr_scmd)) {
    1501         [ #  # ]:          0 :                                 list_for_each_entry_safe(scmd, next,
    1502                 :            :                                                          work_q, eh_entry) {
    1503   [ #  #  #  # ]:          0 :                                         if (scmd->device == sdev &&
    1504                 :          0 :                                             scsi_eh_action(scmd, rtn) != FAILED)
    1505                 :          0 :                                                 scsi_eh_finish_cmd(scmd,
    1506                 :            :                                                                    done_q);
    1507                 :            :                                 }
    1508                 :            :                         }
    1509                 :            :                 } else {
    1510                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1511                 :            :                                 sdev_printk(KERN_INFO, sdev,
    1512                 :          0 :                                             "%s: BDR failed\n", current->comm));
    1513                 :            :                 }
    1514                 :            :         }
    1515                 :            : 
    1516                 :          0 :         return list_empty(work_q);
    1517                 :            : }
    1518                 :            : 
    1519                 :            : /**
    1520                 :            :  * scsi_eh_target_reset - send target reset if needed
    1521                 :            :  * @shost:      scsi host being recovered.
    1522                 :            :  * @work_q:     &list_head for pending commands.
    1523                 :            :  * @done_q:     &list_head for processed commands.
    1524                 :            :  *
    1525                 :            :  * Notes:
    1526                 :            :  *    Try a target reset.
    1527                 :            :  */
    1528                 :          0 : static int scsi_eh_target_reset(struct Scsi_Host *shost,
    1529                 :            :                                 struct list_head *work_q,
    1530                 :            :                                 struct list_head *done_q)
    1531                 :            : {
    1532                 :          0 :         LIST_HEAD(tmp_list);
    1533                 :          0 :         LIST_HEAD(check_list);
    1534                 :            : 
    1535         [ #  # ]:          0 :         list_splice_init(work_q, &tmp_list);
    1536                 :            : 
    1537         [ #  # ]:          0 :         while (!list_empty(&tmp_list)) {
    1538                 :          0 :                 struct scsi_cmnd *next, *scmd;
    1539                 :          0 :                 int rtn;
    1540                 :          0 :                 unsigned int id;
    1541                 :            : 
    1542         [ #  # ]:          0 :                 if (scsi_host_eh_past_deadline(shost)) {
    1543                 :            :                         /* push back on work queue for further processing */
    1544         [ #  # ]:          0 :                         list_splice_init(&check_list, work_q);
    1545         [ #  # ]:          0 :                         list_splice_init(&tmp_list, work_q);
    1546                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1547                 :            :                                 shost_printk(KERN_INFO, shost,
    1548                 :            :                                             "%s: Skip target reset, past eh deadline\n",
    1549                 :          0 :                                              current->comm));
    1550                 :          0 :                         return list_empty(work_q);
    1551                 :            :                 }
    1552                 :            : 
    1553                 :          0 :                 scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
    1554                 :          0 :                 id = scmd_id(scmd);
    1555                 :            : 
    1556                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3,
    1557                 :            :                         shost_printk(KERN_INFO, shost,
    1558                 :            :                                      "%s: Sending target reset to target %d\n",
    1559                 :          0 :                                      current->comm, id));
    1560                 :          0 :                 rtn = scsi_try_target_reset(scmd);
    1561                 :          0 :                 if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
    1562                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1563                 :            :                                 shost_printk(KERN_INFO, shost,
    1564                 :            :                                              "%s: Target reset failed"
    1565                 :            :                                              " target: %d\n",
    1566                 :          0 :                                              current->comm, id));
    1567         [ #  # ]:          0 :                 list_for_each_entry_safe(scmd, next, &tmp_list, eh_entry) {
    1568         [ #  # ]:          0 :                         if (scmd_id(scmd) != id)
    1569                 :          0 :                                 continue;
    1570                 :            : 
    1571         [ #  # ]:          0 :                         if (rtn == SUCCESS)
    1572                 :          0 :                                 list_move_tail(&scmd->eh_entry, &check_list);
    1573         [ #  # ]:          0 :                         else if (rtn == FAST_IO_FAIL)
    1574                 :          0 :                                 scsi_eh_finish_cmd(scmd, done_q);
    1575                 :            :                         else
    1576                 :            :                                 /* push back on work queue for further processing */
    1577                 :          0 :                                 list_move(&scmd->eh_entry, work_q);
    1578                 :            :                 }
    1579                 :            :         }
    1580                 :            : 
    1581                 :          0 :         return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
    1582                 :            : }
    1583                 :            : 
    1584                 :            : /**
    1585                 :            :  * scsi_eh_bus_reset - send a bus reset
    1586                 :            :  * @shost:      &scsi host being recovered.
    1587                 :            :  * @work_q:     &list_head for pending commands.
    1588                 :            :  * @done_q:     &list_head for processed commands.
    1589                 :            :  */
    1590                 :          0 : static int scsi_eh_bus_reset(struct Scsi_Host *shost,
    1591                 :            :                              struct list_head *work_q,
    1592                 :            :                              struct list_head *done_q)
    1593                 :            : {
    1594                 :          0 :         struct scsi_cmnd *scmd, *chan_scmd, *next;
    1595                 :          0 :         LIST_HEAD(check_list);
    1596                 :          0 :         unsigned int channel;
    1597                 :          0 :         int rtn;
    1598                 :            : 
    1599                 :            :         /*
    1600                 :            :          * we really want to loop over the various channels, and do this on
    1601                 :            :          * a channel by channel basis.  we should also check to see if any
    1602                 :            :          * of the failed commands are on soft_reset devices, and if so, skip
    1603                 :            :          * the reset.
    1604                 :            :          */
    1605                 :            : 
    1606         [ #  # ]:          0 :         for (channel = 0; channel <= shost->max_channel; channel++) {
    1607         [ #  # ]:          0 :                 if (scsi_host_eh_past_deadline(shost)) {
    1608         [ #  # ]:          0 :                         list_splice_init(&check_list, work_q);
    1609                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1610                 :            :                                 shost_printk(KERN_INFO, shost,
    1611                 :            :                                             "%s: skip BRST, past eh deadline\n",
    1612                 :          0 :                                              current->comm));
    1613                 :          0 :                         return list_empty(work_q);
    1614                 :            :                 }
    1615                 :            : 
    1616                 :          0 :                 chan_scmd = NULL;
    1617         [ #  # ]:          0 :                 list_for_each_entry(scmd, work_q, eh_entry) {
    1618         [ #  # ]:          0 :                         if (channel == scmd_channel(scmd)) {
    1619                 :            :                                 chan_scmd = scmd;
    1620                 :            :                                 break;
    1621                 :            :                                 /*
    1622                 :            :                                  * FIXME add back in some support for
    1623                 :            :                                  * soft_reset devices.
    1624                 :            :                                  */
    1625                 :            :                         }
    1626                 :            :                 }
    1627                 :            : 
    1628         [ #  # ]:          0 :                 if (!chan_scmd)
    1629                 :          0 :                         continue;
    1630                 :          0 :                 SCSI_LOG_ERROR_RECOVERY(3,
    1631                 :            :                         shost_printk(KERN_INFO, shost,
    1632                 :            :                                      "%s: Sending BRST chan: %d\n",
    1633                 :          0 :                                      current->comm, channel));
    1634                 :          0 :                 rtn = scsi_try_bus_reset(chan_scmd);
    1635         [ #  # ]:          0 :                 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
    1636         [ #  # ]:          0 :                         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
    1637         [ #  # ]:          0 :                                 if (channel == scmd_channel(scmd)) {
    1638         [ #  # ]:          0 :                                         if (rtn == FAST_IO_FAIL)
    1639                 :          0 :                                                 scsi_eh_finish_cmd(scmd,
    1640                 :            :                                                                    done_q);
    1641                 :            :                                         else
    1642                 :          0 :                                                 list_move_tail(&scmd->eh_entry,
    1643                 :            :                                                                &check_list);
    1644                 :            :                                 }
    1645                 :            :                         }
    1646                 :            :                 } else {
    1647                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    1648                 :            :                                 shost_printk(KERN_INFO, shost,
    1649                 :            :                                              "%s: BRST failed chan: %d\n",
    1650                 :          0 :                                              current->comm, channel));
    1651                 :            :                 }
    1652                 :            :         }
    1653                 :          0 :         return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
    1654                 :            : }
    1655                 :            : 
    1656                 :            : /**
    1657                 :            :  * scsi_eh_host_reset - send a host reset
    1658                 :            :  * @shost:      host to be reset.
    1659                 :            :  * @work_q:     &list_head for pending commands.
    1660                 :            :  * @done_q:     &list_head for processed commands.
    1661                 :            :  */
    1662                 :            : static int scsi_eh_host_reset(struct Scsi_Host *shost,
    1663                 :            :                               struct list_head *work_q,
    1664                 :            :                               struct list_head *done_q)
    1665                 :            : {
    1666                 :            :         struct scsi_cmnd *scmd, *next;
    1667                 :            :         LIST_HEAD(check_list);
    1668                 :            :         int rtn;
    1669                 :            : 
    1670                 :            :         if (!list_empty(work_q)) {
    1671                 :            :                 scmd = list_entry(work_q->next,
    1672                 :            :                                   struct scsi_cmnd, eh_entry);
    1673                 :            : 
    1674                 :            :                 SCSI_LOG_ERROR_RECOVERY(3,
    1675                 :            :                         shost_printk(KERN_INFO, shost,
    1676                 :            :                                      "%s: Sending HRST\n",
    1677                 :            :                                      current->comm));
    1678                 :            : 
    1679                 :            :                 rtn = scsi_try_host_reset(scmd);
    1680                 :            :                 if (rtn == SUCCESS) {
    1681                 :            :                         list_splice_init(work_q, &check_list);
    1682                 :            :                 } else if (rtn == FAST_IO_FAIL) {
    1683                 :            :                         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
    1684                 :            :                                         scsi_eh_finish_cmd(scmd, done_q);
    1685                 :            :                         }
    1686                 :            :                 } else {
    1687                 :            :                         SCSI_LOG_ERROR_RECOVERY(3,
    1688                 :            :                                 shost_printk(KERN_INFO, shost,
    1689                 :            :                                              "%s: HRST failed\n",
    1690                 :            :                                              current->comm));
    1691                 :            :                 }
    1692                 :            :         }
    1693                 :            :         return scsi_eh_test_devices(&check_list, work_q, done_q, 1);
    1694                 :            : }
    1695                 :            : 
    1696                 :            : /**
    1697                 :            :  * scsi_eh_offline_sdevs - offline scsi devices that fail to recover
    1698                 :            :  * @work_q:     &list_head for pending commands.
    1699                 :            :  * @done_q:     &list_head for processed commands.
    1700                 :            :  */
    1701                 :          0 : static void scsi_eh_offline_sdevs(struct list_head *work_q,
    1702                 :            :                                   struct list_head *done_q)
    1703                 :            : {
    1704                 :          0 :         struct scsi_cmnd *scmd, *next;
    1705                 :          0 :         struct scsi_device *sdev;
    1706                 :            : 
    1707         [ #  # ]:          0 :         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
    1708                 :          0 :                 sdev_printk(KERN_INFO, scmd->device, "Device offlined - "
    1709                 :            :                             "not ready after error recovery\n");
    1710                 :          0 :                 sdev = scmd->device;
    1711                 :            : 
    1712                 :          0 :                 mutex_lock(&sdev->state_mutex);
    1713                 :          0 :                 scsi_device_set_state(sdev, SDEV_OFFLINE);
    1714                 :          0 :                 mutex_unlock(&sdev->state_mutex);
    1715                 :            : 
    1716                 :          0 :                 scsi_eh_finish_cmd(scmd, done_q);
    1717                 :            :         }
    1718                 :          0 :         return;
    1719                 :            : }
    1720                 :            : 
    1721                 :            : /**
    1722                 :            :  * scsi_noretry_cmd - determine if command should be failed fast
    1723                 :            :  * @scmd:       SCSI cmd to examine.
    1724                 :            :  */
    1725                 :       1558 : int scsi_noretry_cmd(struct scsi_cmnd *scmd)
    1726                 :            : {
    1727   [ -  -  -  -  :       1558 :         switch (host_byte(scmd->result)) {
                   -  + ]
    1728                 :            :         case DID_OK:
    1729                 :            :                 break;
    1730                 :          0 :         case DID_TIME_OUT:
    1731                 :          0 :                 goto check_type;
    1732                 :          0 :         case DID_BUS_BUSY:
    1733                 :          0 :                 return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
    1734                 :          0 :         case DID_PARITY:
    1735                 :          0 :                 return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
    1736                 :          0 :         case DID_ERROR:
    1737         [ #  # ]:          0 :                 if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
    1738         [ #  # ]:          0 :                     status_byte(scmd->result) == RESERVATION_CONFLICT)
    1739                 :            :                         return 0;
    1740                 :            :                 /* fall through */
    1741                 :            :         case DID_SOFT_ERROR:
    1742                 :          0 :                 return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
    1743                 :            :         }
    1744                 :            : 
    1745         [ +  - ]:       1558 :         if (status_byte(scmd->result) != CHECK_CONDITION)
    1746                 :            :                 return 0;
    1747                 :            : 
    1748                 :       1558 : check_type:
    1749                 :            :         /*
    1750                 :            :          * assume caller has checked sense and determined
    1751                 :            :          * the check condition was retryable.
    1752                 :            :          */
    1753   [ +  -  -  + ]:       3116 :         if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
    1754                 :            :             blk_rq_is_passthrough(scmd->request))
    1755                 :            :                 return 1;
    1756                 :            :         else
    1757                 :          0 :                 return 0;
    1758                 :            : }
    1759                 :            : 
    1760                 :            : /**
    1761                 :            :  * scsi_decide_disposition - Disposition a cmd on return from LLD.
    1762                 :            :  * @scmd:       SCSI cmd to examine.
    1763                 :            :  *
    1764                 :            :  * Notes:
    1765                 :            :  *    This is *only* called when we are examining the status after sending
    1766                 :            :  *    out the actual data command.  any commands that are queued for error
    1767                 :            :  *    recovery (e.g. test_unit_ready) do *not* come through here.
    1768                 :            :  *
    1769                 :            :  *    When this routine returns failed, it means the error handler thread
    1770                 :            :  *    is woken.  In cases where the error code indicates an error that
    1771                 :            :  *    doesn't require the error handler read (i.e. we don't need to
    1772                 :            :  *    abort/reset), this function should return SUCCESS.
    1773                 :            :  */
    1774                 :      86930 : int scsi_decide_disposition(struct scsi_cmnd *scmd)
    1775                 :            : {
    1776                 :      86930 :         int rtn;
    1777                 :            : 
    1778                 :            :         /*
    1779                 :            :          * if the device is offline, then we clearly just pass the result back
    1780                 :            :          * up to the top level.
    1781                 :            :          */
    1782         [ +  - ]:      86930 :         if (!scsi_device_online(scmd->device)) {
    1783                 :            :                 SCSI_LOG_ERROR_RECOVERY(5, scmd_printk(KERN_INFO, scmd,
    1784                 :            :                         "%s: device offline - report as SUCCESS\n", __func__));
    1785                 :            :                 return SUCCESS;
    1786                 :            :         }
    1787                 :            : 
    1788                 :            :         /*
    1789                 :            :          * first check the host byte, to see if there is anything in there
    1790                 :            :          * that would indicate what we need to do.
    1791                 :            :          */
    1792   [ -  -  -  -  :      86930 :         switch (host_byte(scmd->result)) {
          -  -  -  -  -  
                -  +  - ]
    1793                 :          0 :         case DID_PASSTHROUGH:
    1794                 :            :                 /*
    1795                 :            :                  * no matter what, pass this through to the upper layer.
    1796                 :            :                  * nuke this special code so that it looks like we are saying
    1797                 :            :                  * did_ok.
    1798                 :            :                  */
    1799                 :          0 :                 scmd->result &= 0xff00ffff;
    1800                 :          0 :                 return SUCCESS;
    1801                 :            :         case DID_OK:
    1802                 :            :                 /*
    1803                 :            :                  * looks good.  drop through, and check the next byte.
    1804                 :            :                  */
    1805                 :            :                 break;
    1806                 :          0 :         case DID_ABORT:
    1807         [ #  # ]:          0 :                 if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
    1808                 :          0 :                         set_host_byte(scmd, DID_TIME_OUT);
    1809                 :          0 :                         return SUCCESS;
    1810                 :            :                 }
    1811                 :            :                 /* FALLTHROUGH */
    1812                 :            :         case DID_NO_CONNECT:
    1813                 :            :         case DID_BAD_TARGET:
    1814                 :            :                 /*
    1815                 :            :                  * note - this means that we just report the status back
    1816                 :            :                  * to the top level driver, not that we actually think
    1817                 :            :                  * that it indicates SUCCESS.
    1818                 :            :                  */
    1819                 :            :                 return SUCCESS;
    1820                 :          0 :         case DID_SOFT_ERROR:
    1821                 :            :                 /*
    1822                 :            :                  * when the low level driver returns did_soft_error,
    1823                 :            :                  * it is responsible for keeping an internal retry counter
    1824                 :            :                  * in order to avoid endless loops (db)
    1825                 :            :                  */
    1826                 :          0 :                 goto maybe_retry;
    1827                 :          0 :         case DID_IMM_RETRY:
    1828                 :          0 :                 return NEEDS_RETRY;
    1829                 :            : 
    1830                 :          0 :         case DID_REQUEUE:
    1831                 :          0 :                 return ADD_TO_MLQUEUE;
    1832                 :          0 :         case DID_TRANSPORT_DISRUPTED:
    1833                 :            :                 /*
    1834                 :            :                  * LLD/transport was disrupted during processing of the IO.
    1835                 :            :                  * The transport class is now blocked/blocking,
    1836                 :            :                  * and the transport will decide what to do with the IO
    1837                 :            :                  * based on its timers and recovery capablilities if
    1838                 :            :                  * there are enough retries.
    1839                 :            :                  */
    1840                 :          0 :                 goto maybe_retry;
    1841                 :            :         case DID_TRANSPORT_FAILFAST:
    1842                 :            :                 /*
    1843                 :            :                  * The transport decided to failfast the IO (most likely
    1844                 :            :                  * the fast io fail tmo fired), so send IO directly upwards.
    1845                 :            :                  */
    1846                 :            :                 return SUCCESS;
    1847                 :          0 :         case DID_ERROR:
    1848         [ #  # ]:          0 :                 if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
    1849         [ #  # ]:          0 :                     status_byte(scmd->result) == RESERVATION_CONFLICT)
    1850                 :            :                         /*
    1851                 :            :                          * execute reservation conflict processing code
    1852                 :            :                          * lower down
    1853                 :            :                          */
    1854                 :            :                         break;
    1855                 :            :                 /* fallthrough */
    1856                 :            :         case DID_BUS_BUSY:
    1857                 :            :         case DID_PARITY:
    1858                 :          0 :                 goto maybe_retry;
    1859                 :          0 :         case DID_TIME_OUT:
    1860                 :            :                 /*
    1861                 :            :                  * when we scan the bus, we get timeout messages for
    1862                 :            :                  * these commands if there is no device available.
    1863                 :            :                  * other hosts report did_no_connect for the same thing.
    1864                 :            :                  */
    1865         [ #  # ]:          0 :                 if ((scmd->cmnd[0] == TEST_UNIT_READY ||
    1866                 :            :                      scmd->cmnd[0] == INQUIRY)) {
    1867                 :            :                         return SUCCESS;
    1868                 :            :                 } else {
    1869                 :          0 :                         return FAILED;
    1870                 :            :                 }
    1871                 :            :         case DID_RESET:
    1872                 :            :                 return SUCCESS;
    1873                 :          0 :         default:
    1874                 :          0 :                 return FAILED;
    1875                 :            :         }
    1876                 :            : 
    1877                 :            :         /*
    1878                 :            :          * next, check the message byte.
    1879                 :            :          */
    1880         [ +  - ]:      86930 :         if (msg_byte(scmd->result) != COMMAND_COMPLETE)
    1881                 :            :                 return FAILED;
    1882                 :            : 
    1883                 :            :         /*
    1884                 :            :          * check the status byte to see if this indicates anything special.
    1885                 :            :          */
    1886   [ -  -  +  -  :      86930 :         switch (status_byte(scmd->result)) {
             +  -  -  - ]
    1887                 :          0 :         case QUEUE_FULL:
    1888                 :          0 :                 scsi_handle_queue_full(scmd->device);
    1889                 :            :                 /*
    1890                 :            :                  * the case of trying to send too many commands to a
    1891                 :            :                  * tagged queueing device.
    1892                 :            :                  */
    1893                 :            :                 /* FALLTHROUGH */
    1894                 :            :         case BUSY:
    1895                 :            :                 /*
    1896                 :            :                  * device can't talk to us at the moment.  Should only
    1897                 :            :                  * occur (SAM-3) when the task queue is empty, so will cause
    1898                 :            :                  * the empty queue handling to trigger a stall in the
    1899                 :            :                  * device.
    1900                 :            :                  */
    1901                 :            :                 return ADD_TO_MLQUEUE;
    1902                 :      86696 :         case GOOD:
    1903         [ -  + ]:      86696 :                 if (scmd->cmnd[0] == REPORT_LUNS)
    1904                 :          0 :                         scmd->device->sdev_target->expecting_lun_change = 0;
    1905                 :      86696 :                 scsi_handle_queue_ramp_up(scmd->device);
    1906                 :            :                 /* FALLTHROUGH */
    1907                 :            :         case COMMAND_TERMINATED:
    1908                 :            :                 return SUCCESS;
    1909                 :          0 :         case TASK_ABORTED:
    1910                 :          0 :                 goto maybe_retry;
    1911                 :        234 :         case CHECK_CONDITION:
    1912                 :        234 :                 rtn = scsi_check_sense(scmd);
    1913         [ -  + ]:        234 :                 if (rtn == NEEDS_RETRY)
    1914                 :          0 :                         goto maybe_retry;
    1915                 :            :                 /* if rtn == FAILED, we have no sense information;
    1916                 :            :                  * returning FAILED will wake the error handler thread
    1917                 :            :                  * to collect the sense and redo the decide
    1918                 :            :                  * disposition */
    1919                 :            :                 return rtn;
    1920                 :            :         case CONDITION_GOOD:
    1921                 :            :         case INTERMEDIATE_GOOD:
    1922                 :            :         case INTERMEDIATE_C_GOOD:
    1923                 :            :         case ACA_ACTIVE:
    1924                 :            :                 /*
    1925                 :            :                  * who knows?  FIXME(eric)
    1926                 :            :                  */
    1927                 :            :                 return SUCCESS;
    1928                 :            : 
    1929                 :          0 :         case RESERVATION_CONFLICT:
    1930                 :          0 :                 sdev_printk(KERN_INFO, scmd->device,
    1931                 :            :                             "reservation conflict\n");
    1932                 :          0 :                 set_host_byte(scmd, DID_NEXUS_FAILURE);
    1933                 :          0 :                 return SUCCESS; /* causes immediate i/o error */
    1934                 :          0 :         default:
    1935                 :          0 :                 return FAILED;
    1936                 :            :         }
    1937                 :            :         return FAILED;
    1938                 :            : 
    1939                 :          0 : maybe_retry:
    1940                 :            : 
    1941                 :            :         /* we requeue for retry because the error was retryable, and
    1942                 :            :          * the request was not marked fast fail.  Note that above,
    1943                 :            :          * even if the request is marked fast fail, we still requeue
    1944                 :            :          * for queue congestion conditions (QUEUE_FULL or BUSY) */
    1945         [ #  # ]:          0 :         if ((++scmd->retries) <= scmd->allowed
    1946         [ #  # ]:          0 :             && !scsi_noretry_cmd(scmd)) {
    1947                 :            :                 return NEEDS_RETRY;
    1948                 :            :         } else {
    1949                 :            :                 /*
    1950                 :            :                  * no more retries - report this one back to upper level.
    1951                 :            :                  */
    1952                 :          0 :                 return SUCCESS;
    1953                 :            :         }
    1954                 :            : }
    1955                 :            : 
    1956                 :          0 : static void eh_lock_door_done(struct request *req, blk_status_t status)
    1957                 :            : {
    1958                 :          0 :         blk_put_request(req);
    1959                 :          0 : }
    1960                 :            : 
    1961                 :            : /**
    1962                 :            :  * scsi_eh_lock_door - Prevent medium removal for the specified device
    1963                 :            :  * @sdev:       SCSI device to prevent medium removal
    1964                 :            :  *
    1965                 :            :  * Locking:
    1966                 :            :  *      We must be called from process context.
    1967                 :            :  *
    1968                 :            :  * Notes:
    1969                 :            :  *      We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the
    1970                 :            :  *      head of the devices request queue, and continue.
    1971                 :            :  */
    1972                 :            : static void scsi_eh_lock_door(struct scsi_device *sdev)
    1973                 :            : {
    1974                 :            :         struct request *req;
    1975                 :            :         struct scsi_request *rq;
    1976                 :            : 
    1977                 :            :         req = blk_get_request(sdev->request_queue, REQ_OP_SCSI_IN, 0);
    1978                 :            :         if (IS_ERR(req))
    1979                 :            :                 return;
    1980                 :            :         rq = scsi_req(req);
    1981                 :            : 
    1982                 :            :         rq->cmd[0] = ALLOW_MEDIUM_REMOVAL;
    1983                 :            :         rq->cmd[1] = 0;
    1984                 :            :         rq->cmd[2] = 0;
    1985                 :            :         rq->cmd[3] = 0;
    1986                 :            :         rq->cmd[4] = SCSI_REMOVAL_PREVENT;
    1987                 :            :         rq->cmd[5] = 0;
    1988                 :            :         rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
    1989                 :            : 
    1990                 :            :         req->rq_flags |= RQF_QUIET;
    1991                 :            :         req->timeout = 10 * HZ;
    1992                 :            :         rq->retries = 5;
    1993                 :            : 
    1994                 :            :         blk_execute_rq_nowait(req->q, NULL, req, 1, eh_lock_door_done);
    1995                 :            : }
    1996                 :            : 
    1997                 :            : /**
    1998                 :            :  * scsi_restart_operations - restart io operations to the specified host.
    1999                 :            :  * @shost:      Host we are restarting.
    2000                 :            :  *
    2001                 :            :  * Notes:
    2002                 :            :  *    When we entered the error handler, we blocked all further i/o to
    2003                 :            :  *    this device.  we need to 'reverse' this process.
    2004                 :            :  */
    2005                 :        935 : static void scsi_restart_operations(struct Scsi_Host *shost)
    2006                 :            : {
    2007                 :        935 :         struct scsi_device *sdev;
    2008                 :        935 :         unsigned long flags;
    2009                 :            : 
    2010                 :            :         /*
    2011                 :            :          * If the door was locked, we need to insert a door lock request
    2012                 :            :          * onto the head of the SCSI request queue for the device.  There
    2013                 :            :          * is no point trying to lock the door of an off-line device.
    2014                 :            :          */
    2015         [ +  + ]:       1714 :         shost_for_each_device(sdev, shost) {
    2016   [ +  -  -  + ]:        779 :                 if (scsi_device_online(sdev) && sdev->was_reset && sdev->locked) {
    2017                 :          0 :                         scsi_eh_lock_door(sdev);
    2018                 :          0 :                         sdev->was_reset = 0;
    2019                 :            :                 }
    2020                 :            :         }
    2021                 :            : 
    2022                 :            :         /*
    2023                 :            :          * next free up anything directly waiting upon the host.  this
    2024                 :            :          * will be requests for character device operations, and also for
    2025                 :            :          * ioctls to queued block devices.
    2026                 :            :          */
    2027                 :        935 :         SCSI_LOG_ERROR_RECOVERY(3,
    2028                 :        935 :                 shost_printk(KERN_INFO, shost, "waking up host to restart\n"));
    2029                 :            : 
    2030                 :        935 :         spin_lock_irqsave(shost->host_lock, flags);
    2031         [ -  + ]:        935 :         if (scsi_host_set_state(shost, SHOST_RUNNING))
    2032         [ #  # ]:          0 :                 if (scsi_host_set_state(shost, SHOST_CANCEL))
    2033         [ #  # ]:          0 :                         BUG_ON(scsi_host_set_state(shost, SHOST_DEL));
    2034                 :        935 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2035                 :            : 
    2036                 :        935 :         wake_up(&shost->host_wait);
    2037                 :            : 
    2038                 :            :         /*
    2039                 :            :          * finally we need to re-initiate requests that may be pending.  we will
    2040                 :            :          * have had everything blocked while error handling is taking place, and
    2041                 :            :          * now that error recovery is done, we will need to ensure that these
    2042                 :            :          * requests are started.
    2043                 :            :          */
    2044                 :        935 :         scsi_run_host_queues(shost);
    2045                 :            : 
    2046                 :            :         /*
    2047                 :            :          * if eh is active and host_eh_scheduled is pending we need to re-run
    2048                 :            :          * recovery.  we do this check after scsi_run_host_queues() to allow
    2049                 :            :          * everything pent up since the last eh run a chance to make forward
    2050                 :            :          * progress before we sync again.  Either we'll immediately re-run
    2051                 :            :          * recovery or scsi_device_unbusy() will wake us again when these
    2052                 :            :          * pending commands complete.
    2053                 :            :          */
    2054                 :        935 :         spin_lock_irqsave(shost->host_lock, flags);
    2055         [ -  + ]:        935 :         if (shost->host_eh_scheduled)
    2056         [ #  # ]:          0 :                 if (scsi_host_set_state(shost, SHOST_RECOVERY))
    2057         [ #  # ]:          0 :                         WARN_ON(scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY));
    2058                 :        935 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2059                 :        935 : }
    2060                 :            : 
    2061                 :            : /**
    2062                 :            :  * scsi_eh_ready_devs - check device ready state and recover if not.
    2063                 :            :  * @shost:      host to be recovered.
    2064                 :            :  * @work_q:     &list_head for pending commands.
    2065                 :            :  * @done_q:     &list_head for processed commands.
    2066                 :            :  */
    2067                 :          0 : void scsi_eh_ready_devs(struct Scsi_Host *shost,
    2068                 :            :                         struct list_head *work_q,
    2069                 :            :                         struct list_head *done_q)
    2070                 :            : {
    2071         [ #  # ]:          0 :         if (!scsi_eh_stu(shost, work_q, done_q))
    2072         [ #  # ]:          0 :                 if (!scsi_eh_bus_device_reset(shost, work_q, done_q))
    2073         [ #  # ]:          0 :                         if (!scsi_eh_target_reset(shost, work_q, done_q))
    2074         [ #  # ]:          0 :                                 if (!scsi_eh_bus_reset(shost, work_q, done_q))
    2075         [ #  # ]:          0 :                                         if (!scsi_eh_host_reset(shost, work_q, done_q))
    2076                 :          0 :                                                 scsi_eh_offline_sdevs(work_q,
    2077                 :            :                                                                       done_q);
    2078                 :          0 : }
    2079                 :            : EXPORT_SYMBOL_GPL(scsi_eh_ready_devs);
    2080                 :            : 
    2081                 :            : /**
    2082                 :            :  * scsi_eh_flush_done_q - finish processed commands or retry them.
    2083                 :            :  * @done_q:     list_head of processed commands.
    2084                 :            :  */
    2085                 :        935 : void scsi_eh_flush_done_q(struct list_head *done_q)
    2086                 :            : {
    2087                 :        935 :         struct scsi_cmnd *scmd, *next;
    2088                 :            : 
    2089         [ +  + ]:       1714 :         list_for_each_entry_safe(scmd, next, done_q, eh_entry) {
    2090         [ +  - ]:        779 :                 list_del_init(&scmd->eh_entry);
    2091         [ +  - ]:        779 :                 if (scsi_device_online(scmd->device) &&
    2092         [ -  + ]:        779 :                     !scsi_noretry_cmd(scmd) &&
    2093         [ #  # ]:          0 :                     (++scmd->retries <= scmd->allowed)) {
    2094                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(3,
    2095                 :            :                                 scmd_printk(KERN_INFO, scmd,
    2096                 :            :                                              "%s: flush retry cmd\n",
    2097                 :          0 :                                              current->comm));
    2098                 :          0 :                                 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
    2099                 :            :                 } else {
    2100                 :            :                         /*
    2101                 :            :                          * If just we got sense for the device (called
    2102                 :            :                          * scsi_eh_get_sense), scmd->result is already
    2103                 :            :                          * set, do not set DRIVER_TIMEOUT.
    2104                 :            :                          */
    2105         [ -  + ]:        779 :                         if (!scmd->result)
    2106                 :          0 :                                 scmd->result |= (DRIVER_TIMEOUT << 24);
    2107                 :        779 :                         SCSI_LOG_ERROR_RECOVERY(3,
    2108                 :            :                                 scmd_printk(KERN_INFO, scmd,
    2109                 :            :                                              "%s: flush finish cmd\n",
    2110                 :        779 :                                              current->comm));
    2111                 :        779 :                         scsi_finish_command(scmd);
    2112                 :            :                 }
    2113                 :            :         }
    2114                 :        935 : }
    2115                 :            : EXPORT_SYMBOL(scsi_eh_flush_done_q);
    2116                 :            : 
    2117                 :            : /**
    2118                 :            :  * scsi_unjam_host - Attempt to fix a host which has a cmd that failed.
    2119                 :            :  * @shost:      Host to unjam.
    2120                 :            :  *
    2121                 :            :  * Notes:
    2122                 :            :  *    When we come in here, we *know* that all commands on the bus have
    2123                 :            :  *    either completed, failed or timed out.  we also know that no further
    2124                 :            :  *    commands are being sent to the host, so things are relatively quiet
    2125                 :            :  *    and we have freedom to fiddle with things as we wish.
    2126                 :            :  *
    2127                 :            :  *    This is only the *default* implementation.  it is possible for
    2128                 :            :  *    individual drivers to supply their own version of this function, and
    2129                 :            :  *    if the maintainer wishes to do this, it is strongly suggested that
    2130                 :            :  *    this function be taken as a template and modified.  this function
    2131                 :            :  *    was designed to correctly handle problems for about 95% of the
    2132                 :            :  *    different cases out there, and it should always provide at least a
    2133                 :            :  *    reasonable amount of error recovery.
    2134                 :            :  *
    2135                 :            :  *    Any command marked 'failed' or 'timeout' must eventually have
    2136                 :            :  *    scsi_finish_cmd() called for it.  we do all of the retry stuff
    2137                 :            :  *    here, so when we restart the host after we return it should have an
    2138                 :            :  *    empty queue.
    2139                 :            :  */
    2140                 :          0 : static void scsi_unjam_host(struct Scsi_Host *shost)
    2141                 :            : {
    2142                 :          0 :         unsigned long flags;
    2143                 :          0 :         LIST_HEAD(eh_work_q);
    2144                 :          0 :         LIST_HEAD(eh_done_q);
    2145                 :            : 
    2146                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    2147         [ #  # ]:          0 :         list_splice_init(&shost->eh_cmd_q, &eh_work_q);
    2148                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2149                 :            : 
    2150                 :          0 :         SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q));
    2151                 :            : 
    2152         [ #  # ]:          0 :         if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q))
    2153                 :          0 :                 scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q);
    2154                 :            : 
    2155                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    2156         [ #  # ]:          0 :         if (shost->eh_deadline != -1)
    2157                 :          0 :                 shost->last_reset = 0;
    2158                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2159                 :          0 :         scsi_eh_flush_done_q(&eh_done_q);
    2160                 :          0 : }
    2161                 :            : 
    2162                 :            : /**
    2163                 :            :  * scsi_error_handler - SCSI error handler thread
    2164                 :            :  * @data:       Host for which we are running.
    2165                 :            :  *
    2166                 :            :  * Notes:
    2167                 :            :  *    This is the main error handling loop.  This is run as a kernel thread
    2168                 :            :  *    for every SCSI host and handles all error handling activity.
    2169                 :            :  */
    2170                 :        156 : int scsi_error_handler(void *data)
    2171                 :            : {
    2172                 :        156 :         struct Scsi_Host *shost = data;
    2173                 :            : 
    2174                 :            :         /*
    2175                 :            :          * We use TASK_INTERRUPTIBLE so that the thread is not
    2176                 :            :          * counted against the load average as a running process.
    2177                 :            :          * We never actually get interrupted because kthread_run
    2178                 :            :          * disables signal delivery for the created thread.
    2179                 :            :          */
    2180                 :       2026 :         while (true) {
    2181                 :            :                 /*
    2182                 :            :                  * The sequence in kthread_stop() sets the stop flag first
    2183                 :            :                  * then wakes the process.  To avoid missed wakeups, the task
    2184                 :            :                  * should always be in a non running state before the stop
    2185                 :            :                  * flag is checked
    2186                 :            :                  */
    2187                 :       2026 :                 set_current_state(TASK_INTERRUPTIBLE);
    2188         [ +  - ]:       2026 :                 if (kthread_should_stop())
    2189                 :            :                         break;
    2190                 :            : 
    2191   [ +  +  +  + ]:       2026 :                 if ((shost->host_failed == 0 && shost->host_eh_scheduled == 0) ||
    2192         [ -  + ]:        935 :                     shost->host_failed != scsi_host_busy(shost)) {
    2193                 :       1091 :                         SCSI_LOG_ERROR_RECOVERY(1,
    2194                 :            :                                 shost_printk(KERN_INFO, shost,
    2195                 :            :                                              "scsi_eh_%d: sleeping\n",
    2196                 :       1091 :                                              shost->host_no));
    2197                 :       1091 :                         schedule();
    2198                 :        935 :                         continue;
    2199                 :            :                 }
    2200                 :            : 
    2201         [ -  + ]:        935 :                 __set_current_state(TASK_RUNNING);
    2202                 :        935 :                 SCSI_LOG_ERROR_RECOVERY(1,
    2203                 :            :                         shost_printk(KERN_INFO, shost,
    2204                 :            :                                      "scsi_eh_%d: waking up %d/%d/%d\n",
    2205                 :            :                                      shost->host_no, shost->host_eh_scheduled,
    2206                 :            :                                      shost->host_failed,
    2207                 :        935 :                                      scsi_host_busy(shost)));
    2208                 :            : 
    2209                 :            :                 /*
    2210                 :            :                  * We have a host that is failing for some reason.  Figure out
    2211                 :            :                  * what we need to do to get it up and online again (if we can).
    2212                 :            :                  * If we fail, we end up taking the thing offline.
    2213                 :            :                  */
    2214   [ -  +  -  - ]:        935 :                 if (!shost->eh_noresume && scsi_autopm_get_host(shost) != 0) {
    2215                 :          0 :                         SCSI_LOG_ERROR_RECOVERY(1,
    2216                 :            :                                 shost_printk(KERN_ERR, shost,
    2217                 :            :                                              "scsi_eh_%d: unable to autoresume\n",
    2218                 :          0 :                                              shost->host_no));
    2219                 :          0 :                         continue;
    2220                 :            :                 }
    2221                 :            : 
    2222         [ +  - ]:        935 :                 if (shost->transportt->eh_strategy_handler)
    2223                 :        935 :                         shost->transportt->eh_strategy_handler(shost);
    2224                 :            :                 else
    2225                 :          0 :                         scsi_unjam_host(shost);
    2226                 :            : 
    2227                 :            :                 /* All scmds have been handled */
    2228                 :        935 :                 shost->host_failed = 0;
    2229                 :            : 
    2230                 :            :                 /*
    2231                 :            :                  * Note - if the above fails completely, the action is to take
    2232                 :            :                  * individual devices offline and flush the queue of any
    2233                 :            :                  * outstanding requests that may have been pending.  When we
    2234                 :            :                  * restart, we restart any I/O to any other devices on the bus
    2235                 :            :                  * which are still online.
    2236                 :            :                  */
    2237                 :        935 :                 scsi_restart_operations(shost);
    2238         [ +  - ]:        935 :                 if (!shost->eh_noresume)
    2239                 :          0 :                         scsi_autopm_put_host(shost);
    2240                 :            :         }
    2241                 :          0 :         __set_current_state(TASK_RUNNING);
    2242                 :            : 
    2243                 :          0 :         SCSI_LOG_ERROR_RECOVERY(1,
    2244                 :            :                 shost_printk(KERN_INFO, shost,
    2245                 :            :                              "Error handler scsi_eh_%d exiting\n",
    2246                 :          0 :                              shost->host_no));
    2247                 :          0 :         shost->ehandler = NULL;
    2248                 :          0 :         return 0;
    2249                 :            : }
    2250                 :            : 
    2251                 :            : /*
    2252                 :            :  * Function:    scsi_report_bus_reset()
    2253                 :            :  *
    2254                 :            :  * Purpose:     Utility function used by low-level drivers to report that
    2255                 :            :  *              they have observed a bus reset on the bus being handled.
    2256                 :            :  *
    2257                 :            :  * Arguments:   shost       - Host in question
    2258                 :            :  *              channel     - channel on which reset was observed.
    2259                 :            :  *
    2260                 :            :  * Returns:     Nothing
    2261                 :            :  *
    2262                 :            :  * Lock status: Host lock must be held.
    2263                 :            :  *
    2264                 :            :  * Notes:       This only needs to be called if the reset is one which
    2265                 :            :  *              originates from an unknown location.  Resets originated
    2266                 :            :  *              by the mid-level itself don't need to call this, but there
    2267                 :            :  *              should be no harm.
    2268                 :            :  *
    2269                 :            :  *              The main purpose of this is to make sure that a CHECK_CONDITION
    2270                 :            :  *              is properly treated.
    2271                 :            :  */
    2272                 :          0 : void scsi_report_bus_reset(struct Scsi_Host *shost, int channel)
    2273                 :            : {
    2274                 :          0 :         struct scsi_device *sdev;
    2275                 :            : 
    2276   [ #  #  #  #  :          0 :         __shost_for_each_device(sdev, shost) {
                   #  # ]
    2277   [ #  #  #  #  :          0 :                 if (channel == sdev_channel(sdev))
                   #  # ]
    2278                 :          0 :                         __scsi_report_device_reset(sdev, NULL);
    2279                 :            :         }
    2280                 :          0 : }
    2281                 :            : EXPORT_SYMBOL(scsi_report_bus_reset);
    2282                 :            : 
    2283                 :            : /*
    2284                 :            :  * Function:    scsi_report_device_reset()
    2285                 :            :  *
    2286                 :            :  * Purpose:     Utility function used by low-level drivers to report that
    2287                 :            :  *              they have observed a device reset on the device being handled.
    2288                 :            :  *
    2289                 :            :  * Arguments:   shost       - Host in question
    2290                 :            :  *              channel     - channel on which reset was observed
    2291                 :            :  *              target      - target on which reset was observed
    2292                 :            :  *
    2293                 :            :  * Returns:     Nothing
    2294                 :            :  *
    2295                 :            :  * Lock status: Host lock must be held
    2296                 :            :  *
    2297                 :            :  * Notes:       This only needs to be called if the reset is one which
    2298                 :            :  *              originates from an unknown location.  Resets originated
    2299                 :            :  *              by the mid-level itself don't need to call this, but there
    2300                 :            :  *              should be no harm.
    2301                 :            :  *
    2302                 :            :  *              The main purpose of this is to make sure that a CHECK_CONDITION
    2303                 :            :  *              is properly treated.
    2304                 :            :  */
    2305                 :          0 : void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target)
    2306                 :            : {
    2307                 :          0 :         struct scsi_device *sdev;
    2308                 :            : 
    2309         [ #  # ]:          0 :         __shost_for_each_device(sdev, shost) {
    2310   [ #  #  #  # ]:          0 :                 if (channel == sdev_channel(sdev) &&
    2311         [ #  # ]:          0 :                     target == sdev_id(sdev))
    2312                 :          0 :                         __scsi_report_device_reset(sdev, NULL);
    2313                 :            :         }
    2314                 :          0 : }
    2315                 :            : EXPORT_SYMBOL(scsi_report_device_reset);
    2316                 :            : 
    2317                 :            : static void
    2318                 :          0 : scsi_reset_provider_done_command(struct scsi_cmnd *scmd)
    2319                 :            : {
    2320                 :          0 : }
    2321                 :            : 
    2322                 :            : /**
    2323                 :            :  * scsi_ioctl_reset: explicitly reset a host/bus/target/device
    2324                 :            :  * @dev:        scsi_device to operate on
    2325                 :            :  * @arg:        reset type (see sg.h)
    2326                 :            :  */
    2327                 :            : int
    2328                 :          0 : scsi_ioctl_reset(struct scsi_device *dev, int __user *arg)
    2329                 :            : {
    2330                 :          0 :         struct scsi_cmnd *scmd;
    2331                 :          0 :         struct Scsi_Host *shost = dev->host;
    2332                 :          0 :         struct request *rq;
    2333                 :          0 :         unsigned long flags;
    2334                 :          0 :         int error = 0, rtn, val;
    2335                 :            : 
    2336   [ #  #  #  # ]:          0 :         if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
    2337                 :          0 :                 return -EACCES;
    2338                 :            : 
    2339                 :          0 :         error = get_user(val, arg);
    2340         [ #  # ]:          0 :         if (error)
    2341                 :            :                 return error;
    2342                 :            : 
    2343         [ #  # ]:          0 :         if (scsi_autopm_get_host(shost) < 0)
    2344                 :            :                 return -EIO;
    2345                 :            : 
    2346                 :          0 :         error = -EIO;
    2347                 :          0 :         rq = kzalloc(sizeof(struct request) + sizeof(struct scsi_cmnd) +
    2348                 :          0 :                         shost->hostt->cmd_size, GFP_KERNEL);
    2349         [ #  # ]:          0 :         if (!rq)
    2350                 :          0 :                 goto out_put_autopm_host;
    2351                 :          0 :         blk_rq_init(NULL, rq);
    2352                 :            : 
    2353                 :          0 :         scmd = (struct scsi_cmnd *)(rq + 1);
    2354                 :          0 :         scsi_init_command(dev, scmd);
    2355                 :          0 :         scmd->request = rq;
    2356                 :          0 :         scmd->cmnd = scsi_req(rq)->cmd;
    2357                 :            : 
    2358                 :          0 :         scmd->scsi_done              = scsi_reset_provider_done_command;
    2359                 :          0 :         memset(&scmd->sdb, 0, sizeof(scmd->sdb));
    2360                 :            : 
    2361                 :          0 :         scmd->cmd_len                        = 0;
    2362                 :            : 
    2363                 :          0 :         scmd->sc_data_direction              = DMA_BIDIRECTIONAL;
    2364                 :            : 
    2365                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    2366                 :          0 :         shost->tmf_in_progress = 1;
    2367                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2368                 :            : 
    2369   [ #  #  #  #  :          0 :         switch (val & ~SG_SCSI_RESET_NO_ESCALATE) {
                   #  # ]
    2370                 :            :         case SG_SCSI_RESET_NOTHING:
    2371                 :            :                 rtn = SUCCESS;
    2372                 :            :                 break;
    2373                 :            :         case SG_SCSI_RESET_DEVICE:
    2374         [ #  # ]:          0 :                 rtn = scsi_try_bus_device_reset(scmd);
    2375   [ #  #  #  # ]:          0 :                 if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
    2376                 :            :                         break;
    2377                 :            :                 /* FALLTHROUGH */
    2378                 :            :         case SG_SCSI_RESET_TARGET:
    2379                 :          0 :                 rtn = scsi_try_target_reset(scmd);
    2380   [ #  #  #  # ]:          0 :                 if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
    2381                 :            :                         break;
    2382                 :            :                 /* FALLTHROUGH */
    2383                 :            :         case SG_SCSI_RESET_BUS:
    2384                 :          0 :                 rtn = scsi_try_bus_reset(scmd);
    2385   [ #  #  #  # ]:          0 :                 if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
    2386                 :            :                         break;
    2387                 :            :                 /* FALLTHROUGH */
    2388                 :            :         case SG_SCSI_RESET_HOST:
    2389                 :          0 :                 rtn = scsi_try_host_reset(scmd);
    2390         [ #  # ]:          0 :                 if (rtn == SUCCESS)
    2391                 :            :                         break;
    2392                 :            :                 /* FALLTHROUGH */
    2393                 :            :         default:
    2394                 :            :                 rtn = FAILED;
    2395                 :            :                 break;
    2396                 :            :         }
    2397                 :            : 
    2398         [ #  # ]:          0 :         error = (rtn == SUCCESS) ? 0 : -EIO;
    2399                 :            : 
    2400                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    2401                 :          0 :         shost->tmf_in_progress = 0;
    2402                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    2403                 :            : 
    2404                 :            :         /*
    2405                 :            :          * be sure to wake up anyone who was sleeping or had their queue
    2406                 :            :          * suspended while we performed the TMF.
    2407                 :            :          */
    2408                 :          0 :         SCSI_LOG_ERROR_RECOVERY(3,
    2409                 :            :                 shost_printk(KERN_INFO, shost,
    2410                 :          0 :                              "waking up host to restart after TMF\n"));
    2411                 :            : 
    2412                 :          0 :         wake_up(&shost->host_wait);
    2413                 :          0 :         scsi_run_host_queues(shost);
    2414                 :            : 
    2415                 :          0 :         scsi_put_command(scmd);
    2416                 :          0 :         kfree(rq);
    2417                 :            : 
    2418                 :          0 : out_put_autopm_host:
    2419                 :          0 :         scsi_autopm_put_host(shost);
    2420                 :          0 :         return error;
    2421                 :            : }
    2422                 :            : 
    2423                 :       2026 : bool scsi_command_normalize_sense(const struct scsi_cmnd *cmd,
    2424                 :            :                                   struct scsi_sense_hdr *sshdr)
    2425                 :            : {
    2426                 :       2026 :         return scsi_normalize_sense(cmd->sense_buffer,
    2427                 :            :                         SCSI_SENSE_BUFFERSIZE, sshdr);
    2428                 :            : }
    2429                 :            : EXPORT_SYMBOL(scsi_command_normalize_sense);
    2430                 :            : 
    2431                 :            : /**
    2432                 :            :  * scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format)
    2433                 :            :  * @sense_buffer:       byte array of sense data
    2434                 :            :  * @sb_len:             number of valid bytes in sense_buffer
    2435                 :            :  * @info_out:           pointer to 64 integer where 8 or 4 byte information
    2436                 :            :  *                      field will be placed if found.
    2437                 :            :  *
    2438                 :            :  * Return value:
    2439                 :            :  *      true if information field found, false if not found.
    2440                 :            :  */
    2441                 :          0 : bool scsi_get_sense_info_fld(const u8 *sense_buffer, int sb_len,
    2442                 :            :                              u64 *info_out)
    2443                 :            : {
    2444                 :          0 :         const u8 * ucp;
    2445                 :            : 
    2446         [ #  # ]:          0 :         if (sb_len < 7)
    2447                 :            :                 return false;
    2448      [ #  #  # ]:          0 :         switch (sense_buffer[0] & 0x7f) {
    2449                 :          0 :         case 0x70:
    2450                 :            :         case 0x71:
    2451         [ #  # ]:          0 :                 if (sense_buffer[0] & 0x80) {
    2452                 :          0 :                         *info_out = get_unaligned_be32(&sense_buffer[3]);
    2453                 :          0 :                         return true;
    2454                 :            :                 }
    2455                 :            :                 return false;
    2456                 :          0 :         case 0x72:
    2457                 :            :         case 0x73:
    2458                 :          0 :                 ucp = scsi_sense_desc_find(sense_buffer, sb_len,
    2459                 :            :                                            0 /* info desc */);
    2460   [ #  #  #  # ]:          0 :                 if (ucp && (0xa == ucp[1])) {
    2461                 :          0 :                         *info_out = get_unaligned_be64(&ucp[4]);
    2462                 :          0 :                         return true;
    2463                 :            :                 }
    2464                 :            :                 return false;
    2465                 :            :         default:
    2466                 :            :                 return false;
    2467                 :            :         }
    2468                 :            : }
    2469                 :            : EXPORT_SYMBOL(scsi_get_sense_info_fld);

Generated by: LCOV version 1.14