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