2 * scsi_error.c Copyright (C) 1997 Eric Youngdale
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.
9 * Restructured scsi_unjam_host and associated functions.
10 * September 04, 2002 Mike Anderson (andmike@us.ibm.com)
12 * Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
14 * September 30, 2002 Mike Anderson (andmike@us.ibm.com)
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>
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_common.h>
37 #include <scsi/scsi_transport.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_ioctl.h>
40 #include <scsi/scsi_dh.h>
43 #include "scsi_priv.h"
44 #include "scsi_logging.h"
45 #include "scsi_transport_api.h"
47 #include <trace/events/scsi.h>
49 #include <asm/unaligned.h>
51 static void scsi_eh_done(struct scsi_cmnd
*scmd
);
54 * These should *probably* be handled by the host itself.
55 * Since it is allowed to sleep, it probably should.
57 #define BUS_RESET_SETTLE_TIME (10)
58 #define HOST_RESET_SETTLE_TIME (10)
60 static int scsi_eh_try_stu(struct scsi_cmnd
*scmd
);
61 static int scsi_try_to_abort_cmd(struct scsi_host_template
*,
64 /* called with shost->host_lock held */
65 void scsi_eh_wakeup(struct Scsi_Host
*shost
)
67 if (atomic_read(&shost
->host_busy
) == shost
->host_failed
) {
68 trace_scsi_eh_wakeup(shost
);
69 wake_up_process(shost
->ehandler
);
70 SCSI_LOG_ERROR_RECOVERY(5, shost_printk(KERN_INFO
, shost
,
71 "Waking error handler thread\n"));
76 * scsi_schedule_eh - schedule EH for SCSI host
77 * @shost: SCSI host to invoke error handling on.
79 * Schedule SCSI EH without scmd.
81 void scsi_schedule_eh(struct Scsi_Host
*shost
)
85 spin_lock_irqsave(shost
->host_lock
, flags
);
87 if (scsi_host_set_state(shost
, SHOST_RECOVERY
) == 0 ||
88 scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
) == 0) {
89 shost
->host_eh_scheduled
++;
90 scsi_eh_wakeup(shost
);
93 spin_unlock_irqrestore(shost
->host_lock
, flags
);
95 EXPORT_SYMBOL_GPL(scsi_schedule_eh
);
97 static int scsi_host_eh_past_deadline(struct Scsi_Host
*shost
)
99 if (!shost
->last_reset
|| shost
->eh_deadline
== -1)
103 * 32bit accesses are guaranteed to be atomic
104 * (on all supported architectures), so instead
105 * of using a spinlock we can as well double check
106 * if eh_deadline has been set to 'off' during the
109 if (time_before(jiffies
, shost
->last_reset
+ shost
->eh_deadline
) &&
110 shost
->eh_deadline
> -1)
117 * scmd_eh_abort_handler - Handle command aborts
118 * @work: command to be aborted.
121 scmd_eh_abort_handler(struct work_struct
*work
)
123 struct scsi_cmnd
*scmd
=
124 container_of(work
, struct scsi_cmnd
, abort_work
.work
);
125 struct scsi_device
*sdev
= scmd
->device
;
128 if (scsi_host_eh_past_deadline(sdev
->host
)) {
129 SCSI_LOG_ERROR_RECOVERY(3,
130 scmd_printk(KERN_INFO
, scmd
,
131 "eh timeout, not aborting\n"));
133 SCSI_LOG_ERROR_RECOVERY(3,
134 scmd_printk(KERN_INFO
, scmd
,
135 "aborting command\n"));
136 rtn
= scsi_try_to_abort_cmd(sdev
->host
->hostt
, scmd
);
137 if (rtn
== SUCCESS
) {
138 set_host_byte(scmd
, DID_TIME_OUT
);
139 if (scsi_host_eh_past_deadline(sdev
->host
)) {
140 SCSI_LOG_ERROR_RECOVERY(3,
141 scmd_printk(KERN_INFO
, scmd
,
142 "eh timeout, not retrying "
143 "aborted command\n"));
144 } else if (!scsi_noretry_cmd(scmd
) &&
145 (++scmd
->retries
<= scmd
->allowed
)) {
146 SCSI_LOG_ERROR_RECOVERY(3,
147 scmd_printk(KERN_WARNING
, scmd
,
148 "retry aborted command\n"));
149 scsi_queue_insert(scmd
, SCSI_MLQUEUE_EH_RETRY
);
152 SCSI_LOG_ERROR_RECOVERY(3,
153 scmd_printk(KERN_WARNING
, scmd
,
154 "finish aborted command\n"));
155 scsi_finish_command(scmd
);
159 SCSI_LOG_ERROR_RECOVERY(3,
160 scmd_printk(KERN_INFO
, scmd
,
162 (rtn
== FAST_IO_FAIL
) ?
163 "not send" : "failed"));
167 scsi_eh_scmd_add(scmd
);
171 * scsi_abort_command - schedule a command abort
172 * @scmd: scmd to abort.
174 * We only need to abort commands after a command timeout
177 scsi_abort_command(struct scsi_cmnd
*scmd
)
179 struct scsi_device
*sdev
= scmd
->device
;
180 struct Scsi_Host
*shost
= sdev
->host
;
183 if (scmd
->eh_eflags
& SCSI_EH_ABORT_SCHEDULED
) {
185 * Retry after abort failed, escalate to next level.
187 SCSI_LOG_ERROR_RECOVERY(3,
188 scmd_printk(KERN_INFO
, scmd
,
189 "previous abort failed\n"));
190 BUG_ON(delayed_work_pending(&scmd
->abort_work
));
194 spin_lock_irqsave(shost
->host_lock
, flags
);
195 if (shost
->eh_deadline
!= -1 && !shost
->last_reset
)
196 shost
->last_reset
= jiffies
;
197 spin_unlock_irqrestore(shost
->host_lock
, flags
);
199 scmd
->eh_eflags
|= SCSI_EH_ABORT_SCHEDULED
;
200 SCSI_LOG_ERROR_RECOVERY(3,
201 scmd_printk(KERN_INFO
, scmd
, "abort scheduled\n"));
202 queue_delayed_work(shost
->tmf_work_q
, &scmd
->abort_work
, HZ
/ 100);
207 * scsi_eh_reset - call into ->eh_action to reset internal counters
208 * @scmd: scmd to run eh on.
210 * The scsi driver might be carrying internal state about the
211 * devices, so we need to call into the driver to reset the
212 * internal state once the error handler is started.
214 static void scsi_eh_reset(struct scsi_cmnd
*scmd
)
216 if (!blk_rq_is_passthrough(scmd
->request
)) {
217 struct scsi_driver
*sdrv
= scsi_cmd_to_driver(scmd
);
219 sdrv
->eh_reset(scmd
);
224 * scsi_eh_scmd_add - add scsi cmd to error handling.
225 * @scmd: scmd to run eh on.
227 void scsi_eh_scmd_add(struct scsi_cmnd
*scmd
)
229 struct Scsi_Host
*shost
= scmd
->device
->host
;
233 WARN_ON_ONCE(!shost
->ehandler
);
235 spin_lock_irqsave(shost
->host_lock
, flags
);
236 if (scsi_host_set_state(shost
, SHOST_RECOVERY
)) {
237 ret
= scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
);
240 if (shost
->eh_deadline
!= -1 && !shost
->last_reset
)
241 shost
->last_reset
= jiffies
;
244 list_add_tail(&scmd
->eh_entry
, &shost
->eh_cmd_q
);
245 shost
->host_failed
++;
246 scsi_eh_wakeup(shost
);
247 spin_unlock_irqrestore(shost
->host_lock
, flags
);
251 * scsi_times_out - Timeout function for normal scsi commands.
252 * @req: request that is timing out.
255 * We do not need to lock this. There is the potential for a race
256 * only in that the normal completion handling might run, but if the
257 * normal completion function determines that the timer has already
258 * fired, then it mustn't do anything.
260 enum blk_eh_timer_return
scsi_times_out(struct request
*req
)
262 struct scsi_cmnd
*scmd
= blk_mq_rq_to_pdu(req
);
263 enum blk_eh_timer_return rtn
= BLK_EH_NOT_HANDLED
;
264 struct Scsi_Host
*host
= scmd
->device
->host
;
266 trace_scsi_dispatch_cmd_timeout(scmd
);
267 scsi_log_completion(scmd
, TIMEOUT_ERROR
);
269 if (host
->eh_deadline
!= -1 && !host
->last_reset
)
270 host
->last_reset
= jiffies
;
272 if (host
->hostt
->eh_timed_out
)
273 rtn
= host
->hostt
->eh_timed_out(scmd
);
275 if (rtn
== BLK_EH_NOT_HANDLED
) {
276 if (scsi_abort_command(scmd
) != SUCCESS
) {
277 set_host_byte(scmd
, DID_TIME_OUT
);
278 scsi_eh_scmd_add(scmd
);
286 * scsi_block_when_processing_errors - Prevent cmds from being queued.
287 * @sdev: Device on which we are performing recovery.
290 * We block until the host is out of error recovery, and then check to
291 * see whether the host or the device is offline.
294 * 0 when dev was taken offline by error recovery. 1 OK to proceed.
296 int scsi_block_when_processing_errors(struct scsi_device
*sdev
)
300 wait_event(sdev
->host
->host_wait
, !scsi_host_in_recovery(sdev
->host
));
302 online
= scsi_device_online(sdev
);
304 SCSI_LOG_ERROR_RECOVERY(5, sdev_printk(KERN_INFO
, sdev
,
305 "%s: rtn: %d\n", __func__
, online
));
309 EXPORT_SYMBOL(scsi_block_when_processing_errors
);
311 #ifdef CONFIG_SCSI_LOGGING
313 * scsi_eh_prt_fail_stats - Log info on failures.
314 * @shost: scsi host being recovered.
315 * @work_q: Queue of scsi cmds to process.
317 static inline void scsi_eh_prt_fail_stats(struct Scsi_Host
*shost
,
318 struct list_head
*work_q
)
320 struct scsi_cmnd
*scmd
;
321 struct scsi_device
*sdev
;
322 int total_failures
= 0;
325 int devices_failed
= 0;
327 shost_for_each_device(sdev
, shost
) {
328 list_for_each_entry(scmd
, work_q
, eh_entry
) {
329 if (scmd
->device
== sdev
) {
331 if (scmd
->eh_eflags
& SCSI_EH_ABORT_SCHEDULED
)
338 if (cmd_cancel
|| cmd_failed
) {
339 SCSI_LOG_ERROR_RECOVERY(3,
340 shost_printk(KERN_INFO
, shost
,
341 "%s: cmds failed: %d, cancel: %d\n",
342 __func__
, cmd_failed
,
350 SCSI_LOG_ERROR_RECOVERY(2, shost_printk(KERN_INFO
, shost
,
351 "Total of %d commands on %d"
352 " devices require eh work\n",
353 total_failures
, devices_failed
));
358 * scsi_report_lun_change - Set flag on all *other* devices on the same target
359 * to indicate that a UNIT ATTENTION is expected.
360 * @sdev: Device reporting the UNIT ATTENTION
362 static void scsi_report_lun_change(struct scsi_device
*sdev
)
364 sdev
->sdev_target
->expecting_lun_change
= 1;
368 * scsi_report_sense - Examine scsi sense information and log messages for
369 * certain conditions, also issue uevents for some of them.
370 * @sdev: Device reporting the sense code
371 * @sshdr: sshdr to be examined
373 static void scsi_report_sense(struct scsi_device
*sdev
,
374 struct scsi_sense_hdr
*sshdr
)
376 enum scsi_device_event evt_type
= SDEV_EVT_MAXBITS
; /* i.e. none */
378 if (sshdr
->sense_key
== UNIT_ATTENTION
) {
379 if (sshdr
->asc
== 0x3f && sshdr
->ascq
== 0x03) {
380 evt_type
= SDEV_EVT_INQUIRY_CHANGE_REPORTED
;
381 sdev_printk(KERN_WARNING
, sdev
,
382 "Inquiry data has changed");
383 } else if (sshdr
->asc
== 0x3f && sshdr
->ascq
== 0x0e) {
384 evt_type
= SDEV_EVT_LUN_CHANGE_REPORTED
;
385 scsi_report_lun_change(sdev
);
386 sdev_printk(KERN_WARNING
, sdev
,
387 "Warning! Received an indication that the "
388 "LUN assignments on this target have "
389 "changed. The Linux SCSI layer does not "
390 "automatically remap LUN assignments.\n");
391 } else if (sshdr
->asc
== 0x3f)
392 sdev_printk(KERN_WARNING
, sdev
,
393 "Warning! Received an indication that the "
394 "operating parameters on this target have "
395 "changed. The Linux SCSI layer does not "
396 "automatically adjust these parameters.\n");
398 if (sshdr
->asc
== 0x38 && sshdr
->ascq
== 0x07) {
399 evt_type
= SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED
;
400 sdev_printk(KERN_WARNING
, sdev
,
401 "Warning! Received an indication that the "
402 "LUN reached a thin provisioning soft "
406 if (sshdr
->asc
== 0x2a && sshdr
->ascq
== 0x01) {
407 evt_type
= SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED
;
408 sdev_printk(KERN_WARNING
, sdev
,
409 "Mode parameters changed");
410 } else if (sshdr
->asc
== 0x2a && sshdr
->ascq
== 0x06) {
411 evt_type
= SDEV_EVT_ALUA_STATE_CHANGE_REPORTED
;
412 sdev_printk(KERN_WARNING
, sdev
,
413 "Asymmetric access state changed");
414 } else if (sshdr
->asc
== 0x2a && sshdr
->ascq
== 0x09) {
415 evt_type
= SDEV_EVT_CAPACITY_CHANGE_REPORTED
;
416 sdev_printk(KERN_WARNING
, sdev
,
417 "Capacity data has changed");
418 } else if (sshdr
->asc
== 0x2a)
419 sdev_printk(KERN_WARNING
, sdev
,
420 "Parameters changed");
423 if (evt_type
!= SDEV_EVT_MAXBITS
) {
424 set_bit(evt_type
, sdev
->pending_events
);
425 schedule_work(&sdev
->event_work
);
430 * scsi_check_sense - Examine scsi cmd sense
431 * @scmd: Cmd to have sense checked.
434 * SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE
437 * When a deferred error is detected the current command has
438 * not been executed and needs retrying.
440 int scsi_check_sense(struct scsi_cmnd
*scmd
)
442 struct scsi_device
*sdev
= scmd
->device
;
443 struct scsi_sense_hdr sshdr
;
445 if (! scsi_command_normalize_sense(scmd
, &sshdr
))
446 return FAILED
; /* no valid sense data */
448 scsi_report_sense(sdev
, &sshdr
);
450 if (scsi_sense_is_deferred(&sshdr
))
453 if (sdev
->handler
&& sdev
->handler
->check_sense
) {
456 rc
= sdev
->handler
->check_sense(sdev
, &sshdr
);
457 if (rc
!= SCSI_RETURN_NOT_HANDLED
)
459 /* handler does not care. Drop down to default handling */
462 if (scmd
->cmnd
[0] == TEST_UNIT_READY
&& scmd
->scsi_done
!= scsi_eh_done
)
464 * nasty: for mid-layer issued TURs, we need to return the
465 * actual sense data without any recovery attempt. For eh
466 * issued ones, we need to try to recover and interpret
471 * Previous logic looked for FILEMARK, EOM or ILI which are
472 * mainly associated with tapes and returned SUCCESS.
474 if (sshdr
.response_code
== 0x70) {
476 if (scmd
->sense_buffer
[2] & 0xe0)
480 * descriptor format: look for "stream commands sense data
481 * descriptor" (see SSC-3). Assume single sense data
482 * descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
484 if ((sshdr
.additional_length
> 3) &&
485 (scmd
->sense_buffer
[8] == 0x4) &&
486 (scmd
->sense_buffer
[11] & 0xe0))
490 switch (sshdr
.sense_key
) {
493 case RECOVERED_ERROR
:
494 return /* soft_error */ SUCCESS
;
496 case ABORTED_COMMAND
:
497 if (sshdr
.asc
== 0x10) /* DIF */
504 * if we are expecting a cc/ua because of a bus reset that we
505 * performed, treat this just as a retry. otherwise this is
506 * information that we should pass up to the upper-level driver
507 * so that we can deal with it there.
509 if (scmd
->device
->expecting_cc_ua
) {
511 * Because some device does not queue unit
512 * attentions correctly, we carefully check
513 * additional sense code and qualifier so as
514 * not to squash media change unit attention.
516 if (sshdr
.asc
!= 0x28 || sshdr
.ascq
!= 0x00) {
517 scmd
->device
->expecting_cc_ua
= 0;
522 * we might also expect a cc/ua if another LUN on the target
523 * reported a UA with an ASC/ASCQ of 3F 0E -
524 * REPORTED LUNS DATA HAS CHANGED.
526 if (scmd
->device
->sdev_target
->expecting_lun_change
&&
527 sshdr
.asc
== 0x3f && sshdr
.ascq
== 0x0e)
530 * if the device is in the process of becoming ready, we
533 if ((sshdr
.asc
== 0x04) && (sshdr
.ascq
== 0x01))
536 * if the device is not started, we need to wake
537 * the error handler to start the motor
539 if (scmd
->device
->allow_restart
&&
540 (sshdr
.asc
== 0x04) && (sshdr
.ascq
== 0x02))
543 * Pass the UA upwards for a determination in the completion
548 /* these are not supported */
550 if (sshdr
.asc
== 0x27 && sshdr
.ascq
== 0x07) {
551 /* Thin provisioning hard threshold reached */
552 set_host_byte(scmd
, DID_ALLOC_FAILURE
);
557 case VOLUME_OVERFLOW
:
560 set_host_byte(scmd
, DID_TARGET_FAILURE
);
564 if (sshdr
.asc
== 0x11 || /* UNRECOVERED READ ERR */
565 sshdr
.asc
== 0x13 || /* AMNF DATA FIELD */
566 sshdr
.asc
== 0x14) { /* RECORD NOT FOUND */
567 set_host_byte(scmd
, DID_MEDIUM_ERROR
);
573 if (scmd
->device
->retry_hwerror
)
574 return ADD_TO_MLQUEUE
;
576 set_host_byte(scmd
, DID_TARGET_FAILURE
);
579 case ILLEGAL_REQUEST
:
580 if (sshdr
.asc
== 0x20 || /* Invalid command operation code */
581 sshdr
.asc
== 0x21 || /* Logical block address out of range */
582 sshdr
.asc
== 0x24 || /* Invalid field in cdb */
583 sshdr
.asc
== 0x26 || /* Parameter value invalid */
584 sshdr
.asc
== 0x27) { /* Write protected */
585 set_host_byte(scmd
, DID_TARGET_FAILURE
);
593 EXPORT_SYMBOL_GPL(scsi_check_sense
);
595 static void scsi_handle_queue_ramp_up(struct scsi_device
*sdev
)
597 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
598 struct scsi_device
*tmp_sdev
;
600 if (!sht
->track_queue_depth
||
601 sdev
->queue_depth
>= sdev
->max_queue_depth
)
604 if (time_before(jiffies
,
605 sdev
->last_queue_ramp_up
+ sdev
->queue_ramp_up_period
))
608 if (time_before(jiffies
,
609 sdev
->last_queue_full_time
+ sdev
->queue_ramp_up_period
))
613 * Walk all devices of a target and do
616 shost_for_each_device(tmp_sdev
, sdev
->host
) {
617 if (tmp_sdev
->channel
!= sdev
->channel
||
618 tmp_sdev
->id
!= sdev
->id
||
619 tmp_sdev
->queue_depth
== sdev
->max_queue_depth
)
622 scsi_change_queue_depth(tmp_sdev
, tmp_sdev
->queue_depth
+ 1);
623 sdev
->last_queue_ramp_up
= jiffies
;
627 static void scsi_handle_queue_full(struct scsi_device
*sdev
)
629 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
630 struct scsi_device
*tmp_sdev
;
632 if (!sht
->track_queue_depth
)
635 shost_for_each_device(tmp_sdev
, sdev
->host
) {
636 if (tmp_sdev
->channel
!= sdev
->channel
||
637 tmp_sdev
->id
!= sdev
->id
)
640 * We do not know the number of commands that were at
641 * the device when we got the queue full so we start
642 * from the highest possible value and work our way down.
644 scsi_track_queue_full(tmp_sdev
, tmp_sdev
->queue_depth
- 1);
649 * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
650 * @scmd: SCSI cmd to examine.
653 * This is *only* called when we are examining the status of commands
654 * queued during error recovery. the main difference here is that we
655 * don't allow for the possibility of retries here, and we are a lot
656 * more restrictive about what we consider acceptable.
658 static int scsi_eh_completed_normally(struct scsi_cmnd
*scmd
)
661 * first check the host byte, to see if there is anything in there
662 * that would indicate what we need to do.
664 if (host_byte(scmd
->result
) == DID_RESET
) {
666 * rats. we are already in the error handler, so we now
667 * get to try and figure out what to do next. if the sense
668 * is valid, we have a pretty good idea of what to do.
669 * if not, we mark it as FAILED.
671 return scsi_check_sense(scmd
);
673 if (host_byte(scmd
->result
) != DID_OK
)
677 * next, check the message byte.
679 if (msg_byte(scmd
->result
) != COMMAND_COMPLETE
)
683 * now, check the status byte to see if this indicates
686 switch (status_byte(scmd
->result
)) {
688 scsi_handle_queue_ramp_up(scmd
->device
);
690 case COMMAND_TERMINATED
:
692 case CHECK_CONDITION
:
693 return scsi_check_sense(scmd
);
695 case INTERMEDIATE_GOOD
:
696 case INTERMEDIATE_C_GOOD
:
698 * who knows? FIXME(eric)
701 case RESERVATION_CONFLICT
:
702 if (scmd
->cmnd
[0] == TEST_UNIT_READY
)
703 /* it is a success, we probed the device and
706 /* otherwise, we failed to send the command */
709 scsi_handle_queue_full(scmd
->device
);
720 * scsi_eh_done - Completion function for error handling.
721 * @scmd: Cmd that is done.
723 static void scsi_eh_done(struct scsi_cmnd
*scmd
)
725 struct completion
*eh_action
;
727 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
728 "%s result: %x\n", __func__
, scmd
->result
));
730 eh_action
= scmd
->device
->host
->eh_action
;
736 * scsi_try_host_reset - ask host adapter to reset itself
737 * @scmd: SCSI cmd to send host reset.
739 static int scsi_try_host_reset(struct scsi_cmnd
*scmd
)
743 struct Scsi_Host
*host
= scmd
->device
->host
;
744 struct scsi_host_template
*hostt
= host
->hostt
;
746 SCSI_LOG_ERROR_RECOVERY(3,
747 shost_printk(KERN_INFO
, host
, "Snd Host RST\n"));
749 if (!hostt
->eh_host_reset_handler
)
752 rtn
= hostt
->eh_host_reset_handler(scmd
);
754 if (rtn
== SUCCESS
) {
755 if (!hostt
->skip_settle_delay
)
756 ssleep(HOST_RESET_SETTLE_TIME
);
757 spin_lock_irqsave(host
->host_lock
, flags
);
758 scsi_report_bus_reset(host
, scmd_channel(scmd
));
759 spin_unlock_irqrestore(host
->host_lock
, flags
);
766 * scsi_try_bus_reset - ask host to perform a bus reset
767 * @scmd: SCSI cmd to send bus reset.
769 static int scsi_try_bus_reset(struct scsi_cmnd
*scmd
)
773 struct Scsi_Host
*host
= scmd
->device
->host
;
774 struct scsi_host_template
*hostt
= host
->hostt
;
776 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
777 "%s: Snd Bus RST\n", __func__
));
779 if (!hostt
->eh_bus_reset_handler
)
782 rtn
= hostt
->eh_bus_reset_handler(scmd
);
784 if (rtn
== SUCCESS
) {
785 if (!hostt
->skip_settle_delay
)
786 ssleep(BUS_RESET_SETTLE_TIME
);
787 spin_lock_irqsave(host
->host_lock
, flags
);
788 scsi_report_bus_reset(host
, scmd_channel(scmd
));
789 spin_unlock_irqrestore(host
->host_lock
, flags
);
795 static void __scsi_report_device_reset(struct scsi_device
*sdev
, void *data
)
798 sdev
->expecting_cc_ua
= 1;
802 * scsi_try_target_reset - Ask host to perform a target reset
803 * @scmd: SCSI cmd used to send a target reset
806 * There is no timeout for this operation. if this operation is
807 * unreliable for a given host, then the host itself needs to put a
808 * timer on it, and set the host back to a consistent state prior to
811 static int scsi_try_target_reset(struct scsi_cmnd
*scmd
)
815 struct Scsi_Host
*host
= scmd
->device
->host
;
816 struct scsi_host_template
*hostt
= host
->hostt
;
818 if (!hostt
->eh_target_reset_handler
)
821 rtn
= hostt
->eh_target_reset_handler(scmd
);
822 if (rtn
== SUCCESS
) {
823 spin_lock_irqsave(host
->host_lock
, flags
);
824 __starget_for_each_device(scsi_target(scmd
->device
), NULL
,
825 __scsi_report_device_reset
);
826 spin_unlock_irqrestore(host
->host_lock
, flags
);
833 * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
834 * @scmd: SCSI cmd used to send BDR
837 * There is no timeout for this operation. if this operation is
838 * unreliable for a given host, then the host itself needs to put a
839 * timer on it, and set the host back to a consistent state prior to
842 static int scsi_try_bus_device_reset(struct scsi_cmnd
*scmd
)
845 struct scsi_host_template
*hostt
= scmd
->device
->host
->hostt
;
847 if (!hostt
->eh_device_reset_handler
)
850 rtn
= hostt
->eh_device_reset_handler(scmd
);
852 __scsi_report_device_reset(scmd
->device
, NULL
);
857 * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
858 * @hostt: SCSI driver host template
859 * @scmd: SCSI cmd used to send a target reset
862 * SUCCESS, FAILED, or FAST_IO_FAIL
865 * SUCCESS does not necessarily indicate that the command
866 * has been aborted; it only indicates that the LLDDs
867 * has cleared all references to that command.
868 * LLDDs should return FAILED only if an abort was required
869 * but could not be executed. LLDDs should return FAST_IO_FAIL
870 * if the device is temporarily unavailable (eg due to a
871 * link down on FibreChannel)
873 static int scsi_try_to_abort_cmd(struct scsi_host_template
*hostt
,
874 struct scsi_cmnd
*scmd
)
876 if (!hostt
->eh_abort_handler
)
879 return hostt
->eh_abort_handler(scmd
);
882 static void scsi_abort_eh_cmnd(struct scsi_cmnd
*scmd
)
884 if (scsi_try_to_abort_cmd(scmd
->device
->host
->hostt
, scmd
) != SUCCESS
)
885 if (scsi_try_bus_device_reset(scmd
) != SUCCESS
)
886 if (scsi_try_target_reset(scmd
) != SUCCESS
)
887 if (scsi_try_bus_reset(scmd
) != SUCCESS
)
888 scsi_try_host_reset(scmd
);
892 * scsi_eh_prep_cmnd - Save a scsi command info as part of error recovery
893 * @scmd: SCSI command structure to hijack
894 * @ses: structure to save restore information
895 * @cmnd: CDB to send. Can be NULL if no new cmnd is needed
896 * @cmnd_size: size in bytes of @cmnd (must be <= BLK_MAX_CDB)
897 * @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
899 * This function is used to save a scsi command information before re-execution
900 * as part of the error recovery process. If @sense_bytes is 0 the command
901 * sent must be one that does not transfer any data. If @sense_bytes != 0
902 * @cmnd is ignored and this functions sets up a REQUEST_SENSE command
903 * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
905 void scsi_eh_prep_cmnd(struct scsi_cmnd
*scmd
, struct scsi_eh_save
*ses
,
906 unsigned char *cmnd
, int cmnd_size
, unsigned sense_bytes
)
908 struct scsi_device
*sdev
= scmd
->device
;
911 * We need saved copies of a number of fields - this is because
912 * error handling may need to overwrite these with different values
913 * to run different commands, and once error handling is complete,
914 * we will need to restore these values prior to running the actual
917 ses
->cmd_len
= scmd
->cmd_len
;
918 ses
->cmnd
= scmd
->cmnd
;
919 ses
->data_direction
= scmd
->sc_data_direction
;
920 ses
->sdb
= scmd
->sdb
;
921 ses
->next_rq
= scmd
->request
->next_rq
;
922 ses
->result
= scmd
->result
;
923 ses
->underflow
= scmd
->underflow
;
924 ses
->prot_op
= scmd
->prot_op
;
925 ses
->eh_eflags
= scmd
->eh_eflags
;
927 scmd
->prot_op
= SCSI_PROT_NORMAL
;
929 scmd
->cmnd
= ses
->eh_cmnd
;
930 memset(scmd
->cmnd
, 0, BLK_MAX_CDB
);
931 memset(&scmd
->sdb
, 0, sizeof(scmd
->sdb
));
932 scmd
->request
->next_rq
= NULL
;
936 scmd
->sdb
.length
= min_t(unsigned, SCSI_SENSE_BUFFERSIZE
,
938 sg_init_one(&ses
->sense_sgl
, scmd
->sense_buffer
,
940 scmd
->sdb
.table
.sgl
= &ses
->sense_sgl
;
941 scmd
->sc_data_direction
= DMA_FROM_DEVICE
;
942 scmd
->sdb
.table
.nents
= scmd
->sdb
.table
.orig_nents
= 1;
943 scmd
->cmnd
[0] = REQUEST_SENSE
;
944 scmd
->cmnd
[4] = scmd
->sdb
.length
;
945 scmd
->cmd_len
= COMMAND_SIZE(scmd
->cmnd
[0]);
947 scmd
->sc_data_direction
= DMA_NONE
;
949 BUG_ON(cmnd_size
> BLK_MAX_CDB
);
950 memcpy(scmd
->cmnd
, cmnd
, cmnd_size
);
951 scmd
->cmd_len
= COMMAND_SIZE(scmd
->cmnd
[0]);
957 if (sdev
->scsi_level
<= SCSI_2
&& sdev
->scsi_level
!= SCSI_UNKNOWN
)
958 scmd
->cmnd
[1] = (scmd
->cmnd
[1] & 0x1f) |
959 (sdev
->lun
<< 5 & 0xe0);
962 * Zero the sense buffer. The scsi spec mandates that any
963 * untransferred sense data should be interpreted as being zero.
965 memset(scmd
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
967 EXPORT_SYMBOL(scsi_eh_prep_cmnd
);
970 * scsi_eh_restore_cmnd - Restore a scsi command info as part of error recovery
971 * @scmd: SCSI command structure to restore
972 * @ses: saved information from a coresponding call to scsi_eh_prep_cmnd
974 * Undo any damage done by above scsi_eh_prep_cmnd().
976 void scsi_eh_restore_cmnd(struct scsi_cmnd
* scmd
, struct scsi_eh_save
*ses
)
979 * Restore original data
981 scmd
->cmd_len
= ses
->cmd_len
;
982 scmd
->cmnd
= ses
->cmnd
;
983 scmd
->sc_data_direction
= ses
->data_direction
;
984 scmd
->sdb
= ses
->sdb
;
985 scmd
->request
->next_rq
= ses
->next_rq
;
986 scmd
->result
= ses
->result
;
987 scmd
->underflow
= ses
->underflow
;
988 scmd
->prot_op
= ses
->prot_op
;
989 scmd
->eh_eflags
= ses
->eh_eflags
;
991 EXPORT_SYMBOL(scsi_eh_restore_cmnd
);
994 * scsi_send_eh_cmnd - submit a scsi command as part of error recovery
995 * @scmd: SCSI command structure to hijack
997 * @cmnd_size: size in bytes of @cmnd
998 * @timeout: timeout for this request
999 * @sense_bytes: size of sense data to copy or 0
1001 * This function is used to send a scsi command down to a target device
1002 * as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
1005 * SUCCESS or FAILED or NEEDS_RETRY
1007 static int scsi_send_eh_cmnd(struct scsi_cmnd
*scmd
, unsigned char *cmnd
,
1008 int cmnd_size
, int timeout
, unsigned sense_bytes
)
1010 struct scsi_device
*sdev
= scmd
->device
;
1011 struct Scsi_Host
*shost
= sdev
->host
;
1012 DECLARE_COMPLETION_ONSTACK(done
);
1013 unsigned long timeleft
= timeout
;
1014 struct scsi_eh_save ses
;
1015 const unsigned long stall_for
= msecs_to_jiffies(100);
1019 scsi_eh_prep_cmnd(scmd
, &ses
, cmnd
, cmnd_size
, sense_bytes
);
1020 shost
->eh_action
= &done
;
1022 scsi_log_send(scmd
);
1023 scmd
->scsi_done
= scsi_eh_done
;
1024 rtn
= shost
->hostt
->queuecommand(shost
, scmd
);
1026 if (timeleft
> stall_for
) {
1027 scsi_eh_restore_cmnd(scmd
, &ses
);
1028 timeleft
-= stall_for
;
1029 msleep(jiffies_to_msecs(stall_for
));
1032 /* signal not to enter either branch of the if () below */
1036 timeleft
= wait_for_completion_timeout(&done
, timeout
);
1040 shost
->eh_action
= NULL
;
1042 scsi_log_completion(scmd
, rtn
);
1044 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
1045 "%s timeleft: %ld\n",
1046 __func__
, timeleft
));
1049 * If there is time left scsi_eh_done got called, and we will examine
1050 * the actual status codes to see whether the command actually did
1051 * complete normally, else if we have a zero return and no time left,
1052 * the command must still be pending, so abort it and return FAILED.
1053 * If we never actually managed to issue the command, because
1054 * ->queuecommand() kept returning non zero, use the rtn = FAILED
1055 * value above (so don't execute either branch of the if)
1058 rtn
= scsi_eh_completed_normally(scmd
);
1059 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
1060 "%s: scsi_eh_completed_normally %x\n", __func__
, rtn
));
1067 case ADD_TO_MLQUEUE
:
1074 } else if (rtn
!= FAILED
) {
1075 scsi_abort_eh_cmnd(scmd
);
1079 scsi_eh_restore_cmnd(scmd
, &ses
);
1085 * scsi_request_sense - Request sense data from a particular target.
1086 * @scmd: SCSI cmd for request sense.
1089 * Some hosts automatically obtain this information, others require
1090 * that we obtain it on our own. This function will *not* return until
1091 * the command either times out, or it completes.
1093 static int scsi_request_sense(struct scsi_cmnd
*scmd
)
1095 return scsi_send_eh_cmnd(scmd
, NULL
, 0, scmd
->device
->eh_timeout
, ~0);
1098 static int scsi_eh_action(struct scsi_cmnd
*scmd
, int rtn
)
1100 if (!blk_rq_is_passthrough(scmd
->request
)) {
1101 struct scsi_driver
*sdrv
= scsi_cmd_to_driver(scmd
);
1102 if (sdrv
->eh_action
)
1103 rtn
= sdrv
->eh_action(scmd
, rtn
);
1109 * scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
1110 * @scmd: Original SCSI cmd that eh has finished.
1111 * @done_q: Queue for processed commands.
1114 * We don't want to use the normal command completion while we are are
1115 * still handling errors - it may cause other commands to be queued,
1116 * and that would disturb what we are doing. Thus we really want to
1117 * keep a list of pending commands for final completion, and once we
1118 * are ready to leave error handling we handle completion for real.
1120 void scsi_eh_finish_cmd(struct scsi_cmnd
*scmd
, struct list_head
*done_q
)
1122 list_move_tail(&scmd
->eh_entry
, done_q
);
1124 EXPORT_SYMBOL(scsi_eh_finish_cmd
);
1127 * scsi_eh_get_sense - Get device sense data.
1128 * @work_q: Queue of commands to process.
1129 * @done_q: Queue of processed commands.
1132 * See if we need to request sense information. if so, then get it
1133 * now, so we have a better idea of what to do.
1136 * This has the unfortunate side effect that if a shost adapter does
1137 * not automatically request sense information, we end up shutting
1138 * it down before we request it.
1140 * All drivers should request sense information internally these days,
1141 * so for now all I have to say is tough noogies if you end up in here.
1143 * XXX: Long term this code should go away, but that needs an audit of
1146 int scsi_eh_get_sense(struct list_head
*work_q
,
1147 struct list_head
*done_q
)
1149 struct scsi_cmnd
*scmd
, *next
;
1150 struct Scsi_Host
*shost
;
1154 * If SCSI_EH_ABORT_SCHEDULED has been set, it is timeout IO,
1155 * should not get sense.
1157 list_for_each_entry_safe(scmd
, next
, work_q
, eh_entry
) {
1158 if ((scmd
->eh_eflags
& SCSI_EH_ABORT_SCHEDULED
) ||
1159 SCSI_SENSE_VALID(scmd
))
1162 shost
= scmd
->device
->host
;
1163 if (scsi_host_eh_past_deadline(shost
)) {
1164 SCSI_LOG_ERROR_RECOVERY(3,
1165 scmd_printk(KERN_INFO
, scmd
,
1166 "%s: skip request sense, past eh deadline\n",
1170 if (status_byte(scmd
->result
) != CHECK_CONDITION
)
1172 * don't request sense if there's no check condition
1173 * status because the error we're processing isn't one
1174 * that has a sense code (and some devices get
1175 * confused by sense requests out of the blue)
1179 SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO
, scmd
,
1180 "%s: requesting sense\n",
1182 rtn
= scsi_request_sense(scmd
);
1186 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
1187 "sense requested, result %x\n", scmd
->result
));
1188 SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd
));
1190 rtn
= scsi_decide_disposition(scmd
);
1193 * if the result was normal, then just pass it along to the
1197 /* we don't want this command reissued, just
1198 * finished with the sense data, so set
1199 * retries to the max allowed to ensure it
1200 * won't get reissued */
1201 scmd
->retries
= scmd
->allowed
;
1202 else if (rtn
!= NEEDS_RETRY
)
1205 scsi_eh_finish_cmd(scmd
, done_q
);
1208 return list_empty(work_q
);
1210 EXPORT_SYMBOL_GPL(scsi_eh_get_sense
);
1213 * scsi_eh_tur - Send TUR to device.
1214 * @scmd: &scsi_cmnd to send TUR
1217 * 0 - Device is ready. 1 - Device NOT ready.
1219 static int scsi_eh_tur(struct scsi_cmnd
*scmd
)
1221 static unsigned char tur_command
[6] = {TEST_UNIT_READY
, 0, 0, 0, 0, 0};
1222 int retry_cnt
= 1, rtn
;
1225 rtn
= scsi_send_eh_cmnd(scmd
, tur_command
, 6,
1226 scmd
->device
->eh_timeout
, 0);
1228 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO
, scmd
,
1229 "%s return: %x\n", __func__
, rtn
));
1244 * scsi_eh_test_devices - check if devices are responding from error recovery.
1245 * @cmd_list: scsi commands in error recovery.
1246 * @work_q: queue for commands which still need more error recovery
1247 * @done_q: queue for commands which are finished
1248 * @try_stu: boolean on if a STU command should be tried in addition to TUR.
1251 * Tests if devices are in a working state. Commands to devices now in
1252 * a working state are sent to the done_q while commands to devices which
1253 * are still failing to respond are returned to the work_q for more
1256 static int scsi_eh_test_devices(struct list_head
*cmd_list
,
1257 struct list_head
*work_q
,
1258 struct list_head
*done_q
, int try_stu
)
1260 struct scsi_cmnd
*scmd
, *next
;
1261 struct scsi_device
*sdev
;
1264 while (!list_empty(cmd_list
)) {
1265 scmd
= list_entry(cmd_list
->next
, struct scsi_cmnd
, eh_entry
);
1266 sdev
= scmd
->device
;
1269 if (scsi_host_eh_past_deadline(sdev
->host
)) {
1270 /* Push items back onto work_q */
1271 list_splice_init(cmd_list
, work_q
);
1272 SCSI_LOG_ERROR_RECOVERY(3,
1273 sdev_printk(KERN_INFO
, sdev
,
1274 "%s: skip test device, past eh deadline",
1280 finish_cmds
= !scsi_device_online(scmd
->device
) ||
1281 (try_stu
&& !scsi_eh_try_stu(scmd
) &&
1282 !scsi_eh_tur(scmd
)) ||
1285 list_for_each_entry_safe(scmd
, next
, cmd_list
, eh_entry
)
1286 if (scmd
->device
== sdev
) {
1289 scsi_eh_action(scmd
, SUCCESS
) == SUCCESS
))
1290 scsi_eh_finish_cmd(scmd
, done_q
);
1292 list_move_tail(&scmd
->eh_entry
, work_q
);
1295 return list_empty(work_q
);
1299 * scsi_eh_try_stu - Send START_UNIT to device.
1300 * @scmd: &scsi_cmnd to send START_UNIT
1303 * 0 - Device is ready. 1 - Device NOT ready.
1305 static int scsi_eh_try_stu(struct scsi_cmnd
*scmd
)
1307 static unsigned char stu_command
[6] = {START_STOP
, 0, 0, 0, 1, 0};
1309 if (scmd
->device
->allow_restart
) {
1310 int i
, rtn
= NEEDS_RETRY
;
1312 for (i
= 0; rtn
== NEEDS_RETRY
&& i
< 2; i
++)
1313 rtn
= scsi_send_eh_cmnd(scmd
, stu_command
, 6, scmd
->device
->request_queue
->rq_timeout
, 0);
1323 * scsi_eh_stu - send START_UNIT if needed
1324 * @shost: &scsi host being recovered.
1325 * @work_q: &list_head for pending commands.
1326 * @done_q: &list_head for processed commands.
1329 * If commands are failing due to not ready, initializing command required,
1330 * try revalidating the device, which will end up sending a start unit.
1332 static int scsi_eh_stu(struct Scsi_Host
*shost
,
1333 struct list_head
*work_q
,
1334 struct list_head
*done_q
)
1336 struct scsi_cmnd
*scmd
, *stu_scmd
, *next
;
1337 struct scsi_device
*sdev
;
1339 shost_for_each_device(sdev
, shost
) {
1340 if (scsi_host_eh_past_deadline(shost
)) {
1341 SCSI_LOG_ERROR_RECOVERY(3,
1342 sdev_printk(KERN_INFO
, sdev
,
1343 "%s: skip START_UNIT, past eh deadline\n",
1348 list_for_each_entry(scmd
, work_q
, eh_entry
)
1349 if (scmd
->device
== sdev
&& SCSI_SENSE_VALID(scmd
) &&
1350 scsi_check_sense(scmd
) == FAILED
) {
1358 SCSI_LOG_ERROR_RECOVERY(3,
1359 sdev_printk(KERN_INFO
, sdev
,
1360 "%s: Sending START_UNIT\n",
1363 if (!scsi_eh_try_stu(stu_scmd
)) {
1364 if (!scsi_device_online(sdev
) ||
1365 !scsi_eh_tur(stu_scmd
)) {
1366 list_for_each_entry_safe(scmd
, next
,
1368 if (scmd
->device
== sdev
&&
1369 scsi_eh_action(scmd
, SUCCESS
) == SUCCESS
)
1370 scsi_eh_finish_cmd(scmd
, done_q
);
1374 SCSI_LOG_ERROR_RECOVERY(3,
1375 sdev_printk(KERN_INFO
, sdev
,
1376 "%s: START_UNIT failed\n",
1381 return list_empty(work_q
);
1386 * scsi_eh_bus_device_reset - send bdr if needed
1387 * @shost: scsi host being recovered.
1388 * @work_q: &list_head for pending commands.
1389 * @done_q: &list_head for processed commands.
1392 * Try a bus device reset. Still, look to see whether we have multiple
1393 * devices that are jammed or not - if we have multiple devices, it
1394 * makes no sense to try bus_device_reset - we really would need to try
1395 * a bus_reset instead.
1397 static int scsi_eh_bus_device_reset(struct Scsi_Host
*shost
,
1398 struct list_head
*work_q
,
1399 struct list_head
*done_q
)
1401 struct scsi_cmnd
*scmd
, *bdr_scmd
, *next
;
1402 struct scsi_device
*sdev
;
1405 shost_for_each_device(sdev
, shost
) {
1406 if (scsi_host_eh_past_deadline(shost
)) {
1407 SCSI_LOG_ERROR_RECOVERY(3,
1408 sdev_printk(KERN_INFO
, sdev
,
1409 "%s: skip BDR, past eh deadline\n",
1414 list_for_each_entry(scmd
, work_q
, eh_entry
)
1415 if (scmd
->device
== sdev
) {
1423 SCSI_LOG_ERROR_RECOVERY(3,
1424 sdev_printk(KERN_INFO
, sdev
,
1425 "%s: Sending BDR\n", current
->comm
));
1426 rtn
= scsi_try_bus_device_reset(bdr_scmd
);
1427 if (rtn
== SUCCESS
|| rtn
== FAST_IO_FAIL
) {
1428 if (!scsi_device_online(sdev
) ||
1429 rtn
== FAST_IO_FAIL
||
1430 !scsi_eh_tur(bdr_scmd
)) {
1431 list_for_each_entry_safe(scmd
, next
,
1433 if (scmd
->device
== sdev
&&
1434 scsi_eh_action(scmd
, rtn
) != FAILED
)
1435 scsi_eh_finish_cmd(scmd
,
1440 SCSI_LOG_ERROR_RECOVERY(3,
1441 sdev_printk(KERN_INFO
, sdev
,
1442 "%s: BDR failed\n", current
->comm
));
1446 return list_empty(work_q
);
1450 * scsi_eh_target_reset - send target reset if needed
1451 * @shost: scsi host being recovered.
1452 * @work_q: &list_head for pending commands.
1453 * @done_q: &list_head for processed commands.
1456 * Try a target reset.
1458 static int scsi_eh_target_reset(struct Scsi_Host
*shost
,
1459 struct list_head
*work_q
,
1460 struct list_head
*done_q
)
1462 LIST_HEAD(tmp_list
);
1463 LIST_HEAD(check_list
);
1465 list_splice_init(work_q
, &tmp_list
);
1467 while (!list_empty(&tmp_list
)) {
1468 struct scsi_cmnd
*next
, *scmd
;
1472 if (scsi_host_eh_past_deadline(shost
)) {
1473 /* push back on work queue for further processing */
1474 list_splice_init(&check_list
, work_q
);
1475 list_splice_init(&tmp_list
, work_q
);
1476 SCSI_LOG_ERROR_RECOVERY(3,
1477 shost_printk(KERN_INFO
, shost
,
1478 "%s: Skip target reset, past eh deadline\n",
1480 return list_empty(work_q
);
1483 scmd
= list_entry(tmp_list
.next
, struct scsi_cmnd
, eh_entry
);
1486 SCSI_LOG_ERROR_RECOVERY(3,
1487 shost_printk(KERN_INFO
, shost
,
1488 "%s: Sending target reset to target %d\n",
1489 current
->comm
, id
));
1490 rtn
= scsi_try_target_reset(scmd
);
1491 if (rtn
!= SUCCESS
&& rtn
!= FAST_IO_FAIL
)
1492 SCSI_LOG_ERROR_RECOVERY(3,
1493 shost_printk(KERN_INFO
, shost
,
1494 "%s: Target reset failed"
1496 current
->comm
, id
));
1497 list_for_each_entry_safe(scmd
, next
, &tmp_list
, eh_entry
) {
1498 if (scmd_id(scmd
) != id
)
1502 list_move_tail(&scmd
->eh_entry
, &check_list
);
1503 else if (rtn
== FAST_IO_FAIL
)
1504 scsi_eh_finish_cmd(scmd
, done_q
);
1506 /* push back on work queue for further processing */
1507 list_move(&scmd
->eh_entry
, work_q
);
1511 return scsi_eh_test_devices(&check_list
, work_q
, done_q
, 0);
1515 * scsi_eh_bus_reset - send a bus reset
1516 * @shost: &scsi host being recovered.
1517 * @work_q: &list_head for pending commands.
1518 * @done_q: &list_head for processed commands.
1520 static int scsi_eh_bus_reset(struct Scsi_Host
*shost
,
1521 struct list_head
*work_q
,
1522 struct list_head
*done_q
)
1524 struct scsi_cmnd
*scmd
, *chan_scmd
, *next
;
1525 LIST_HEAD(check_list
);
1526 unsigned int channel
;
1530 * we really want to loop over the various channels, and do this on
1531 * a channel by channel basis. we should also check to see if any
1532 * of the failed commands are on soft_reset devices, and if so, skip
1536 for (channel
= 0; channel
<= shost
->max_channel
; channel
++) {
1537 if (scsi_host_eh_past_deadline(shost
)) {
1538 list_splice_init(&check_list
, work_q
);
1539 SCSI_LOG_ERROR_RECOVERY(3,
1540 shost_printk(KERN_INFO
, shost
,
1541 "%s: skip BRST, past eh deadline\n",
1543 return list_empty(work_q
);
1547 list_for_each_entry(scmd
, work_q
, eh_entry
) {
1548 if (channel
== scmd_channel(scmd
)) {
1552 * FIXME add back in some support for
1553 * soft_reset devices.
1560 SCSI_LOG_ERROR_RECOVERY(3,
1561 shost_printk(KERN_INFO
, shost
,
1562 "%s: Sending BRST chan: %d\n",
1563 current
->comm
, channel
));
1564 rtn
= scsi_try_bus_reset(chan_scmd
);
1565 if (rtn
== SUCCESS
|| rtn
== FAST_IO_FAIL
) {
1566 list_for_each_entry_safe(scmd
, next
, work_q
, eh_entry
) {
1567 if (channel
== scmd_channel(scmd
)) {
1568 if (rtn
== FAST_IO_FAIL
)
1569 scsi_eh_finish_cmd(scmd
,
1572 list_move_tail(&scmd
->eh_entry
,
1577 SCSI_LOG_ERROR_RECOVERY(3,
1578 shost_printk(KERN_INFO
, shost
,
1579 "%s: BRST failed chan: %d\n",
1580 current
->comm
, channel
));
1583 return scsi_eh_test_devices(&check_list
, work_q
, done_q
, 0);
1587 * scsi_eh_host_reset - send a host reset
1588 * @shost: host to be reset.
1589 * @work_q: &list_head for pending commands.
1590 * @done_q: &list_head for processed commands.
1592 static int scsi_eh_host_reset(struct Scsi_Host
*shost
,
1593 struct list_head
*work_q
,
1594 struct list_head
*done_q
)
1596 struct scsi_cmnd
*scmd
, *next
;
1597 LIST_HEAD(check_list
);
1600 if (!list_empty(work_q
)) {
1601 scmd
= list_entry(work_q
->next
,
1602 struct scsi_cmnd
, eh_entry
);
1604 SCSI_LOG_ERROR_RECOVERY(3,
1605 shost_printk(KERN_INFO
, shost
,
1606 "%s: Sending HRST\n",
1609 rtn
= scsi_try_host_reset(scmd
);
1610 if (rtn
== SUCCESS
) {
1611 list_splice_init(work_q
, &check_list
);
1612 } else if (rtn
== FAST_IO_FAIL
) {
1613 list_for_each_entry_safe(scmd
, next
, work_q
, eh_entry
) {
1614 scsi_eh_finish_cmd(scmd
, done_q
);
1617 SCSI_LOG_ERROR_RECOVERY(3,
1618 shost_printk(KERN_INFO
, shost
,
1619 "%s: HRST failed\n",
1623 return scsi_eh_test_devices(&check_list
, work_q
, done_q
, 1);
1627 * scsi_eh_offline_sdevs - offline scsi devices that fail to recover
1628 * @work_q: &list_head for pending commands.
1629 * @done_q: &list_head for processed commands.
1631 static void scsi_eh_offline_sdevs(struct list_head
*work_q
,
1632 struct list_head
*done_q
)
1634 struct scsi_cmnd
*scmd
, *next
;
1635 struct scsi_device
*sdev
;
1637 list_for_each_entry_safe(scmd
, next
, work_q
, eh_entry
) {
1638 sdev_printk(KERN_INFO
, scmd
->device
, "Device offlined - "
1639 "not ready after error recovery\n");
1640 sdev
= scmd
->device
;
1642 mutex_lock(&sdev
->state_mutex
);
1643 scsi_device_set_state(sdev
, SDEV_OFFLINE
);
1644 mutex_unlock(&sdev
->state_mutex
);
1646 scsi_eh_finish_cmd(scmd
, done_q
);
1652 * scsi_noretry_cmd - determine if command should be failed fast
1653 * @scmd: SCSI cmd to examine.
1655 int scsi_noretry_cmd(struct scsi_cmnd
*scmd
)
1657 switch (host_byte(scmd
->result
)) {
1663 return (scmd
->request
->cmd_flags
& REQ_FAILFAST_TRANSPORT
);
1665 return (scmd
->request
->cmd_flags
& REQ_FAILFAST_DEV
);
1667 if (msg_byte(scmd
->result
) == COMMAND_COMPLETE
&&
1668 status_byte(scmd
->result
) == RESERVATION_CONFLICT
)
1671 case DID_SOFT_ERROR
:
1672 return (scmd
->request
->cmd_flags
& REQ_FAILFAST_DRIVER
);
1675 if (status_byte(scmd
->result
) != CHECK_CONDITION
)
1680 * assume caller has checked sense and determined
1681 * the check condition was retryable.
1683 if (scmd
->request
->cmd_flags
& REQ_FAILFAST_DEV
||
1684 blk_rq_is_passthrough(scmd
->request
))
1691 * scsi_decide_disposition - Disposition a cmd on return from LLD.
1692 * @scmd: SCSI cmd to examine.
1695 * This is *only* called when we are examining the status after sending
1696 * out the actual data command. any commands that are queued for error
1697 * recovery (e.g. test_unit_ready) do *not* come through here.
1699 * When this routine returns failed, it means the error handler thread
1700 * is woken. In cases where the error code indicates an error that
1701 * doesn't require the error handler read (i.e. we don't need to
1702 * abort/reset), this function should return SUCCESS.
1704 int scsi_decide_disposition(struct scsi_cmnd
*scmd
)
1709 * if the device is offline, then we clearly just pass the result back
1710 * up to the top level.
1712 if (!scsi_device_online(scmd
->device
)) {
1713 SCSI_LOG_ERROR_RECOVERY(5, scmd_printk(KERN_INFO
, scmd
,
1714 "%s: device offline - report as SUCCESS\n", __func__
));
1719 * first check the host byte, to see if there is anything in there
1720 * that would indicate what we need to do.
1722 switch (host_byte(scmd
->result
)) {
1723 case DID_PASSTHROUGH
:
1725 * no matter what, pass this through to the upper layer.
1726 * nuke this special code so that it looks like we are saying
1729 scmd
->result
&= 0xff00ffff;
1733 * looks good. drop through, and check the next byte.
1737 if (scmd
->eh_eflags
& SCSI_EH_ABORT_SCHEDULED
) {
1738 set_host_byte(scmd
, DID_TIME_OUT
);
1742 case DID_NO_CONNECT
:
1743 case DID_BAD_TARGET
:
1745 * note - this means that we just report the status back
1746 * to the top level driver, not that we actually think
1747 * that it indicates SUCCESS.
1751 * when the low level driver returns did_soft_error,
1752 * it is responsible for keeping an internal retry counter
1753 * in order to avoid endless loops (db)
1755 * actually this is a bug in this function here. we should
1756 * be mindful of the maximum number of retries specified
1757 * and not get stuck in a loop.
1759 case DID_SOFT_ERROR
:
1765 return ADD_TO_MLQUEUE
;
1766 case DID_TRANSPORT_DISRUPTED
:
1768 * LLD/transport was disrupted during processing of the IO.
1769 * The transport class is now blocked/blocking,
1770 * and the transport will decide what to do with the IO
1771 * based on its timers and recovery capablilities if
1772 * there are enough retries.
1775 case DID_TRANSPORT_FAILFAST
:
1777 * The transport decided to failfast the IO (most likely
1778 * the fast io fail tmo fired), so send IO directly upwards.
1782 if (msg_byte(scmd
->result
) == COMMAND_COMPLETE
&&
1783 status_byte(scmd
->result
) == RESERVATION_CONFLICT
)
1785 * execute reservation conflict processing code
1795 * when we scan the bus, we get timeout messages for
1796 * these commands if there is no device available.
1797 * other hosts report did_no_connect for the same thing.
1799 if ((scmd
->cmnd
[0] == TEST_UNIT_READY
||
1800 scmd
->cmnd
[0] == INQUIRY
)) {
1812 * next, check the message byte.
1814 if (msg_byte(scmd
->result
) != COMMAND_COMPLETE
)
1818 * check the status byte to see if this indicates anything special.
1820 switch (status_byte(scmd
->result
)) {
1822 scsi_handle_queue_full(scmd
->device
);
1824 * the case of trying to send too many commands to a
1825 * tagged queueing device.
1830 * device can't talk to us at the moment. Should only
1831 * occur (SAM-3) when the task queue is empty, so will cause
1832 * the empty queue handling to trigger a stall in the
1835 return ADD_TO_MLQUEUE
;
1837 if (scmd
->cmnd
[0] == REPORT_LUNS
)
1838 scmd
->device
->sdev_target
->expecting_lun_change
= 0;
1839 scsi_handle_queue_ramp_up(scmd
->device
);
1841 case COMMAND_TERMINATED
:
1845 case CHECK_CONDITION
:
1846 rtn
= scsi_check_sense(scmd
);
1847 if (rtn
== NEEDS_RETRY
)
1849 /* if rtn == FAILED, we have no sense information;
1850 * returning FAILED will wake the error handler thread
1851 * to collect the sense and redo the decide
1854 case CONDITION_GOOD
:
1855 case INTERMEDIATE_GOOD
:
1856 case INTERMEDIATE_C_GOOD
:
1859 * who knows? FIXME(eric)
1863 case RESERVATION_CONFLICT
:
1864 sdev_printk(KERN_INFO
, scmd
->device
,
1865 "reservation conflict\n");
1866 set_host_byte(scmd
, DID_NEXUS_FAILURE
);
1867 return SUCCESS
; /* causes immediate i/o error */
1875 /* we requeue for retry because the error was retryable, and
1876 * the request was not marked fast fail. Note that above,
1877 * even if the request is marked fast fail, we still requeue
1878 * for queue congestion conditions (QUEUE_FULL or BUSY) */
1879 if ((++scmd
->retries
) <= scmd
->allowed
1880 && !scsi_noretry_cmd(scmd
)) {
1884 * no more retries - report this one back to upper level.
1890 static void eh_lock_door_done(struct request
*req
, blk_status_t status
)
1892 __blk_put_request(req
->q
, req
);
1896 * scsi_eh_lock_door - Prevent medium removal for the specified device
1897 * @sdev: SCSI device to prevent medium removal
1900 * We must be called from process context.
1903 * We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the
1904 * head of the devices request queue, and continue.
1906 static void scsi_eh_lock_door(struct scsi_device
*sdev
)
1908 struct request
*req
;
1909 struct scsi_request
*rq
;
1912 * blk_get_request with GFP_KERNEL (__GFP_RECLAIM) sleeps until a
1913 * request becomes available
1915 req
= blk_get_request(sdev
->request_queue
, REQ_OP_SCSI_IN
, GFP_KERNEL
);
1920 rq
->cmd
[0] = ALLOW_MEDIUM_REMOVAL
;
1924 rq
->cmd
[4] = SCSI_REMOVAL_PREVENT
;
1926 rq
->cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
1928 req
->rq_flags
|= RQF_QUIET
;
1929 req
->timeout
= 10 * HZ
;
1932 blk_execute_rq_nowait(req
->q
, NULL
, req
, 1, eh_lock_door_done
);
1936 * scsi_restart_operations - restart io operations to the specified host.
1937 * @shost: Host we are restarting.
1940 * When we entered the error handler, we blocked all further i/o to
1941 * this device. we need to 'reverse' this process.
1943 static void scsi_restart_operations(struct Scsi_Host
*shost
)
1945 struct scsi_device
*sdev
;
1946 unsigned long flags
;
1949 * If the door was locked, we need to insert a door lock request
1950 * onto the head of the SCSI request queue for the device. There
1951 * is no point trying to lock the door of an off-line device.
1953 shost_for_each_device(sdev
, shost
) {
1954 if (scsi_device_online(sdev
) && sdev
->was_reset
&& sdev
->locked
) {
1955 scsi_eh_lock_door(sdev
);
1956 sdev
->was_reset
= 0;
1961 * next free up anything directly waiting upon the host. this
1962 * will be requests for character device operations, and also for
1963 * ioctls to queued block devices.
1965 SCSI_LOG_ERROR_RECOVERY(3,
1966 shost_printk(KERN_INFO
, shost
, "waking up host to restart\n"));
1968 spin_lock_irqsave(shost
->host_lock
, flags
);
1969 if (scsi_host_set_state(shost
, SHOST_RUNNING
))
1970 if (scsi_host_set_state(shost
, SHOST_CANCEL
))
1971 BUG_ON(scsi_host_set_state(shost
, SHOST_DEL
));
1972 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1974 wake_up(&shost
->host_wait
);
1977 * finally we need to re-initiate requests that may be pending. we will
1978 * have had everything blocked while error handling is taking place, and
1979 * now that error recovery is done, we will need to ensure that these
1980 * requests are started.
1982 scsi_run_host_queues(shost
);
1985 * if eh is active and host_eh_scheduled is pending we need to re-run
1986 * recovery. we do this check after scsi_run_host_queues() to allow
1987 * everything pent up since the last eh run a chance to make forward
1988 * progress before we sync again. Either we'll immediately re-run
1989 * recovery or scsi_device_unbusy() will wake us again when these
1990 * pending commands complete.
1992 spin_lock_irqsave(shost
->host_lock
, flags
);
1993 if (shost
->host_eh_scheduled
)
1994 if (scsi_host_set_state(shost
, SHOST_RECOVERY
))
1995 WARN_ON(scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
));
1996 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2000 * scsi_eh_ready_devs - check device ready state and recover if not.
2001 * @shost: host to be recovered.
2002 * @work_q: &list_head for pending commands.
2003 * @done_q: &list_head for processed commands.
2005 void scsi_eh_ready_devs(struct Scsi_Host
*shost
,
2006 struct list_head
*work_q
,
2007 struct list_head
*done_q
)
2009 if (!scsi_eh_stu(shost
, work_q
, done_q
))
2010 if (!scsi_eh_bus_device_reset(shost
, work_q
, done_q
))
2011 if (!scsi_eh_target_reset(shost
, work_q
, done_q
))
2012 if (!scsi_eh_bus_reset(shost
, work_q
, done_q
))
2013 if (!scsi_eh_host_reset(shost
, work_q
, done_q
))
2014 scsi_eh_offline_sdevs(work_q
,
2017 EXPORT_SYMBOL_GPL(scsi_eh_ready_devs
);
2020 * scsi_eh_flush_done_q - finish processed commands or retry them.
2021 * @done_q: list_head of processed commands.
2023 void scsi_eh_flush_done_q(struct list_head
*done_q
)
2025 struct scsi_cmnd
*scmd
, *next
;
2027 list_for_each_entry_safe(scmd
, next
, done_q
, eh_entry
) {
2028 list_del_init(&scmd
->eh_entry
);
2029 if (scsi_device_online(scmd
->device
) &&
2030 !scsi_noretry_cmd(scmd
) &&
2031 (++scmd
->retries
<= scmd
->allowed
)) {
2032 SCSI_LOG_ERROR_RECOVERY(3,
2033 scmd_printk(KERN_INFO
, scmd
,
2034 "%s: flush retry cmd\n",
2036 scsi_queue_insert(scmd
, SCSI_MLQUEUE_EH_RETRY
);
2039 * If just we got sense for the device (called
2040 * scsi_eh_get_sense), scmd->result is already
2041 * set, do not set DRIVER_TIMEOUT.
2044 scmd
->result
|= (DRIVER_TIMEOUT
<< 24);
2045 SCSI_LOG_ERROR_RECOVERY(3,
2046 scmd_printk(KERN_INFO
, scmd
,
2047 "%s: flush finish cmd\n",
2049 scsi_finish_command(scmd
);
2053 EXPORT_SYMBOL(scsi_eh_flush_done_q
);
2056 * scsi_unjam_host - Attempt to fix a host which has a cmd that failed.
2057 * @shost: Host to unjam.
2060 * When we come in here, we *know* that all commands on the bus have
2061 * either completed, failed or timed out. we also know that no further
2062 * commands are being sent to the host, so things are relatively quiet
2063 * and we have freedom to fiddle with things as we wish.
2065 * This is only the *default* implementation. it is possible for
2066 * individual drivers to supply their own version of this function, and
2067 * if the maintainer wishes to do this, it is strongly suggested that
2068 * this function be taken as a template and modified. this function
2069 * was designed to correctly handle problems for about 95% of the
2070 * different cases out there, and it should always provide at least a
2071 * reasonable amount of error recovery.
2073 * Any command marked 'failed' or 'timeout' must eventually have
2074 * scsi_finish_cmd() called for it. we do all of the retry stuff
2075 * here, so when we restart the host after we return it should have an
2078 static void scsi_unjam_host(struct Scsi_Host
*shost
)
2080 unsigned long flags
;
2081 LIST_HEAD(eh_work_q
);
2082 LIST_HEAD(eh_done_q
);
2084 spin_lock_irqsave(shost
->host_lock
, flags
);
2085 list_splice_init(&shost
->eh_cmd_q
, &eh_work_q
);
2086 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2088 SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost
, &eh_work_q
));
2090 if (!scsi_eh_get_sense(&eh_work_q
, &eh_done_q
))
2091 scsi_eh_ready_devs(shost
, &eh_work_q
, &eh_done_q
);
2093 spin_lock_irqsave(shost
->host_lock
, flags
);
2094 if (shost
->eh_deadline
!= -1)
2095 shost
->last_reset
= 0;
2096 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2097 scsi_eh_flush_done_q(&eh_done_q
);
2101 * scsi_error_handler - SCSI error handler thread
2102 * @data: Host for which we are running.
2105 * This is the main error handling loop. This is run as a kernel thread
2106 * for every SCSI host and handles all error handling activity.
2108 int scsi_error_handler(void *data
)
2110 struct Scsi_Host
*shost
= data
;
2113 * We use TASK_INTERRUPTIBLE so that the thread is not
2114 * counted against the load average as a running process.
2115 * We never actually get interrupted because kthread_run
2116 * disables signal delivery for the created thread.
2120 * The sequence in kthread_stop() sets the stop flag first
2121 * then wakes the process. To avoid missed wakeups, the task
2122 * should always be in a non running state before the stop
2125 set_current_state(TASK_INTERRUPTIBLE
);
2126 if (kthread_should_stop())
2129 if ((shost
->host_failed
== 0 && shost
->host_eh_scheduled
== 0) ||
2130 shost
->host_failed
!= atomic_read(&shost
->host_busy
)) {
2131 SCSI_LOG_ERROR_RECOVERY(1,
2132 shost_printk(KERN_INFO
, shost
,
2133 "scsi_eh_%d: sleeping\n",
2139 __set_current_state(TASK_RUNNING
);
2140 SCSI_LOG_ERROR_RECOVERY(1,
2141 shost_printk(KERN_INFO
, shost
,
2142 "scsi_eh_%d: waking up %d/%d/%d\n",
2143 shost
->host_no
, shost
->host_eh_scheduled
,
2145 atomic_read(&shost
->host_busy
)));
2148 * We have a host that is failing for some reason. Figure out
2149 * what we need to do to get it up and online again (if we can).
2150 * If we fail, we end up taking the thing offline.
2152 if (!shost
->eh_noresume
&& scsi_autopm_get_host(shost
) != 0) {
2153 SCSI_LOG_ERROR_RECOVERY(1,
2154 shost_printk(KERN_ERR
, shost
,
2155 "scsi_eh_%d: unable to autoresume\n",
2160 if (shost
->transportt
->eh_strategy_handler
)
2161 shost
->transportt
->eh_strategy_handler(shost
);
2163 scsi_unjam_host(shost
);
2165 /* All scmds have been handled */
2166 shost
->host_failed
= 0;
2169 * Note - if the above fails completely, the action is to take
2170 * individual devices offline and flush the queue of any
2171 * outstanding requests that may have been pending. When we
2172 * restart, we restart any I/O to any other devices on the bus
2173 * which are still online.
2175 scsi_restart_operations(shost
);
2176 if (!shost
->eh_noresume
)
2177 scsi_autopm_put_host(shost
);
2179 __set_current_state(TASK_RUNNING
);
2181 SCSI_LOG_ERROR_RECOVERY(1,
2182 shost_printk(KERN_INFO
, shost
,
2183 "Error handler scsi_eh_%d exiting\n",
2185 shost
->ehandler
= NULL
;
2190 * Function: scsi_report_bus_reset()
2192 * Purpose: Utility function used by low-level drivers to report that
2193 * they have observed a bus reset on the bus being handled.
2195 * Arguments: shost - Host in question
2196 * channel - channel on which reset was observed.
2200 * Lock status: Host lock must be held.
2202 * Notes: This only needs to be called if the reset is one which
2203 * originates from an unknown location. Resets originated
2204 * by the mid-level itself don't need to call this, but there
2205 * should be no harm.
2207 * The main purpose of this is to make sure that a CHECK_CONDITION
2208 * is properly treated.
2210 void scsi_report_bus_reset(struct Scsi_Host
*shost
, int channel
)
2212 struct scsi_device
*sdev
;
2214 __shost_for_each_device(sdev
, shost
) {
2215 if (channel
== sdev_channel(sdev
))
2216 __scsi_report_device_reset(sdev
, NULL
);
2219 EXPORT_SYMBOL(scsi_report_bus_reset
);
2222 * Function: scsi_report_device_reset()
2224 * Purpose: Utility function used by low-level drivers to report that
2225 * they have observed a device reset on the device being handled.
2227 * Arguments: shost - Host in question
2228 * channel - channel on which reset was observed
2229 * target - target on which reset was observed
2233 * Lock status: Host lock must be held
2235 * Notes: This only needs to be called if the reset is one which
2236 * originates from an unknown location. Resets originated
2237 * by the mid-level itself don't need to call this, but there
2238 * should be no harm.
2240 * The main purpose of this is to make sure that a CHECK_CONDITION
2241 * is properly treated.
2243 void scsi_report_device_reset(struct Scsi_Host
*shost
, int channel
, int target
)
2245 struct scsi_device
*sdev
;
2247 __shost_for_each_device(sdev
, shost
) {
2248 if (channel
== sdev_channel(sdev
) &&
2249 target
== sdev_id(sdev
))
2250 __scsi_report_device_reset(sdev
, NULL
);
2253 EXPORT_SYMBOL(scsi_report_device_reset
);
2256 scsi_reset_provider_done_command(struct scsi_cmnd
*scmd
)
2261 * scsi_ioctl_reset: explicitly reset a host/bus/target/device
2262 * @dev: scsi_device to operate on
2263 * @arg: reset type (see sg.h)
2266 scsi_ioctl_reset(struct scsi_device
*dev
, int __user
*arg
)
2268 struct scsi_cmnd
*scmd
;
2269 struct Scsi_Host
*shost
= dev
->host
;
2271 unsigned long flags
;
2272 int error
= 0, rtn
, val
;
2274 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
2277 error
= get_user(val
, arg
);
2281 if (scsi_autopm_get_host(shost
) < 0)
2285 rq
= kzalloc(sizeof(struct request
) + sizeof(struct scsi_cmnd
) +
2286 shost
->hostt
->cmd_size
, GFP_KERNEL
);
2288 goto out_put_autopm_host
;
2289 blk_rq_init(NULL
, rq
);
2291 scmd
= (struct scsi_cmnd
*)(rq
+ 1);
2292 scsi_init_command(dev
, scmd
);
2294 scmd
->cmnd
= scsi_req(rq
)->cmd
;
2296 scmd
->scsi_done
= scsi_reset_provider_done_command
;
2297 memset(&scmd
->sdb
, 0, sizeof(scmd
->sdb
));
2301 scmd
->sc_data_direction
= DMA_BIDIRECTIONAL
;
2303 spin_lock_irqsave(shost
->host_lock
, flags
);
2304 shost
->tmf_in_progress
= 1;
2305 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2307 switch (val
& ~SG_SCSI_RESET_NO_ESCALATE
) {
2308 case SG_SCSI_RESET_NOTHING
:
2311 case SG_SCSI_RESET_DEVICE
:
2312 rtn
= scsi_try_bus_device_reset(scmd
);
2313 if (rtn
== SUCCESS
|| (val
& SG_SCSI_RESET_NO_ESCALATE
))
2316 case SG_SCSI_RESET_TARGET
:
2317 rtn
= scsi_try_target_reset(scmd
);
2318 if (rtn
== SUCCESS
|| (val
& SG_SCSI_RESET_NO_ESCALATE
))
2321 case SG_SCSI_RESET_BUS
:
2322 rtn
= scsi_try_bus_reset(scmd
);
2323 if (rtn
== SUCCESS
|| (val
& SG_SCSI_RESET_NO_ESCALATE
))
2326 case SG_SCSI_RESET_HOST
:
2327 rtn
= scsi_try_host_reset(scmd
);
2336 error
= (rtn
== SUCCESS
) ? 0 : -EIO
;
2338 spin_lock_irqsave(shost
->host_lock
, flags
);
2339 shost
->tmf_in_progress
= 0;
2340 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2343 * be sure to wake up anyone who was sleeping or had their queue
2344 * suspended while we performed the TMF.
2346 SCSI_LOG_ERROR_RECOVERY(3,
2347 shost_printk(KERN_INFO
, shost
,
2348 "waking up host to restart after TMF\n"));
2350 wake_up(&shost
->host_wait
);
2351 scsi_run_host_queues(shost
);
2353 scsi_put_command(scmd
);
2356 out_put_autopm_host
:
2357 scsi_autopm_put_host(shost
);
2360 EXPORT_SYMBOL(scsi_ioctl_reset
);
2362 bool scsi_command_normalize_sense(const struct scsi_cmnd
*cmd
,
2363 struct scsi_sense_hdr
*sshdr
)
2365 return scsi_normalize_sense(cmd
->sense_buffer
,
2366 SCSI_SENSE_BUFFERSIZE
, sshdr
);
2368 EXPORT_SYMBOL(scsi_command_normalize_sense
);
2371 * scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format)
2372 * @sense_buffer: byte array of sense data
2373 * @sb_len: number of valid bytes in sense_buffer
2374 * @info_out: pointer to 64 integer where 8 or 4 byte information
2375 * field will be placed if found.
2378 * true if information field found, false if not found.
2380 bool scsi_get_sense_info_fld(const u8
*sense_buffer
, int sb_len
,
2387 switch (sense_buffer
[0] & 0x7f) {
2390 if (sense_buffer
[0] & 0x80) {
2391 *info_out
= get_unaligned_be32(&sense_buffer
[3]);
2397 ucp
= scsi_sense_desc_find(sense_buffer
, sb_len
,
2399 if (ucp
&& (0xa == ucp
[1])) {
2400 *info_out
= get_unaligned_be64(&ucp
[4]);
2408 EXPORT_SYMBOL(scsi_get_sense_info_fld
);