scsi_error.c 68.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 *  scsi_error.c Copyright (C) 1997 Eric Youngdale
 *
 *  SCSI error/timeout handling
 *      Initial versions: Eric Youngdale.  Based upon conversations with
6
 *                        Leonard Zubkoff and David Miller at Linux Expo,
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9 10 11 12
 *                        ideas originating from all over the place.
 *
 *	Restructured scsi_unjam_host and associated functions.
 *	September 04, 2002 Mike Anderson (andmike@us.ibm.com)
 *
 *	Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
13
 *	minor cleanups.
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16 17 18
 *	September 30, 2002 Mike Anderson (andmike@us.ibm.com)
 */

#include <linux/module.h>
#include <linux/sched.h>
19
#include <linux/gfp.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/kernel.h>
23
#include <linux/freezer.h>
24
#include <linux/kthread.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
28
#include <linux/jiffies.h>
Linus Torvalds's avatar
Linus Torvalds committed
29 30

#include <scsi/scsi.h>
31
#include <scsi/scsi_cmnd.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_device.h>
34
#include <scsi/scsi_driver.h>
Linus Torvalds's avatar
Linus Torvalds committed
35
#include <scsi/scsi_eh.h>
36
#include <scsi/scsi_common.h>
37
#include <scsi/scsi_transport.h>
Linus Torvalds's avatar
Linus Torvalds committed
38 39
#include <scsi/scsi_host.h>
#include <scsi/scsi_ioctl.h>
40
#include <scsi/scsi_dh.h>
41
#include <scsi/sg.h>
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44

#include "scsi_priv.h"
#include "scsi_logging.h"
45
#include "scsi_transport_api.h"
Linus Torvalds's avatar
Linus Torvalds committed
46

47 48
#include <trace/events/scsi.h>

49 50
static void scsi_eh_done(struct scsi_cmnd *scmd);

Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55 56 57
/*
 * These should *probably* be handled by the host itself.
 * Since it is allowed to sleep, it probably should.
 */
#define BUS_RESET_SETTLE_TIME   (10)
#define HOST_RESET_SETTLE_TIME  (10)

58
static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
59 60
static int scsi_try_to_abort_cmd(struct scsi_host_template *,
				 struct scsi_cmnd *);
61

Linus Torvalds's avatar
Linus Torvalds committed
62 63 64
/* called with shost->host_lock held */
void scsi_eh_wakeup(struct Scsi_Host *shost)
{
65
	if (atomic_read(&shost->host_busy) == shost->host_failed) {
66
		trace_scsi_eh_wakeup(shost);
67
		wake_up_process(shost->ehandler);
68 69
		SCSI_LOG_ERROR_RECOVERY(5, shost_printk(KERN_INFO, shost,
			"Waking error handler thread\n"));
Linus Torvalds's avatar
Linus Torvalds committed
70 71
	}
}
72 73 74 75 76 77

/**
 * scsi_schedule_eh - schedule EH for SCSI host
 * @shost:	SCSI host to invoke error handling on.
 *
 * Schedule SCSI EH without scmd.
78
 */
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
void scsi_schedule_eh(struct Scsi_Host *shost)
{
	unsigned long flags;

	spin_lock_irqsave(shost->host_lock, flags);

	if (scsi_host_set_state(shost, SHOST_RECOVERY) == 0 ||
	    scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY) == 0) {
		shost->host_eh_scheduled++;
		scsi_eh_wakeup(shost);
	}

	spin_unlock_irqrestore(shost->host_lock, flags);
}
EXPORT_SYMBOL_GPL(scsi_schedule_eh);
Linus Torvalds's avatar
Linus Torvalds committed
94

95 96
static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
{
97
	if (!shost->last_reset || shost->eh_deadline == -1)
98 99
		return 0;

100 101 102 103
	/*
	 * 32bit accesses are guaranteed to be atomic
	 * (on all supported architectures), so instead
	 * of using a spinlock we can as well double check
104
	 * if eh_deadline has been set to 'off' during the
105 106 107
	 * time_before call.
	 */
	if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
108
	    shost->eh_deadline > -1)
109 110 111 112 113
		return 0;

	return 1;
}

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
/**
 * scmd_eh_abort_handler - Handle command aborts
 * @work:	command to be aborted.
 */
void
scmd_eh_abort_handler(struct work_struct *work)
{
	struct scsi_cmnd *scmd =
		container_of(work, struct scsi_cmnd, abort_work.work);
	struct scsi_device *sdev = scmd->device;
	int rtn;

	if (scsi_host_eh_past_deadline(sdev->host)) {
		SCSI_LOG_ERROR_RECOVERY(3,
			scmd_printk(KERN_INFO, scmd,
129
				    "eh timeout, not aborting\n"));
130 131 132
	} else {
		SCSI_LOG_ERROR_RECOVERY(3,
			scmd_printk(KERN_INFO, scmd,
133
				    "aborting command\n"));
134 135
		rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
		if (rtn == SUCCESS) {
136
			set_host_byte(scmd, DID_TIME_OUT);
137 138 139
			if (scsi_host_eh_past_deadline(sdev->host)) {
				SCSI_LOG_ERROR_RECOVERY(3,
					scmd_printk(KERN_INFO, scmd,
140 141
						    "eh timeout, not retrying "
						    "aborted command\n"));
142
			} else if (!scsi_noretry_cmd(scmd) &&
143 144 145
			    (++scmd->retries <= scmd->allowed)) {
				SCSI_LOG_ERROR_RECOVERY(3,
					scmd_printk(KERN_WARNING, scmd,
146
						    "retry aborted command\n"));
147
				scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
148
				return;
149 150 151
			} else {
				SCSI_LOG_ERROR_RECOVERY(3,
					scmd_printk(KERN_WARNING, scmd,
152
						    "finish aborted command\n"));
153
				scsi_finish_command(scmd);
154
				return;
155
			}
156 157 158
		} else {
			SCSI_LOG_ERROR_RECOVERY(3,
				scmd_printk(KERN_INFO, scmd,
159
					    "cmd abort %s\n",
160 161
					    (rtn == FAST_IO_FAIL) ?
					    "not send" : "failed"));
162 163 164 165 166 167
		}
	}

	if (!scsi_eh_scmd_add(scmd, 0)) {
		SCSI_LOG_ERROR_RECOVERY(3,
			scmd_printk(KERN_WARNING, scmd,
168
				    "terminate aborted command\n"));
169
		set_host_byte(scmd, DID_TIME_OUT);
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
		scsi_finish_command(scmd);
	}
}

/**
 * scsi_abort_command - schedule a command abort
 * @scmd:	scmd to abort.
 *
 * We only need to abort commands after a command timeout
 */
static int
scsi_abort_command(struct scsi_cmnd *scmd)
{
	struct scsi_device *sdev = scmd->device;
	struct Scsi_Host *shost = sdev->host;
	unsigned long flags;

	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
		/*
		 * Retry after abort failed, escalate to next level.
		 */
191
		scmd->eh_eflags &= ~SCSI_EH_ABORT_SCHEDULED;
192 193
		SCSI_LOG_ERROR_RECOVERY(3,
			scmd_printk(KERN_INFO, scmd,
194
				    "previous abort failed\n"));
195
		BUG_ON(delayed_work_pending(&scmd->abort_work));
196 197 198 199 200 201 202 203 204 205 206 207
		return FAILED;
	}

	/*
	 * Do not try a command abort if
	 * SCSI EH has already started.
	 */
	spin_lock_irqsave(shost->host_lock, flags);
	if (scsi_host_in_recovery(shost)) {
		spin_unlock_irqrestore(shost->host_lock, flags);
		SCSI_LOG_ERROR_RECOVERY(3,
			scmd_printk(KERN_INFO, scmd,
208
				    "not aborting, host in recovery\n"));
209 210 211
		return FAILED;
	}

212
	if (shost->eh_deadline != -1 && !shost->last_reset)
213 214 215 216 217
		shost->last_reset = jiffies;
	spin_unlock_irqrestore(shost->host_lock, flags);

	scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
	SCSI_LOG_ERROR_RECOVERY(3,
218
		scmd_printk(KERN_INFO, scmd, "abort scheduled\n"));
219 220 221 222
	queue_delayed_work(shost->tmf_work_q, &scmd->abort_work, HZ / 100);
	return SUCCESS;
}

Linus Torvalds's avatar
Linus Torvalds committed
223 224 225 226 227 228 229
/**
 * scsi_eh_scmd_add - add scsi cmd to error handling.
 * @scmd:	scmd to run eh on.
 * @eh_flag:	optional SCSI_EH flag.
 *
 * Return value:
 *	0 on failure.
230
 */
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234
int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
{
	struct Scsi_Host *shost = scmd->device->host;
	unsigned long flags;
235
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
236

237
	if (!shost->ehandler)
Linus Torvalds's avatar
Linus Torvalds committed
238 239 240
		return 0;

	spin_lock_irqsave(shost->host_lock, flags);
241 242 243
	if (scsi_host_set_state(shost, SHOST_RECOVERY))
		if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY))
			goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
244

245
	if (shost->eh_deadline != -1 && !shost->last_reset)
246 247
		shost->last_reset = jiffies;

248
	ret = 1;
249 250
	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
		eh_flag &= ~SCSI_EH_CANCEL_CMD;
251
	scmd->eh_eflags |= eh_flag;
Linus Torvalds's avatar
Linus Torvalds committed
252 253 254
	list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
	shost->host_failed++;
	scsi_eh_wakeup(shost);
255
 out_unlock:
Linus Torvalds's avatar
Linus Torvalds committed
256
	spin_unlock_irqrestore(shost->host_lock, flags);
257
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260 261
}

/**
 * scsi_times_out - Timeout function for normal scsi commands.
262
 * @req:	request that is timing out.
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265 266 267 268
 *
 * Notes:
 *     We do not need to lock this.  There is the potential for a race
 *     only in that the normal completion handling might run, but if the
 *     normal completion function determines that the timer has already
 *     fired, then it mustn't do anything.
269
 */
270
enum blk_eh_timer_return scsi_times_out(struct request *req)
Linus Torvalds's avatar
Linus Torvalds committed
271
{
272 273
	struct scsi_cmnd *scmd = req->special;
	enum blk_eh_timer_return rtn = BLK_EH_NOT_HANDLED;
274
	struct Scsi_Host *host = scmd->device->host;
275

276
	trace_scsi_dispatch_cmd_timeout(scmd);
Linus Torvalds's avatar
Linus Torvalds committed
277 278
	scsi_log_completion(scmd, TIMEOUT_ERROR);

279
	if (host->eh_deadline != -1 && !host->last_reset)
280 281
		host->last_reset = jiffies;

282
	if (host->hostt->eh_timed_out)
283
		rtn = host->hostt->eh_timed_out(scmd);
Linus Torvalds's avatar
Linus Torvalds committed
284

285 286 287
	if (rtn == BLK_EH_NOT_HANDLED) {
		if (!host->hostt->no_async_abort &&
		    scsi_abort_command(scmd) == SUCCESS)
288 289
			return BLK_EH_NOT_HANDLED;

290 291 292 293
		set_host_byte(scmd, DID_TIME_OUT);
		if (!scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD))
			rtn = BLK_EH_HANDLED;
	}
294

295
	return rtn;
Linus Torvalds's avatar
Linus Torvalds committed
296 297 298 299 300 301 302 303 304 305 306 307
}

/**
 * scsi_block_when_processing_errors - Prevent cmds from being queued.
 * @sdev:	Device on which we are performing recovery.
 *
 * Description:
 *     We block until the host is out of error recovery, and then check to
 *     see whether the host or the device is offline.
 *
 * Return value:
 *     0 when dev was taken offline by error recovery. 1 OK to proceed.
308
 */
Linus Torvalds's avatar
Linus Torvalds committed
309 310 311 312
int scsi_block_when_processing_errors(struct scsi_device *sdev)
{
	int online;

313
	wait_event(sdev->host->host_wait, !scsi_host_in_recovery(sdev->host));
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316

	online = scsi_device_online(sdev);

317 318
	SCSI_LOG_ERROR_RECOVERY(5, sdev_printk(KERN_INFO, sdev,
		"%s: rtn: %d\n", __func__, online));
Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322 323 324 325 326 327 328

	return online;
}
EXPORT_SYMBOL(scsi_block_when_processing_errors);

#ifdef CONFIG_SCSI_LOGGING
/**
 * scsi_eh_prt_fail_stats - Log info on failures.
 * @shost:	scsi host being recovered.
 * @work_q:	Queue of scsi cmds to process.
329
 */
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332 333 334 335 336 337 338 339 340 341 342 343
static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
					  struct list_head *work_q)
{
	struct scsi_cmnd *scmd;
	struct scsi_device *sdev;
	int total_failures = 0;
	int cmd_failed = 0;
	int cmd_cancel = 0;
	int devices_failed = 0;

	shost_for_each_device(sdev, shost) {
		list_for_each_entry(scmd, work_q, eh_entry) {
			if (scmd->device == sdev) {
				++total_failures;
344
				if (scmd->eh_eflags & SCSI_EH_CANCEL_CMD)
Linus Torvalds's avatar
Linus Torvalds committed
345
					++cmd_cancel;
346
				else
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349 350 351 352
					++cmd_failed;
			}
		}

		if (cmd_cancel || cmd_failed) {
			SCSI_LOG_ERROR_RECOVERY(3,
353
				shost_printk(KERN_INFO, shost,
354
					    "%s: cmds failed: %d, cancel: %d\n",
355
					    __func__, cmd_failed,
356
					    cmd_cancel));
Linus Torvalds's avatar
Linus Torvalds committed
357 358 359 360 361 362
			cmd_cancel = 0;
			cmd_failed = 0;
			++devices_failed;
		}
	}

363 364 365
	SCSI_LOG_ERROR_RECOVERY(2, shost_printk(KERN_INFO, shost,
				   "Total of %d commands on %d"
				   " devices require eh work\n",
366
				   total_failures, devices_failed));
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369
}
#endif

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
 /**
 * scsi_report_lun_change - Set flag on all *other* devices on the same target
 *                          to indicate that a UNIT ATTENTION is expected.
 * @sdev:	Device reporting the UNIT ATTENTION
 */
static void scsi_report_lun_change(struct scsi_device *sdev)
{
	sdev->sdev_target->expecting_lun_change = 1;
}

/**
 * scsi_report_sense - Examine scsi sense information and log messages for
 *		       certain conditions, also issue uevents for some of them.
 * @sdev:	Device reporting the sense code
 * @sshdr:	sshdr to be examined
 */
static void scsi_report_sense(struct scsi_device *sdev,
			      struct scsi_sense_hdr *sshdr)
{
	enum scsi_device_event evt_type = SDEV_EVT_MAXBITS;	/* i.e. none */

	if (sshdr->sense_key == UNIT_ATTENTION) {
		if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
			evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
			sdev_printk(KERN_WARNING, sdev,
				    "Inquiry data has changed");
		} else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
			evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
			scsi_report_lun_change(sdev);
			sdev_printk(KERN_WARNING, sdev,
				    "Warning! Received an indication that the "
				    "LUN assignments on this target have "
				    "changed. The Linux SCSI layer does not "
				    "automatically remap LUN assignments.\n");
		} else if (sshdr->asc == 0x3f)
			sdev_printk(KERN_WARNING, sdev,
				    "Warning! Received an indication that the "
				    "operating parameters on this target have "
				    "changed. The Linux SCSI layer does not "
				    "automatically adjust these parameters.\n");

		if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
			evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
			sdev_printk(KERN_WARNING, sdev,
				    "Warning! Received an indication that the "
				    "LUN reached a thin provisioning soft "
				    "threshold.\n");
		}

		if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
			evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
			sdev_printk(KERN_WARNING, sdev,
				    "Mode parameters changed");
423 424 425 426
		} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
			evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
			sdev_printk(KERN_WARNING, sdev,
				    "Asymmetric access state changed");
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
		} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
			evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
			sdev_printk(KERN_WARNING, sdev,
				    "Capacity data has changed");
		} else if (sshdr->asc == 0x2a)
			sdev_printk(KERN_WARNING, sdev,
				    "Parameters changed");
	}

	if (evt_type != SDEV_EVT_MAXBITS) {
		set_bit(evt_type, sdev->pending_events);
		schedule_work(&sdev->event_work);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
442 443 444 445 446
/**
 * scsi_check_sense - Examine scsi cmd sense
 * @scmd:	Cmd to have sense checked.
 *
 * Return value:
447
 *	SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE
Linus Torvalds's avatar
Linus Torvalds committed
448 449 450 451
 *
 * Notes:
 *	When a deferred error is detected the current command has
 *	not been executed and needs retrying.
452
 */
453
int scsi_check_sense(struct scsi_cmnd *scmd)
Linus Torvalds's avatar
Linus Torvalds committed
454
{
455
	struct scsi_device *sdev = scmd->device;
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460
	struct scsi_sense_hdr sshdr;

	if (! scsi_command_normalize_sense(scmd, &sshdr))
		return FAILED;	/* no valid sense data */

461 462
	scsi_report_sense(sdev, &sshdr);

Linus Torvalds's avatar
Linus Torvalds committed
463 464 465
	if (scsi_sense_is_deferred(&sshdr))
		return NEEDS_RETRY;

466
	if (sdev->handler && sdev->handler->check_sense) {
467 468
		int rc;

469
		rc = sdev->handler->check_sense(sdev, &sshdr);
470 471 472 473 474
		if (rc != SCSI_RETURN_NOT_HANDLED)
			return rc;
		/* handler does not care. Drop down to default handling */
	}

475 476 477 478 479 480 481 482
	if (scmd->cmnd[0] == TEST_UNIT_READY && scmd->scsi_done != scsi_eh_done)
		/*
		 * nasty: for mid-layer issued TURs, we need to return the
		 * actual sense data without any recovery attempt.  For eh
		 * issued ones, we need to try to recover and interpret
		 */
		return SUCCESS;

Linus Torvalds's avatar
Linus Torvalds committed
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
	/*
	 * Previous logic looked for FILEMARK, EOM or ILI which are
	 * mainly associated with tapes and returned SUCCESS.
	 */
	if (sshdr.response_code == 0x70) {
		/* fixed format */
		if (scmd->sense_buffer[2] & 0xe0)
			return SUCCESS;
	} else {
		/*
		 * descriptor format: look for "stream commands sense data
		 * descriptor" (see SSC-3). Assume single sense data
		 * descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
		 */
		if ((sshdr.additional_length > 3) &&
		    (scmd->sense_buffer[8] == 0x4) &&
		    (scmd->sense_buffer[11] & 0xe0))
			return SUCCESS;
	}

	switch (sshdr.sense_key) {
	case NO_SENSE:
		return SUCCESS;
	case RECOVERED_ERROR:
		return /* soft_error */ SUCCESS;

	case ABORTED_COMMAND:
510 511 512
		if (sshdr.asc == 0x10) /* DIF */
			return SUCCESS;

Linus Torvalds's avatar
Linus Torvalds committed
513 514 515 516 517 518 519 520 521 522
		return NEEDS_RETRY;
	case NOT_READY:
	case UNIT_ATTENTION:
		/*
		 * if we are expecting a cc/ua because of a bus reset that we
		 * performed, treat this just as a retry.  otherwise this is
		 * information that we should pass up to the upper-level driver
		 * so that we can deal with it there.
		 */
		if (scmd->device->expecting_cc_ua) {
523 524 525 526 527 528 529 530 531 532
			/*
			 * Because some device does not queue unit
			 * attentions correctly, we carefully check
			 * additional sense code and qualifier so as
			 * not to squash media change unit attention.
			 */
			if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
				scmd->device->expecting_cc_ua = 0;
				return NEEDS_RETRY;
			}
Linus Torvalds's avatar
Linus Torvalds committed
533
		}
534 535 536 537 538 539 540 541
		/*
		 * we might also expect a cc/ua if another LUN on the target
		 * reported a UA with an ASC/ASCQ of 3F 0E -
		 * REPORTED LUNS DATA HAS CHANGED.
		 */
		if (scmd->device->sdev_target->expecting_lun_change &&
		    sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
			return NEEDS_RETRY;
Linus Torvalds's avatar
Linus Torvalds committed
542
		/*
543
		 * if the device is in the process of becoming ready, we
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549 550 551 552 553 554
		 * should retry.
		 */
		if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
			return NEEDS_RETRY;
		/*
		 * if the device is not started, we need to wake
		 * the error handler to start the motor
		 */
		if (scmd->device->allow_restart &&
		    (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
			return FAILED;
555 556 557 558 559
		/*
		 * Pass the UA upwards for a determination in the completion
		 * functions.
		 */
		return SUCCESS;
Linus Torvalds's avatar
Linus Torvalds committed
560

561
		/* these are not supported */
562 563 564 565 566 567
	case DATA_PROTECT:
		if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
			/* Thin provisioning hard threshold reached */
			set_host_byte(scmd, DID_ALLOC_FAILURE);
			return SUCCESS;
		}
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570
	case COPY_ABORTED:
	case VOLUME_OVERFLOW:
	case MISCOMPARE:
571
	case BLANK_CHECK:
572 573
		set_host_byte(scmd, DID_TARGET_FAILURE);
		return SUCCESS;
Linus Torvalds's avatar
Linus Torvalds committed
574 575

	case MEDIUM_ERROR:
576 577 578
		if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
		    sshdr.asc == 0x13 || /* AMNF DATA FIELD */
		    sshdr.asc == 0x14) { /* RECORD NOT FOUND */
579
			set_host_byte(scmd, DID_MEDIUM_ERROR);
580
			return SUCCESS;
581
		}
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585
		return NEEDS_RETRY;

	case HARDWARE_ERROR:
		if (scmd->device->retry_hwerror)
586
			return ADD_TO_MLQUEUE;
Linus Torvalds's avatar
Linus Torvalds committed
587
		else
588
			set_host_byte(scmd, DID_TARGET_FAILURE);
Linus Torvalds's avatar
Linus Torvalds committed
589 590

	case ILLEGAL_REQUEST:
591 592 593 594
		if (sshdr.asc == 0x20 || /* Invalid command operation code */
		    sshdr.asc == 0x21 || /* Logical block address out of range */
		    sshdr.asc == 0x24 || /* Invalid field in cdb */
		    sshdr.asc == 0x26) { /* Parameter value invalid */
595
			set_host_byte(scmd, DID_TARGET_FAILURE);
596 597 598
		}
		return SUCCESS;

Linus Torvalds's avatar
Linus Torvalds committed
599 600 601 602
	default:
		return SUCCESS;
	}
}
603
EXPORT_SYMBOL_GPL(scsi_check_sense);
Linus Torvalds's avatar
Linus Torvalds committed
604

605 606 607 608 609
static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
{
	struct scsi_host_template *sht = sdev->host->hostt;
	struct scsi_device *tmp_sdev;

610
	if (!sht->track_queue_depth ||
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
	    sdev->queue_depth >= sdev->max_queue_depth)
		return;

	if (time_before(jiffies,
	    sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
		return;

	if (time_before(jiffies,
	    sdev->last_queue_full_time + sdev->queue_ramp_up_period))
		return;

	/*
	 * Walk all devices of a target and do
	 * ramp up on them.
	 */
	shost_for_each_device(tmp_sdev, sdev->host) {
		if (tmp_sdev->channel != sdev->channel ||
		    tmp_sdev->id != sdev->id ||
		    tmp_sdev->queue_depth == sdev->max_queue_depth)
			continue;
631

632
		scsi_change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1);
633 634 635 636
		sdev->last_queue_ramp_up = jiffies;
	}
}

637 638 639 640 641
static void scsi_handle_queue_full(struct scsi_device *sdev)
{
	struct scsi_host_template *sht = sdev->host->hostt;
	struct scsi_device *tmp_sdev;

642
	if (!sht->track_queue_depth)
643 644 645 646 647 648 649 650 651 652 653
		return;

	shost_for_each_device(tmp_sdev, sdev->host) {
		if (tmp_sdev->channel != sdev->channel ||
		    tmp_sdev->id != sdev->id)
			continue;
		/*
		 * We do not know the number of commands that were at
		 * the device when we got the queue full so we start
		 * from the highest possible value and work our way down.
		 */
654
		scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
655 656 657
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
658 659 660 661 662 663 664 665 666
/**
 * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
 * @scmd:	SCSI cmd to examine.
 *
 * Notes:
 *    This is *only* called when we are examining the status of commands
 *    queued during error recovery.  the main difference here is that we
 *    don't allow for the possibility of retries here, and we are a lot
 *    more restrictive about what we consider acceptable.
667
 */
Linus Torvalds's avatar
Linus Torvalds committed
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
{
	/*
	 * first check the host byte, to see if there is anything in there
	 * that would indicate what we need to do.
	 */
	if (host_byte(scmd->result) == DID_RESET) {
		/*
		 * rats.  we are already in the error handler, so we now
		 * get to try and figure out what to do next.  if the sense
		 * is valid, we have a pretty good idea of what to do.
		 * if not, we mark it as FAILED.
		 */
		return scsi_check_sense(scmd);
	}
	if (host_byte(scmd->result) != DID_OK)
		return FAILED;

	/*
	 * next, check the message byte.
	 */
	if (msg_byte(scmd->result) != COMMAND_COMPLETE)
		return FAILED;

	/*
	 * now, check the status byte to see if this indicates
	 * anything special.
	 */
	switch (status_byte(scmd->result)) {
	case GOOD:
698
		scsi_handle_queue_ramp_up(scmd->device);
Linus Torvalds's avatar
Linus Torvalds committed
699 700 701 702 703 704 705 706 707 708 709
	case COMMAND_TERMINATED:
		return SUCCESS;
	case CHECK_CONDITION:
		return scsi_check_sense(scmd);
	case CONDITION_GOOD:
	case INTERMEDIATE_GOOD:
	case INTERMEDIATE_C_GOOD:
		/*
		 * who knows?  FIXME(eric)
		 */
		return SUCCESS;
710
	case RESERVATION_CONFLICT:
711 712 713 714 715 716
		if (scmd->cmnd[0] == TEST_UNIT_READY)
			/* it is a success, we probed the device and
			 * found it */
			return SUCCESS;
		/* otherwise, we failed to send the command */
		return FAILED;
Linus Torvalds's avatar
Linus Torvalds committed
717
	case QUEUE_FULL:
718 719 720
		scsi_handle_queue_full(scmd->device);
		/* fall through */
	case BUSY:
721
		return NEEDS_RETRY;
Linus Torvalds's avatar
Linus Torvalds committed
722 723 724 725 726 727 728 729 730
	default:
		return FAILED;
	}
	return FAILED;
}

/**
 * scsi_eh_done - Completion function for error handling.
 * @scmd:	Cmd that is done.
731
 */
Linus Torvalds's avatar
Linus Torvalds committed
732 733
static void scsi_eh_done(struct scsi_cmnd *scmd)
{
734
	struct completion *eh_action;
735

736
	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
737
			"%s result: %x\n", __func__, scmd->result));
738 739 740 741

	eh_action = scmd->device->host->eh_action;
	if (eh_action)
		complete(eh_action);
Linus Torvalds's avatar
Linus Torvalds committed
742 743
}

744 745
/**
 * scsi_try_host_reset - ask host adapter to reset itself
746
 * @scmd:	SCSI cmd to send host reset.
747
 */
748 749 750 751
static int scsi_try_host_reset(struct scsi_cmnd *scmd)
{
	unsigned long flags;
	int rtn;
752 753
	struct Scsi_Host *host = scmd->device->host;
	struct scsi_host_template *hostt = host->hostt;
754

755 756
	SCSI_LOG_ERROR_RECOVERY(3,
		shost_printk(KERN_INFO, host, "Snd Host RST\n"));
757

758
	if (!hostt->eh_host_reset_handler)
759 760
		return FAILED;

761
	rtn = hostt->eh_host_reset_handler(scmd);
762 763

	if (rtn == SUCCESS) {
764
		if (!hostt->skip_settle_delay)
765
			ssleep(HOST_RESET_SETTLE_TIME);
766 767 768
		spin_lock_irqsave(host->host_lock, flags);
		scsi_report_bus_reset(host, scmd_channel(scmd));
		spin_unlock_irqrestore(host->host_lock, flags);
769 770 771 772 773 774 775 776
	}

	return rtn;
}

/**
 * scsi_try_bus_reset - ask host to perform a bus reset
 * @scmd:	SCSI cmd to send bus reset.
777
 */
778 779 780 781
static int scsi_try_bus_reset(struct scsi_cmnd *scmd)
{
	unsigned long flags;
	int rtn;
782 783
	struct Scsi_Host *host = scmd->device->host;
	struct scsi_host_template *hostt = host->hostt;
784

785 786
	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
		"%s: Snd Bus RST\n", __func__));
787

788
	if (!hostt->eh_bus_reset_handler)
789 790
		return FAILED;

791
	rtn = hostt->eh_bus_reset_handler(scmd);
792 793

	if (rtn == SUCCESS) {
794
		if (!hostt->skip_settle_delay)
795
			ssleep(BUS_RESET_SETTLE_TIME);
796 797 798
		spin_lock_irqsave(host->host_lock, flags);
		scsi_report_bus_reset(host, scmd_channel(scmd));
		spin_unlock_irqrestore(host->host_lock, flags);
799 800 801 802 803
	}

	return rtn;
}

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
static void __scsi_report_device_reset(struct scsi_device *sdev, void *data)
{
	sdev->was_reset = 1;
	sdev->expecting_cc_ua = 1;
}

/**
 * scsi_try_target_reset - Ask host to perform a target reset
 * @scmd:	SCSI cmd used to send a target reset
 *
 * Notes:
 *    There is no timeout for this operation.  if this operation is
 *    unreliable for a given host, then the host itself needs to put a
 *    timer on it, and set the host back to a consistent state prior to
 *    returning.
 */
static int scsi_try_target_reset(struct scsi_cmnd *scmd)
{
	unsigned long flags;
	int rtn;
824 825
	struct Scsi_Host *host = scmd->device->host;
	struct scsi_host_template *hostt = host->hostt;
826

827
	if (!hostt->eh_target_reset_handler)
828 829
		return FAILED;

830
	rtn = hostt->eh_target_reset_handler(scmd);
831
	if (rtn == SUCCESS) {
832
		spin_lock_irqsave(host->host_lock, flags);
833 834
		__starget_for_each_device(scsi_target(scmd->device), NULL,
					  __scsi_report_device_reset);
835
		spin_unlock_irqrestore(host->host_lock, flags);
836 837 838 839 840
	}

	return rtn;
}

841 842 843 844 845 846 847 848 849
/**
 * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
 * @scmd:	SCSI cmd used to send BDR
 *
 * Notes:
 *    There is no timeout for this operation.  if this operation is
 *    unreliable for a given host, then the host itself needs to put a
 *    timer on it, and set the host back to a consistent state prior to
 *    returning.
850
 */
851 852 853
static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
{
	int rtn;
854
	struct scsi_host_template *hostt = scmd->device->host->hostt;
855

856
	if (!hostt->eh_device_reset_handler)
857 858
		return FAILED;

859
	rtn = hostt->eh_device_reset_handler(scmd);
860 861
	if (rtn == SUCCESS)
		__scsi_report_device_reset(scmd->device, NULL);
862 863 864
	return rtn;
}

865 866
/**
 * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
867
 * @hostt:	SCSI driver host template
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
 * @scmd:	SCSI cmd used to send a target reset
 *
 * Return value:
 *	SUCCESS, FAILED, or FAST_IO_FAIL
 *
 * Notes:
 *    SUCCESS does not necessarily indicate that the command
 *    has been aborted; it only indicates that the LLDDs
 *    has cleared all references to that command.
 *    LLDDs should return FAILED only if an abort was required
 *    but could not be executed. LLDDs should return FAST_IO_FAIL
 *    if the device is temporarily unavailable (eg due to a
 *    link down on FibreChannel)
 */
static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt,
				 struct scsi_cmnd *scmd)
884
{
885
	if (!hostt->eh_abort_handler)
886 887
		return FAILED;

888
	return hostt->eh_abort_handler(scmd);
889 890 891 892
}

static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)
{
893
	if (scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd) != SUCCESS)
894
		if (scsi_try_bus_device_reset(scmd) != SUCCESS)
895 896 897
			if (scsi_try_target_reset(scmd) != SUCCESS)
				if (scsi_try_bus_reset(scmd) != SUCCESS)
					scsi_try_host_reset(scmd);
898 899
}

Linus Torvalds's avatar
Linus Torvalds committed
900
/**
901
 * scsi_eh_prep_cmnd  - Save a scsi command info as part of error recovery
902
 * @scmd:       SCSI command structure to hijack
903
 * @ses:        structure to save restore information
904
 * @cmnd:       CDB to send. Can be NULL if no new cmnd is needed
905
 * @cmnd_size:  size in bytes of @cmnd (must be <= BLK_MAX_CDB)
906
 * @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
907
 *
908
 * This function is used to save a scsi command information before re-execution
909 910 911 912
 * as part of the error recovery process.  If @sense_bytes is 0 the command
 * sent must be one that does not transfer any data.  If @sense_bytes != 0
 * @cmnd is ignored and this functions sets up a REQUEST_SENSE command
 * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
913
 */
914 915
void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses,
			unsigned char *cmnd, int cmnd_size, unsigned sense_bytes)
Linus Torvalds's avatar
Linus Torvalds committed
916
{
917
	struct scsi_device *sdev = scmd->device;
Linus Torvalds's avatar
Linus Torvalds committed
918

919 920 921 922 923 924 925
	/*
	 * We need saved copies of a number of fields - this is because
	 * error handling may need to overwrite these with different values
	 * to run different commands, and once error handling is complete,
	 * we will need to restore these values prior to running the actual
	 * command.
	 */
926
	ses->cmd_len = scmd->cmd_len;
927
	ses->cmnd = scmd->cmnd;
928
	ses->data_direction = scmd->sc_data_direction;
929
	ses->sdb = scmd->sdb;
930
	ses->next_rq = scmd->request->next_rq;
931
	ses->result = scmd->result;
932
	ses->underflow = scmd->underflow;
933
	ses->prot_op = scmd->prot_op;
934

935
	scmd->prot_op = SCSI_PROT_NORMAL;
936
	scmd->eh_eflags = 0;
937 938
	scmd->cmnd = ses->eh_cmnd;
	memset(scmd->cmnd, 0, BLK_MAX_CDB);
939
	memset(&scmd->sdb, 0, sizeof(scmd->sdb));
940
	scmd->request->next_rq = NULL;
941
	scmd->result = 0;
942

943
	if (sense_bytes) {
944 945
		scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
					 sense_bytes);
946
		sg_init_one(&ses->sense_sgl, scmd->sense_buffer,
947 948
			    scmd->sdb.length);
		scmd->sdb.table.sgl = &ses->sense_sgl;
949
		scmd->sc_data_direction = DMA_FROM_DEVICE;
950
		scmd->sdb.table.nents = scmd->sdb.table.orig_nents = 1;
951
		scmd->cmnd[0] = REQUEST_SENSE;
952
		scmd->cmnd[4] = scmd->sdb.length;
953
		scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
954 955
	} else {
		scmd->sc_data_direction = DMA_NONE;
956
		if (cmnd) {
957
			BUG_ON(cmnd_size > BLK_MAX_CDB);
958 959 960
			memcpy(scmd->cmnd, cmnd, cmnd_size);
			scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
		}
961 962 963 964
	}

	scmd->underflow = 0;

965
	if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN)
Linus Torvalds's avatar
Linus Torvalds committed
966
		scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
967
			(sdev->lun << 5 & 0xe0);
Linus Torvalds's avatar
Linus Torvalds committed
968

969 970 971 972
	/*
	 * Zero the sense buffer.  The scsi spec mandates that any
	 * untransferred sense data should be interpreted as being zero.
	 */
973
	memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
974 975 976 977
}
EXPORT_SYMBOL(scsi_eh_prep_cmnd);

/**
978
 * scsi_eh_restore_cmnd  - Restore a scsi command info as part of error recovery
979
 * @scmd:       SCSI command structure to restore
980
 * @ses:        saved information from a coresponding call to scsi_eh_prep_cmnd
981
 *
982
 * Undo any damage done by above scsi_eh_prep_cmnd().
983
 */
984 985 986 987 988 989
void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)
{
	/*
	 * Restore original data
	 */
	scmd->cmd_len = ses->cmd_len;
990
	scmd->cmnd = ses->cmnd;
991
	scmd->sc_data_direction = ses->data_direction;
992
	scmd->sdb = ses->sdb;
993
	scmd->request->next_rq = ses->next_rq;
994
	scmd->result = ses->result;
995
	scmd->underflow = ses->underflow;
996
	scmd->prot_op = ses->prot_op;
997 998
}
EXPORT_SYMBOL(scsi_eh_restore_cmnd);
999

1000
/**
1001
 * scsi_send_eh_cmnd  - submit a scsi command as part of error recovery
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
 * @scmd:       SCSI command structure to hijack
 * @cmnd:       CDB to send
 * @cmnd_size:  size in bytes of @cmnd
 * @timeout:    timeout for this request
 * @sense_bytes: size of sense data to copy or 0
 *
 * This function is used to send a scsi command down to a target device
 * as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
 *
 * Return value:
 *    SUCCESS or FAILED or NEEDS_RETRY
1013
 */
1014 1015 1016 1017 1018 1019
static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
			     int cmnd_size, int timeout, unsigned sense_bytes)
{
	struct scsi_device *sdev = scmd->device;
	struct Scsi_Host *shost = sdev->host;
	DECLARE_COMPLETION_ONSTACK(done);
1020
	unsigned long timeleft = timeout;
1021
	struct scsi_eh_save ses;
1022
	const unsigned long stall_for = msecs_to_jiffies(100);
1023 1024
	int rtn;

1025
retry:
1026
	scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
1027
	shost->eh_action = &done;
Linus Torvalds's avatar
Linus Torvalds committed
1028 1029

	scsi_log_send(scmd);
Jeff Garzik's avatar
Jeff Garzik committed
1030
	scmd->scsi_done = scsi_eh_done;
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
	rtn = shost->hostt->queuecommand(shost, scmd);
	if (rtn) {
		if (timeleft > stall_for) {
			scsi_eh_restore_cmnd(scmd, &ses);
			timeleft -= stall_for;
			msleep(jiffies_to_msecs(stall_for));
			goto retry;
		}
		/* signal not to enter either branch of the if () below */
		timeleft = 0;
1041
		rtn = FAILED;
1042 1043
	} else {
		timeleft = wait_for_completion_timeout(&done, timeout);
1044
		rtn = SUCCESS;
1045
	}
Linus Torvalds's avatar
Linus Torvalds committed
1046

1047
	shost->eh_action = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1048

1049
	scsi_log_completion(scmd, rtn);
Linus Torvalds's avatar
Linus Torvalds committed
1050

1051
	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1052 1053
			"%s timeleft: %ld\n",
			__func__, timeleft));
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055

	/*
1056 1057 1058 1059 1060 1061 1062
	 * If there is time left scsi_eh_done got called, and we will examine
	 * the actual status codes to see whether the command actually did
	 * complete normally, else if we have a zero return and no time left,
	 * the command must still be pending, so abort it and return FAILED.
	 * If we never actually managed to issue the command, because
	 * ->queuecommand() kept returning non zero, use the rtn = FAILED
	 * value above (so don't execute either branch of the if)
Linus Torvalds's avatar
Linus Torvalds committed
1063
	 */
1064
	if (timeleft) {
Linus Torvalds's avatar
Linus Torvalds committed
1065
		rtn = scsi_eh_completed_normally(scmd);
1066 1067
		SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
			"%s: scsi_eh_completed_normally %x\n", __func__, rtn));
1068

Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071 1072 1073
		switch (rtn) {
		case SUCCESS:
		case NEEDS_RETRY:
		case FAILED:
			break;
1074 1075 1076
		case ADD_TO_MLQUEUE:
			rtn = NEEDS_RETRY;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079 1080
		default:
			rtn = FAILED;
			break;
		}
1081
	} else if (rtn != FAILED) {
1082
		scsi_abort_eh_cmnd(scmd);
1083
		rtn = FAILED;
Linus Torvalds's avatar
Linus Torvalds committed
1084 1085
	}

1086
	scsi_eh_restore_cmnd(scmd, &ses);
1087

Linus Torvalds's avatar
Linus Torvalds committed
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
	return rtn;
}

/**
 * scsi_request_sense - Request sense data from a particular target.
 * @scmd:	SCSI cmd for request sense.
 *
 * Notes:
 *    Some hosts automatically obtain this information, others require
 *    that we obtain it on our own. This function will *not* return until
 *    the command either times out, or it completes.
1099
 */
Linus Torvalds's avatar
Linus Torvalds committed
1100 1101
static int scsi_request_sense(struct scsi_cmnd *scmd)
{
1102
	return scsi_send_eh_cmnd(scmd, NULL, 0, scmd->device->eh_timeout, ~0);
Linus Torvalds's avatar
Linus Torvalds committed
1103 1104
}

1105 1106
static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)
{
1107
	if (!blk_rq_is_passthrough(scmd->request)) {
1108 1109 1110 1111 1112 1113 1114
		struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
		if (sdrv->eh_action)
			rtn = sdrv->eh_action(scmd, rtn);
	}
	return rtn;
}

Linus Torvalds's avatar
Linus Torvalds committed
1115 1116 1117 1118 1119 1120 1121 1122
/**
 * scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
 * @scmd:	Original SCSI cmd that eh has finished.
 * @done_q:	Queue for processed commands.
 *
 * Notes:
 *    We don't want to use the normal command completion while we are are
 *    still handling errors - it may cause other commands to be queued,
1123
 *    and that would disturb what we are doing.  Thus we really want to
Linus Torvalds's avatar
Linus Torvalds committed
1124 1125
 *    keep a list of pending commands for final completion, and once we
 *    are ready to leave error handling we handle completion for real.
1126
 */
1127
void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
Linus Torvalds's avatar
Linus Torvalds committed
1128
{
1129
	scmd->eh_eflags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131
	list_move_tail(&scmd->eh_entry, done_q);
}
1132
EXPORT_SYMBOL(scsi_eh_finish_cmd);
Linus Torvalds's avatar
Linus Torvalds committed
1133 1134 1135 1136

/**
 * scsi_eh_get_sense - Get device sense data.
 * @work_q:	Queue of commands to process.
1137
 * @done_q:	Queue of processed commands.
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139 1140
 *
 * Description:
 *    See if we need to request sense information.  if so, then get it
1141
 *    now, so we have a better idea of what to do.
Linus Torvalds's avatar
Linus Torvalds committed
1142 1143 1144
 *
 * Notes:
 *    This has the unfortunate side effect that if a shost adapter does
1145
 *    not automatically request sense information, we end up shutting
Linus Torvalds's avatar
Linus Torvalds committed
1146 1147 1148 1149 1150 1151 1152
 *    it down before we request it.
 *
 *    All drivers should request sense information internally these days,
 *    so for now all I have to say is tough noogies if you end up in here.
 *
 *    XXX: Long term this code should go away, but that needs an audit of
 *         all LLDDs first.
1153
 */
1154 1155
int scsi_eh_get_sense(struct list_head *work_q,
		      struct list_head *done_q)
Linus Torvalds's avatar
Linus Torvalds committed
1156
{
1157
	struct scsi_cmnd *scmd, *next;
1158
	struct Scsi_Host *shost;
Linus Torvalds's avatar
Linus Torvalds committed
1159 1160
	int rtn;

1161 1162 1163 1164
	/*
	 * If SCSI_EH_ABORT_SCHEDULED has been set, it is timeout IO,
	 * should not get sense.
	 */
1165
	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1166
		if ((scmd->eh_eflags & SCSI_EH_CANCEL_CMD) ||
1167
		    (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) ||
Linus Torvalds's avatar
Linus Torvalds committed
1168 1169 1170
		    SCSI_SENSE_VALID(scmd))
			continue;

1171 1172 1173
		shost = scmd->device->host;
		if (scsi_host_eh_past_deadline(shost)) {
			SCSI_LOG_ERROR_RECOVERY(3,
1174 1175 1176
				scmd_printk(KERN_INFO, scmd,
					    "%s: skip request sense, past eh deadline\n",
					     current->comm));
1177 1178
			break;
		}
1179 1180 1181 1182 1183 1184 1185 1186 1187
		if (status_byte(scmd->result) != CHECK_CONDITION)
			/*
			 * don't request sense if there's no check condition
			 * status because the error we're processing isn't one
			 * that has a sense code (and some devices get
			 * confused by sense requests out of the blue)
			 */
			continue;

1188 1189 1190
		SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
						  "%s: requesting sense\n",
						  current->comm));
Linus Torvalds's avatar
Linus Torvalds committed
1191 1192 1193 1194
		rtn = scsi_request_sense(scmd);
		if (rtn != SUCCESS)
			continue;

1195
		SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1196
			"sense requested, result %x\n", scmd->result));
1197
		SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
Linus Torvalds's avatar
Linus Torvalds committed
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218

		rtn = scsi_decide_disposition(scmd);

		/*
		 * if the result was normal, then just pass it along to the
		 * upper level.
		 */
		if (rtn == SUCCESS)
			/* we don't want this command reissued, just
			 * finished with the sense data, so set
			 * retries to the max allowed to ensure it
			 * won't get reissued */
			scmd->retries = scmd->allowed;
		else if (rtn != NEEDS_RETRY)
			continue;

		scsi_eh_finish_cmd(scmd, done_q);
	}

	return list_empty(work_q);
}
1219
EXPORT_SYMBOL_GPL(scsi_eh_get_sense);
Linus Torvalds's avatar
Linus Torvalds committed
1220 1221 1222

/**
 * scsi_eh_tur - Send TUR to device.
1223
 * @scmd:	&scsi_cmnd to send TUR
Linus Torvalds's avatar
Linus Torvalds committed
1224 1225 1226
 *
 * Return value:
 *    0 - Device is ready. 1 - Device NOT ready.
1227
 */
Linus Torvalds's avatar
Linus Torvalds committed
1228 1229 1230 1231 1232 1233
static int scsi_eh_tur(struct scsi_cmnd *scmd)
{
	static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
	int retry_cnt = 1, rtn;

retry_tur:
1234 1235
	rtn = scsi_send_eh_cmnd(scmd, tur_command, 6,
				scmd->device->eh_timeout, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1236

1237
	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1238
		"%s return: %x\n", __func__, rtn));
1239 1240 1241