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