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