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