PageRenderTime 78ms CodeModel.GetById 3ms app.highlight 60ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/scsi/scsi_error.c

http://github.com/mirrors/linux
C | 2468 lines | 1450 code | 253 blank | 765 comment | 387 complexity | eed5a215adcec46748f2f488268d2e94 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  scsi_error.c Copyright (C) 1997 Eric Youngdale
   4 *
   5 *  SCSI error/timeout handling
   6 *      Initial versions: Eric Youngdale.  Based upon conversations with
   7 *                        Leonard Zubkoff and David Miller at Linux Expo,
   8 *                        ideas originating from all over the place.
   9 *
  10 *	Restructured scsi_unjam_host and associated functions.
  11 *	September 04, 2002 Mike Anderson (andmike@us.ibm.com)
  12 *
  13 *	Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
  14 *	minor cleanups.
  15 *	September 30, 2002 Mike Anderson (andmike@us.ibm.com)
  16 */
  17
  18#include <linux/module.h>
  19#include <linux/sched.h>
  20#include <linux/gfp.h>
  21#include <linux/timer.h>
  22#include <linux/string.h>
  23#include <linux/kernel.h>
  24#include <linux/freezer.h>
  25#include <linux/kthread.h>
  26#include <linux/interrupt.h>
  27#include <linux/blkdev.h>
  28#include <linux/delay.h>
  29#include <linux/jiffies.h>
  30
  31#include <scsi/scsi.h>
  32#include <scsi/scsi_cmnd.h>
  33#include <scsi/scsi_dbg.h>
  34#include <scsi/scsi_device.h>
  35#include <scsi/scsi_driver.h>
  36#include <scsi/scsi_eh.h>
  37#include <scsi/scsi_common.h>
  38#include <scsi/scsi_transport.h>
  39#include <scsi/scsi_host.h>
  40#include <scsi/scsi_ioctl.h>
  41#include <scsi/scsi_dh.h>
  42#include <scsi/scsi_devinfo.h>
  43#include <scsi/sg.h>
  44
  45#include "scsi_priv.h"
  46#include "scsi_logging.h"
  47#include "scsi_transport_api.h"
  48
  49#include <trace/events/scsi.h>
  50
  51#include <asm/unaligned.h>
  52
  53static void scsi_eh_done(struct scsi_cmnd *scmd);
  54
  55/*
  56 * These should *probably* be handled by the host itself.
  57 * Since it is allowed to sleep, it probably should.
  58 */
  59#define BUS_RESET_SETTLE_TIME   (10)
  60#define HOST_RESET_SETTLE_TIME  (10)
  61
  62static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
  63static int scsi_try_to_abort_cmd(struct scsi_host_template *,
  64				 struct scsi_cmnd *);
  65
  66void scsi_eh_wakeup(struct Scsi_Host *shost)
  67{
  68	lockdep_assert_held(shost->host_lock);
  69
  70	if (scsi_host_busy(shost) == shost->host_failed) {
  71		trace_scsi_eh_wakeup(shost);
  72		wake_up_process(shost->ehandler);
  73		SCSI_LOG_ERROR_RECOVERY(5, shost_printk(KERN_INFO, shost,
  74			"Waking error handler thread\n"));
  75	}
  76}
  77
  78/**
  79 * scsi_schedule_eh - schedule EH for SCSI host
  80 * @shost:	SCSI host to invoke error handling on.
  81 *
  82 * Schedule SCSI EH without scmd.
  83 */
  84void scsi_schedule_eh(struct Scsi_Host *shost)
  85{
  86	unsigned long flags;
  87
  88	spin_lock_irqsave(shost->host_lock, flags);
  89
  90	if (scsi_host_set_state(shost, SHOST_RECOVERY) == 0 ||
  91	    scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY) == 0) {
  92		shost->host_eh_scheduled++;
  93		scsi_eh_wakeup(shost);
  94	}
  95
  96	spin_unlock_irqrestore(shost->host_lock, flags);
  97}
  98EXPORT_SYMBOL_GPL(scsi_schedule_eh);
  99
 100static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
 101{
 102	if (!shost->last_reset || shost->eh_deadline == -1)
 103		return 0;
 104
 105	/*
 106	 * 32bit accesses are guaranteed to be atomic
 107	 * (on all supported architectures), so instead
 108	 * of using a spinlock we can as well double check
 109	 * if eh_deadline has been set to 'off' during the
 110	 * time_before call.
 111	 */
 112	if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
 113	    shost->eh_deadline > -1)
 114		return 0;
 115
 116	return 1;
 117}
 118
 119/**
 120 * scmd_eh_abort_handler - Handle command aborts
 121 * @work:	command to be aborted.
 122 *
 123 * Note: this function must be called only for a command that has timed out.
 124 * Because the block layer marks a request as complete before it calls
 125 * scsi_times_out(), a .scsi_done() call from the LLD for a command that has
 126 * timed out do not have any effect. Hence it is safe to call
 127 * scsi_finish_command() from this function.
 128 */
 129void
 130scmd_eh_abort_handler(struct work_struct *work)
 131{
 132	struct scsi_cmnd *scmd =
 133		container_of(work, struct scsi_cmnd, abort_work.work);
 134	struct scsi_device *sdev = scmd->device;
 135	int rtn;
 136
 137	if (scsi_host_eh_past_deadline(sdev->host)) {
 138		SCSI_LOG_ERROR_RECOVERY(3,
 139			scmd_printk(KERN_INFO, scmd,
 140				    "eh timeout, not aborting\n"));
 141	} else {
 142		SCSI_LOG_ERROR_RECOVERY(3,
 143			scmd_printk(KERN_INFO, scmd,
 144				    "aborting command\n"));
 145		rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
 146		if (rtn == SUCCESS) {
 147			set_host_byte(scmd, DID_TIME_OUT);
 148			if (scsi_host_eh_past_deadline(sdev->host)) {
 149				SCSI_LOG_ERROR_RECOVERY(3,
 150					scmd_printk(KERN_INFO, scmd,
 151						    "eh timeout, not retrying "
 152						    "aborted command\n"));
 153			} else if (!scsi_noretry_cmd(scmd) &&
 154			    (++scmd->retries <= scmd->allowed)) {
 155				SCSI_LOG_ERROR_RECOVERY(3,
 156					scmd_printk(KERN_WARNING, scmd,
 157						    "retry aborted command\n"));
 158				scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
 159				return;
 160			} else {
 161				SCSI_LOG_ERROR_RECOVERY(3,
 162					scmd_printk(KERN_WARNING, scmd,
 163						    "finish aborted command\n"));
 164				scsi_finish_command(scmd);
 165				return;
 166			}
 167		} else {
 168			SCSI_LOG_ERROR_RECOVERY(3,
 169				scmd_printk(KERN_INFO, scmd,
 170					    "cmd abort %s\n",
 171					    (rtn == FAST_IO_FAIL) ?
 172					    "not send" : "failed"));
 173		}
 174	}
 175
 176	scsi_eh_scmd_add(scmd);
 177}
 178
 179/**
 180 * scsi_abort_command - schedule a command abort
 181 * @scmd:	scmd to abort.
 182 *
 183 * We only need to abort commands after a command timeout
 184 */
 185static int
 186scsi_abort_command(struct scsi_cmnd *scmd)
 187{
 188	struct scsi_device *sdev = scmd->device;
 189	struct Scsi_Host *shost = sdev->host;
 190	unsigned long flags;
 191
 192	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
 193		/*
 194		 * Retry after abort failed, escalate to next level.
 195		 */
 196		SCSI_LOG_ERROR_RECOVERY(3,
 197			scmd_printk(KERN_INFO, scmd,
 198				    "previous abort failed\n"));
 199		BUG_ON(delayed_work_pending(&scmd->abort_work));
 200		return FAILED;
 201	}
 202
 203	spin_lock_irqsave(shost->host_lock, flags);
 204	if (shost->eh_deadline != -1 && !shost->last_reset)
 205		shost->last_reset = jiffies;
 206	spin_unlock_irqrestore(shost->host_lock, flags);
 207
 208	scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
 209	SCSI_LOG_ERROR_RECOVERY(3,
 210		scmd_printk(KERN_INFO, scmd, "abort scheduled\n"));
 211	queue_delayed_work(shost->tmf_work_q, &scmd->abort_work, HZ / 100);
 212	return SUCCESS;
 213}
 214
 215/**
 216 * scsi_eh_reset - call into ->eh_action to reset internal counters
 217 * @scmd:	scmd to run eh on.
 218 *
 219 * The scsi driver might be carrying internal state about the
 220 * devices, so we need to call into the driver to reset the
 221 * internal state once the error handler is started.
 222 */
 223static void scsi_eh_reset(struct scsi_cmnd *scmd)
 224{
 225	if (!blk_rq_is_passthrough(scmd->request)) {
 226		struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
 227		if (sdrv->eh_reset)
 228			sdrv->eh_reset(scmd);
 229	}
 230}
 231
 232static void scsi_eh_inc_host_failed(struct rcu_head *head)
 233{
 234	struct scsi_cmnd *scmd = container_of(head, typeof(*scmd), rcu);
 235	struct Scsi_Host *shost = scmd->device->host;
 236	unsigned long flags;
 237
 238	spin_lock_irqsave(shost->host_lock, flags);
 239	shost->host_failed++;
 240	scsi_eh_wakeup(shost);
 241	spin_unlock_irqrestore(shost->host_lock, flags);
 242}
 243
 244/**
 245 * scsi_eh_scmd_add - add scsi cmd to error handling.
 246 * @scmd:	scmd to run eh on.
 247 */
 248void scsi_eh_scmd_add(struct scsi_cmnd *scmd)
 249{
 250	struct Scsi_Host *shost = scmd->device->host;
 251	unsigned long flags;
 252	int ret;
 253
 254	WARN_ON_ONCE(!shost->ehandler);
 255
 256	spin_lock_irqsave(shost->host_lock, flags);
 257	if (scsi_host_set_state(shost, SHOST_RECOVERY)) {
 258		ret = scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY);
 259		WARN_ON_ONCE(ret);
 260	}
 261	if (shost->eh_deadline != -1 && !shost->last_reset)
 262		shost->last_reset = jiffies;
 263
 264	scsi_eh_reset(scmd);
 265	list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
 266	spin_unlock_irqrestore(shost->host_lock, flags);
 267	/*
 268	 * Ensure that all tasks observe the host state change before the
 269	 * host_failed change.
 270	 */
 271	call_rcu(&scmd->rcu, scsi_eh_inc_host_failed);
 272}
 273
 274/**
 275 * scsi_times_out - Timeout function for normal scsi commands.
 276 * @req:	request that is timing out.
 277 *
 278 * Notes:
 279 *     We do not need to lock this.  There is the potential for a race
 280 *     only in that the normal completion handling might run, but if the
 281 *     normal completion function determines that the timer has already
 282 *     fired, then it mustn't do anything.
 283 */
 284enum blk_eh_timer_return scsi_times_out(struct request *req)
 285{
 286	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
 287	enum blk_eh_timer_return rtn = BLK_EH_DONE;
 288	struct Scsi_Host *host = scmd->device->host;
 289
 290	trace_scsi_dispatch_cmd_timeout(scmd);
 291	scsi_log_completion(scmd, TIMEOUT_ERROR);
 292
 293	if (host->eh_deadline != -1 && !host->last_reset)
 294		host->last_reset = jiffies;
 295
 296	if (host->hostt->eh_timed_out)
 297		rtn = host->hostt->eh_timed_out(scmd);
 298
 299	if (rtn == BLK_EH_DONE) {
 300		/*
 301		 * Set the command to complete first in order to prevent a real
 302		 * completion from releasing the command while error handling
 303		 * is using it. If the command was already completed, then the
 304		 * lower level driver beat the timeout handler, and it is safe
 305		 * to return without escalating error recovery.
 306		 *
 307		 * If timeout handling lost the race to a real completion, the
 308		 * block layer may ignore that due to a fake timeout injection,
 309		 * so return RESET_TIMER to allow error handling another shot
 310		 * at this command.
 311		 */
 312		if (test_and_set_bit(SCMD_STATE_COMPLETE, &scmd->state))
 313			return BLK_EH_RESET_TIMER;
 314		if (scsi_abort_command(scmd) != SUCCESS) {
 315			set_host_byte(scmd, DID_TIME_OUT);
 316			scsi_eh_scmd_add(scmd);
 317		}
 318	}
 319
 320	return rtn;
 321}
 322
 323/**
 324 * scsi_block_when_processing_errors - Prevent cmds from being queued.
 325 * @sdev:	Device on which we are performing recovery.
 326 *
 327 * Description:
 328 *     We block until the host is out of error recovery, and then check to
 329 *     see whether the host or the device is offline.
 330 *
 331 * Return value:
 332 *     0 when dev was taken offline by error recovery. 1 OK to proceed.
 333 */
 334int scsi_block_when_processing_errors(struct scsi_device *sdev)
 335{
 336	int online;
 337
 338	wait_event(sdev->host->host_wait, !scsi_host_in_recovery(sdev->host));
 339
 340	online = scsi_device_online(sdev);
 341
 342	return online;
 343}
 344EXPORT_SYMBOL(scsi_block_when_processing_errors);
 345
 346#ifdef CONFIG_SCSI_LOGGING
 347/**
 348 * scsi_eh_prt_fail_stats - Log info on failures.
 349 * @shost:	scsi host being recovered.
 350 * @work_q:	Queue of scsi cmds to process.
 351 */
 352static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
 353					  struct list_head *work_q)
 354{
 355	struct scsi_cmnd *scmd;
 356	struct scsi_device *sdev;
 357	int total_failures = 0;
 358	int cmd_failed = 0;
 359	int cmd_cancel = 0;
 360	int devices_failed = 0;
 361
 362	shost_for_each_device(sdev, shost) {
 363		list_for_each_entry(scmd, work_q, eh_entry) {
 364			if (scmd->device == sdev) {
 365				++total_failures;
 366				if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
 367					++cmd_cancel;
 368				else
 369					++cmd_failed;
 370			}
 371		}
 372
 373		if (cmd_cancel || cmd_failed) {
 374			SCSI_LOG_ERROR_RECOVERY(3,
 375				shost_printk(KERN_INFO, shost,
 376					    "%s: cmds failed: %d, cancel: %d\n",
 377					    __func__, cmd_failed,
 378					    cmd_cancel));
 379			cmd_cancel = 0;
 380			cmd_failed = 0;
 381			++devices_failed;
 382		}
 383	}
 384
 385	SCSI_LOG_ERROR_RECOVERY(2, shost_printk(KERN_INFO, shost,
 386				   "Total of %d commands on %d"
 387				   " devices require eh work\n",
 388				   total_failures, devices_failed));
 389}
 390#endif
 391
 392 /**
 393 * scsi_report_lun_change - Set flag on all *other* devices on the same target
 394 *                          to indicate that a UNIT ATTENTION is expected.
 395 * @sdev:	Device reporting the UNIT ATTENTION
 396 */
 397static void scsi_report_lun_change(struct scsi_device *sdev)
 398{
 399	sdev->sdev_target->expecting_lun_change = 1;
 400}
 401
 402/**
 403 * scsi_report_sense - Examine scsi sense information and log messages for
 404 *		       certain conditions, also issue uevents for some of them.
 405 * @sdev:	Device reporting the sense code
 406 * @sshdr:	sshdr to be examined
 407 */
 408static void scsi_report_sense(struct scsi_device *sdev,
 409			      struct scsi_sense_hdr *sshdr)
 410{
 411	enum scsi_device_event evt_type = SDEV_EVT_MAXBITS;	/* i.e. none */
 412
 413	if (sshdr->sense_key == UNIT_ATTENTION) {
 414		if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
 415			evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
 416			sdev_printk(KERN_WARNING, sdev,
 417				    "Inquiry data has changed");
 418		} else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
 419			evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
 420			scsi_report_lun_change(sdev);
 421			sdev_printk(KERN_WARNING, sdev,
 422				    "Warning! Received an indication that the "
 423				    "LUN assignments on this target have "
 424				    "changed. The Linux SCSI layer does not "
 425				    "automatically remap LUN assignments.\n");
 426		} else if (sshdr->asc == 0x3f)
 427			sdev_printk(KERN_WARNING, sdev,
 428				    "Warning! Received an indication that the "
 429				    "operating parameters on this target have "
 430				    "changed. The Linux SCSI layer does not "
 431				    "automatically adjust these parameters.\n");
 432
 433		if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
 434			evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
 435			sdev_printk(KERN_WARNING, sdev,
 436				    "Warning! Received an indication that the "
 437				    "LUN reached a thin provisioning soft "
 438				    "threshold.\n");
 439		}
 440
 441		if (sshdr->asc == 0x29) {
 442			evt_type = SDEV_EVT_POWER_ON_RESET_OCCURRED;
 443			sdev_printk(KERN_WARNING, sdev,
 444				    "Power-on or device reset occurred\n");
 445		}
 446
 447		if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
 448			evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
 449			sdev_printk(KERN_WARNING, sdev,
 450				    "Mode parameters changed");
 451		} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
 452			evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
 453			sdev_printk(KERN_WARNING, sdev,
 454				    "Asymmetric access state changed");
 455		} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
 456			evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
 457			sdev_printk(KERN_WARNING, sdev,
 458				    "Capacity data has changed");
 459		} else if (sshdr->asc == 0x2a)
 460			sdev_printk(KERN_WARNING, sdev,
 461				    "Parameters changed");
 462	}
 463
 464	if (evt_type != SDEV_EVT_MAXBITS) {
 465		set_bit(evt_type, sdev->pending_events);
 466		schedule_work(&sdev->event_work);
 467	}
 468}
 469
 470/**
 471 * scsi_check_sense - Examine scsi cmd sense
 472 * @scmd:	Cmd to have sense checked.
 473 *
 474 * Return value:
 475 *	SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE
 476 *
 477 * Notes:
 478 *	When a deferred error is detected the current command has
 479 *	not been executed and needs retrying.
 480 */
 481int scsi_check_sense(struct scsi_cmnd *scmd)
 482{
 483	struct scsi_device *sdev = scmd->device;
 484	struct scsi_sense_hdr sshdr;
 485
 486	if (! scsi_command_normalize_sense(scmd, &sshdr))
 487		return FAILED;	/* no valid sense data */
 488
 489	scsi_report_sense(sdev, &sshdr);
 490
 491	if (scsi_sense_is_deferred(&sshdr))
 492		return NEEDS_RETRY;
 493
 494	if (sdev->handler && sdev->handler->check_sense) {
 495		int rc;
 496
 497		rc = sdev->handler->check_sense(sdev, &sshdr);
 498		if (rc != SCSI_RETURN_NOT_HANDLED)
 499			return rc;
 500		/* handler does not care. Drop down to default handling */
 501	}
 502
 503	if (scmd->cmnd[0] == TEST_UNIT_READY && scmd->scsi_done != scsi_eh_done)
 504		/*
 505		 * nasty: for mid-layer issued TURs, we need to return the
 506		 * actual sense data without any recovery attempt.  For eh
 507		 * issued ones, we need to try to recover and interpret
 508		 */
 509		return SUCCESS;
 510
 511	/*
 512	 * Previous logic looked for FILEMARK, EOM or ILI which are
 513	 * mainly associated with tapes and returned SUCCESS.
 514	 */
 515	if (sshdr.response_code == 0x70) {
 516		/* fixed format */
 517		if (scmd->sense_buffer[2] & 0xe0)
 518			return SUCCESS;
 519	} else {
 520		/*
 521		 * descriptor format: look for "stream commands sense data
 522		 * descriptor" (see SSC-3). Assume single sense data
 523		 * descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
 524		 */
 525		if ((sshdr.additional_length > 3) &&
 526		    (scmd->sense_buffer[8] == 0x4) &&
 527		    (scmd->sense_buffer[11] & 0xe0))
 528			return SUCCESS;
 529	}
 530
 531	switch (sshdr.sense_key) {
 532	case NO_SENSE:
 533		return SUCCESS;
 534	case RECOVERED_ERROR:
 535		return /* soft_error */ SUCCESS;
 536
 537	case ABORTED_COMMAND:
 538		if (sshdr.asc == 0x10) /* DIF */
 539			return SUCCESS;
 540
 541		if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF)
 542			return ADD_TO_MLQUEUE;
 543		if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
 544		    sdev->sdev_bflags & BLIST_RETRY_ASC_C1)
 545			return ADD_TO_MLQUEUE;
 546
 547		return NEEDS_RETRY;
 548	case NOT_READY:
 549	case UNIT_ATTENTION:
 550		/*
 551		 * if we are expecting a cc/ua because of a bus reset that we
 552		 * performed, treat this just as a retry.  otherwise this is
 553		 * information that we should pass up to the upper-level driver
 554		 * so that we can deal with it there.
 555		 */
 556		if (scmd->device->expecting_cc_ua) {
 557			/*
 558			 * Because some device does not queue unit
 559			 * attentions correctly, we carefully check
 560			 * additional sense code and qualifier so as
 561			 * not to squash media change unit attention.
 562			 */
 563			if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
 564				scmd->device->expecting_cc_ua = 0;
 565				return NEEDS_RETRY;
 566			}
 567		}
 568		/*
 569		 * we might also expect a cc/ua if another LUN on the target
 570		 * reported a UA with an ASC/ASCQ of 3F 0E -
 571		 * REPORTED LUNS DATA HAS CHANGED.
 572		 */
 573		if (scmd->device->sdev_target->expecting_lun_change &&
 574		    sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
 575			return NEEDS_RETRY;
 576		/*
 577		 * if the device is in the process of becoming ready, we
 578		 * should retry.
 579		 */
 580		if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
 581			return NEEDS_RETRY;
 582		/*
 583		 * if the device is not started, we need to wake
 584		 * the error handler to start the motor
 585		 */
 586		if (scmd->device->allow_restart &&
 587		    (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
 588			return FAILED;
 589		/*
 590		 * Pass the UA upwards for a determination in the completion
 591		 * functions.
 592		 */
 593		return SUCCESS;
 594
 595		/* these are not supported */
 596	case DATA_PROTECT:
 597		if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
 598			/* Thin provisioning hard threshold reached */
 599			set_host_byte(scmd, DID_ALLOC_FAILURE);
 600			return SUCCESS;
 601		}
 602		/* FALLTHROUGH */
 603	case COPY_ABORTED:
 604	case VOLUME_OVERFLOW:
 605	case MISCOMPARE:
 606	case BLANK_CHECK:
 607		set_host_byte(scmd, DID_TARGET_FAILURE);
 608		return SUCCESS;
 609
 610	case MEDIUM_ERROR:
 611		if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
 612		    sshdr.asc == 0x13 || /* AMNF DATA FIELD */
 613		    sshdr.asc == 0x14) { /* RECORD NOT FOUND */
 614			set_host_byte(scmd, DID_MEDIUM_ERROR);
 615			return SUCCESS;
 616		}
 617		return NEEDS_RETRY;
 618
 619	case HARDWARE_ERROR:
 620		if (scmd->device->retry_hwerror)
 621			return ADD_TO_MLQUEUE;
 622		else
 623			set_host_byte(scmd, DID_TARGET_FAILURE);
 624		/* FALLTHROUGH */
 625
 626	case ILLEGAL_REQUEST:
 627		if (sshdr.asc == 0x20 || /* Invalid command operation code */
 628		    sshdr.asc == 0x21 || /* Logical block address out of range */
 629		    sshdr.asc == 0x22 || /* Invalid function */
 630		    sshdr.asc == 0x24 || /* Invalid field in cdb */
 631		    sshdr.asc == 0x26 || /* Parameter value invalid */
 632		    sshdr.asc == 0x27) { /* Write protected */
 633			set_host_byte(scmd, DID_TARGET_FAILURE);
 634		}
 635		return SUCCESS;
 636
 637	default:
 638		return SUCCESS;
 639	}
 640}
 641EXPORT_SYMBOL_GPL(scsi_check_sense);
 642
 643static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
 644{
 645	struct scsi_host_template *sht = sdev->host->hostt;
 646	struct scsi_device *tmp_sdev;
 647
 648	if (!sht->track_queue_depth ||
 649	    sdev->queue_depth >= sdev->max_queue_depth)
 650		return;
 651
 652	if (time_before(jiffies,
 653	    sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
 654		return;
 655
 656	if (time_before(jiffies,
 657	    sdev->last_queue_full_time + sdev->queue_ramp_up_period))
 658		return;
 659
 660	/*
 661	 * Walk all devices of a target and do
 662	 * ramp up on them.
 663	 */
 664	shost_for_each_device(tmp_sdev, sdev->host) {
 665		if (tmp_sdev->channel != sdev->channel ||
 666		    tmp_sdev->id != sdev->id ||
 667		    tmp_sdev->queue_depth == sdev->max_queue_depth)
 668			continue;
 669
 670		scsi_change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1);
 671		sdev->last_queue_ramp_up = jiffies;
 672	}
 673}
 674
 675static void scsi_handle_queue_full(struct scsi_device *sdev)
 676{
 677	struct scsi_host_template *sht = sdev->host->hostt;
 678	struct scsi_device *tmp_sdev;
 679
 680	if (!sht->track_queue_depth)
 681		return;
 682
 683	shost_for_each_device(tmp_sdev, sdev->host) {
 684		if (tmp_sdev->channel != sdev->channel ||
 685		    tmp_sdev->id != sdev->id)
 686			continue;
 687		/*
 688		 * We do not know the number of commands that were at
 689		 * the device when we got the queue full so we start
 690		 * from the highest possible value and work our way down.
 691		 */
 692		scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
 693	}
 694}
 695
 696/**
 697 * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
 698 * @scmd:	SCSI cmd to examine.
 699 *
 700 * Notes:
 701 *    This is *only* called when we are examining the status of commands
 702 *    queued during error recovery.  the main difference here is that we
 703 *    don't allow for the possibility of retries here, and we are a lot
 704 *    more restrictive about what we consider acceptable.
 705 */
 706static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
 707{
 708	/*
 709	 * first check the host byte, to see if there is anything in there
 710	 * that would indicate what we need to do.
 711	 */
 712	if (host_byte(scmd->result) == DID_RESET) {
 713		/*
 714		 * rats.  we are already in the error handler, so we now
 715		 * get to try and figure out what to do next.  if the sense
 716		 * is valid, we have a pretty good idea of what to do.
 717		 * if not, we mark it as FAILED.
 718		 */
 719		return scsi_check_sense(scmd);
 720	}
 721	if (host_byte(scmd->result) != DID_OK)
 722		return FAILED;
 723
 724	/*
 725	 * next, check the message byte.
 726	 */
 727	if (msg_byte(scmd->result) != COMMAND_COMPLETE)
 728		return FAILED;
 729
 730	/*
 731	 * now, check the status byte to see if this indicates
 732	 * anything special.
 733	 */
 734	switch (status_byte(scmd->result)) {
 735	case GOOD:
 736		scsi_handle_queue_ramp_up(scmd->device);
 737		/* FALLTHROUGH */
 738	case COMMAND_TERMINATED:
 739		return SUCCESS;
 740	case CHECK_CONDITION:
 741		return scsi_check_sense(scmd);
 742	case CONDITION_GOOD:
 743	case INTERMEDIATE_GOOD:
 744	case INTERMEDIATE_C_GOOD:
 745		/*
 746		 * who knows?  FIXME(eric)
 747		 */
 748		return SUCCESS;
 749	case RESERVATION_CONFLICT:
 750		if (scmd->cmnd[0] == TEST_UNIT_READY)
 751			/* it is a success, we probed the device and
 752			 * found it */
 753			return SUCCESS;
 754		/* otherwise, we failed to send the command */
 755		return FAILED;
 756	case QUEUE_FULL:
 757		scsi_handle_queue_full(scmd->device);
 758		/* fall through */
 759	case BUSY:
 760		return NEEDS_RETRY;
 761	default:
 762		return FAILED;
 763	}
 764	return FAILED;
 765}
 766
 767/**
 768 * scsi_eh_done - Completion function for error handling.
 769 * @scmd:	Cmd that is done.
 770 */
 771static void scsi_eh_done(struct scsi_cmnd *scmd)
 772{
 773	struct completion *eh_action;
 774
 775	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
 776			"%s result: %x\n", __func__, scmd->result));
 777
 778	eh_action = scmd->device->host->eh_action;
 779	if (eh_action)
 780		complete(eh_action);
 781}
 782
 783/**
 784 * scsi_try_host_reset - ask host adapter to reset itself
 785 * @scmd:	SCSI cmd to send host reset.
 786 */
 787static int scsi_try_host_reset(struct scsi_cmnd *scmd)
 788{
 789	unsigned long flags;
 790	int rtn;
 791	struct Scsi_Host *host = scmd->device->host;
 792	struct scsi_host_template *hostt = host->hostt;
 793
 794	SCSI_LOG_ERROR_RECOVERY(3,
 795		shost_printk(KERN_INFO, host, "Snd Host RST\n"));
 796
 797	if (!hostt->eh_host_reset_handler)
 798		return FAILED;
 799
 800	rtn = hostt->eh_host_reset_handler(scmd);
 801
 802	if (rtn == SUCCESS) {
 803		if (!hostt->skip_settle_delay)
 804			ssleep(HOST_RESET_SETTLE_TIME);
 805		spin_lock_irqsave(host->host_lock, flags);
 806		scsi_report_bus_reset(host, scmd_channel(scmd));
 807		spin_unlock_irqrestore(host->host_lock, flags);
 808	}
 809
 810	return rtn;
 811}
 812
 813/**
 814 * scsi_try_bus_reset - ask host to perform a bus reset
 815 * @scmd:	SCSI cmd to send bus reset.
 816 */
 817static int scsi_try_bus_reset(struct scsi_cmnd *scmd)
 818{
 819	unsigned long flags;
 820	int rtn;
 821	struct Scsi_Host *host = scmd->device->host;
 822	struct scsi_host_template *hostt = host->hostt;
 823
 824	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
 825		"%s: Snd Bus RST\n", __func__));
 826
 827	if (!hostt->eh_bus_reset_handler)
 828		return FAILED;
 829
 830	rtn = hostt->eh_bus_reset_handler(scmd);
 831
 832	if (rtn == SUCCESS) {
 833		if (!hostt->skip_settle_delay)
 834			ssleep(BUS_RESET_SETTLE_TIME);
 835		spin_lock_irqsave(host->host_lock, flags);
 836		scsi_report_bus_reset(host, scmd_channel(scmd));
 837		spin_unlock_irqrestore(host->host_lock, flags);
 838	}
 839
 840	return rtn;
 841}
 842
 843static void __scsi_report_device_reset(struct scsi_device *sdev, void *data)
 844{
 845	sdev->was_reset = 1;
 846	sdev->expecting_cc_ua = 1;
 847}
 848
 849/**
 850 * scsi_try_target_reset - Ask host to perform a target reset
 851 * @scmd:	SCSI cmd used to send a target reset
 852 *
 853 * Notes:
 854 *    There is no timeout for this operation.  if this operation is
 855 *    unreliable for a given host, then the host itself needs to put a
 856 *    timer on it, and set the host back to a consistent state prior to
 857 *    returning.
 858 */
 859static int scsi_try_target_reset(struct scsi_cmnd *scmd)
 860{
 861	unsigned long flags;
 862	int rtn;
 863	struct Scsi_Host *host = scmd->device->host;
 864	struct scsi_host_template *hostt = host->hostt;
 865
 866	if (!hostt->eh_target_reset_handler)
 867		return FAILED;
 868
 869	rtn = hostt->eh_target_reset_handler(scmd);
 870	if (rtn == SUCCESS) {
 871		spin_lock_irqsave(host->host_lock, flags);
 872		__starget_for_each_device(scsi_target(scmd->device), NULL,
 873					  __scsi_report_device_reset);
 874		spin_unlock_irqrestore(host->host_lock, flags);
 875	}
 876
 877	return rtn;
 878}
 879
 880/**
 881 * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
 882 * @scmd:	SCSI cmd used to send BDR
 883 *
 884 * Notes:
 885 *    There is no timeout for this operation.  if this operation is
 886 *    unreliable for a given host, then the host itself needs to put a
 887 *    timer on it, and set the host back to a consistent state prior to
 888 *    returning.
 889 */
 890static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
 891{
 892	int rtn;
 893	struct scsi_host_template *hostt = scmd->device->host->hostt;
 894
 895	if (!hostt->eh_device_reset_handler)
 896		return FAILED;
 897
 898	rtn = hostt->eh_device_reset_handler(scmd);
 899	if (rtn == SUCCESS)
 900		__scsi_report_device_reset(scmd->device, NULL);
 901	return rtn;
 902}
 903
 904/**
 905 * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
 906 * @hostt:	SCSI driver host template
 907 * @scmd:	SCSI cmd used to send a target reset
 908 *
 909 * Return value:
 910 *	SUCCESS, FAILED, or FAST_IO_FAIL
 911 *
 912 * Notes:
 913 *    SUCCESS does not necessarily indicate that the command
 914 *    has been aborted; it only indicates that the LLDDs
 915 *    has cleared all references to that command.
 916 *    LLDDs should return FAILED only if an abort was required
 917 *    but could not be executed. LLDDs should return FAST_IO_FAIL
 918 *    if the device is temporarily unavailable (eg due to a
 919 *    link down on FibreChannel)
 920 */
 921static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt,
 922				 struct scsi_cmnd *scmd)
 923{
 924	if (!hostt->eh_abort_handler)
 925		return FAILED;
 926
 927	return hostt->eh_abort_handler(scmd);
 928}
 929
 930static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)
 931{
 932	if (scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd) != SUCCESS)
 933		if (scsi_try_bus_device_reset(scmd) != SUCCESS)
 934			if (scsi_try_target_reset(scmd) != SUCCESS)
 935				if (scsi_try_bus_reset(scmd) != SUCCESS)
 936					scsi_try_host_reset(scmd);
 937}
 938
 939/**
 940 * scsi_eh_prep_cmnd  - Save a scsi command info as part of error recovery
 941 * @scmd:       SCSI command structure to hijack
 942 * @ses:        structure to save restore information
 943 * @cmnd:       CDB to send. Can be NULL if no new cmnd is needed
 944 * @cmnd_size:  size in bytes of @cmnd (must be <= BLK_MAX_CDB)
 945 * @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
 946 *
 947 * This function is used to save a scsi command information before re-execution
 948 * as part of the error recovery process.  If @sense_bytes is 0 the command
 949 * sent must be one that does not transfer any data.  If @sense_bytes != 0
 950 * @cmnd is ignored and this functions sets up a REQUEST_SENSE command
 951 * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
 952 */
 953void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses,
 954			unsigned char *cmnd, int cmnd_size, unsigned sense_bytes)
 955{
 956	struct scsi_device *sdev = scmd->device;
 957
 958	/*
 959	 * We need saved copies of a number of fields - this is because
 960	 * error handling may need to overwrite these with different values
 961	 * to run different commands, and once error handling is complete,
 962	 * we will need to restore these values prior to running the actual
 963	 * command.
 964	 */
 965	ses->cmd_len = scmd->cmd_len;
 966	ses->cmnd = scmd->cmnd;
 967	ses->data_direction = scmd->sc_data_direction;
 968	ses->sdb = scmd->sdb;
 969	ses->result = scmd->result;
 970	ses->resid_len = scmd->req.resid_len;
 971	ses->underflow = scmd->underflow;
 972	ses->prot_op = scmd->prot_op;
 973	ses->eh_eflags = scmd->eh_eflags;
 974
 975	scmd->prot_op = SCSI_PROT_NORMAL;
 976	scmd->eh_eflags = 0;
 977	scmd->cmnd = ses->eh_cmnd;
 978	memset(scmd->cmnd, 0, BLK_MAX_CDB);
 979	memset(&scmd->sdb, 0, sizeof(scmd->sdb));
 980	scmd->result = 0;
 981	scmd->req.resid_len = 0;
 982
 983	if (sense_bytes) {
 984		scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
 985					 sense_bytes);
 986		sg_init_one(&ses->sense_sgl, scmd->sense_buffer,
 987			    scmd->sdb.length);
 988		scmd->sdb.table.sgl = &ses->sense_sgl;
 989		scmd->sc_data_direction = DMA_FROM_DEVICE;
 990		scmd->sdb.table.nents = scmd->sdb.table.orig_nents = 1;
 991		scmd->cmnd[0] = REQUEST_SENSE;
 992		scmd->cmnd[4] = scmd->sdb.length;
 993		scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
 994	} else {
 995		scmd->sc_data_direction = DMA_NONE;
 996		if (cmnd) {
 997			BUG_ON(cmnd_size > BLK_MAX_CDB);
 998			memcpy(scmd->cmnd, cmnd, cmnd_size);
 999			scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
1000		}
1001	}
1002
1003	scmd->underflow = 0;
1004
1005	if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN)
1006		scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
1007			(sdev->lun << 5 & 0xe0);
1008
1009	/*
1010	 * Zero the sense buffer.  The scsi spec mandates that any
1011	 * untransferred sense data should be interpreted as being zero.
1012	 */
1013	memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1014}
1015EXPORT_SYMBOL(scsi_eh_prep_cmnd);
1016
1017/**
1018 * scsi_eh_restore_cmnd  - Restore a scsi command info as part of error recovery
1019 * @scmd:       SCSI command structure to restore
1020 * @ses:        saved information from a coresponding call to scsi_eh_prep_cmnd
1021 *
1022 * Undo any damage done by above scsi_eh_prep_cmnd().
1023 */
1024void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)
1025{
1026	/*
1027	 * Restore original data
1028	 */
1029	scmd->cmd_len = ses->cmd_len;
1030	scmd->cmnd = ses->cmnd;
1031	scmd->sc_data_direction = ses->data_direction;
1032	scmd->sdb = ses->sdb;
1033	scmd->result = ses->result;
1034	scmd->req.resid_len = ses->resid_len;
1035	scmd->underflow = ses->underflow;
1036	scmd->prot_op = ses->prot_op;
1037	scmd->eh_eflags = ses->eh_eflags;
1038}
1039EXPORT_SYMBOL(scsi_eh_restore_cmnd);
1040
1041/**
1042 * scsi_send_eh_cmnd  - submit a scsi command as part of error recovery
1043 * @scmd:       SCSI command structure to hijack
1044 * @cmnd:       CDB to send
1045 * @cmnd_size:  size in bytes of @cmnd
1046 * @timeout:    timeout for this request
1047 * @sense_bytes: size of sense data to copy or 0
1048 *
1049 * This function is used to send a scsi command down to a target device
1050 * as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
1051 *
1052 * Return value:
1053 *    SUCCESS or FAILED or NEEDS_RETRY
1054 */
1055static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
1056			     int cmnd_size, int timeout, unsigned sense_bytes)
1057{
1058	struct scsi_device *sdev = scmd->device;
1059	struct Scsi_Host *shost = sdev->host;
1060	DECLARE_COMPLETION_ONSTACK(done);
1061	unsigned long timeleft = timeout, delay;
1062	struct scsi_eh_save ses;
1063	const unsigned long stall_for = msecs_to_jiffies(100);
1064	int rtn;
1065
1066retry:
1067	scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
1068	shost->eh_action = &done;
1069
1070	scsi_log_send(scmd);
1071	scmd->scsi_done = scsi_eh_done;
1072
1073	/*
1074	 * Lock sdev->state_mutex to avoid that scsi_device_quiesce() can
1075	 * change the SCSI device state after we have examined it and before
1076	 * .queuecommand() is called.
1077	 */
1078	mutex_lock(&sdev->state_mutex);
1079	while (sdev->sdev_state == SDEV_BLOCK && timeleft > 0) {
1080		mutex_unlock(&sdev->state_mutex);
1081		SCSI_LOG_ERROR_RECOVERY(5, sdev_printk(KERN_DEBUG, sdev,
1082			"%s: state %d <> %d\n", __func__, sdev->sdev_state,
1083			SDEV_BLOCK));
1084		delay = min(timeleft, stall_for);
1085		timeleft -= delay;
1086		msleep(jiffies_to_msecs(delay));
1087		mutex_lock(&sdev->state_mutex);
1088	}
1089	if (sdev->sdev_state != SDEV_BLOCK)
1090		rtn = shost->hostt->queuecommand(shost, scmd);
1091	else
1092		rtn = SCSI_MLQUEUE_DEVICE_BUSY;
1093	mutex_unlock(&sdev->state_mutex);
1094
1095	if (rtn) {
1096		if (timeleft > stall_for) {
1097			scsi_eh_restore_cmnd(scmd, &ses);
1098			timeleft -= stall_for;
1099			msleep(jiffies_to_msecs(stall_for));
1100			goto retry;
1101		}
1102		/* signal not to enter either branch of the if () below */
1103		timeleft = 0;
1104		rtn = FAILED;
1105	} else {
1106		timeleft = wait_for_completion_timeout(&done, timeout);
1107		rtn = SUCCESS;
1108	}
1109
1110	shost->eh_action = NULL;
1111
1112	scsi_log_completion(scmd, rtn);
1113
1114	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1115			"%s timeleft: %ld\n",
1116			__func__, timeleft));
1117
1118	/*
1119	 * If there is time left scsi_eh_done got called, and we will examine
1120	 * the actual status codes to see whether the command actually did
1121	 * complete normally, else if we have a zero return and no time left,
1122	 * the command must still be pending, so abort it and return FAILED.
1123	 * If we never actually managed to issue the command, because
1124	 * ->queuecommand() kept returning non zero, use the rtn = FAILED
1125	 * value above (so don't execute either branch of the if)
1126	 */
1127	if (timeleft) {
1128		rtn = scsi_eh_completed_normally(scmd);
1129		SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1130			"%s: scsi_eh_completed_normally %x\n", __func__, rtn));
1131
1132		switch (rtn) {
1133		case SUCCESS:
1134		case NEEDS_RETRY:
1135		case FAILED:
1136			break;
1137		case ADD_TO_MLQUEUE:
1138			rtn = NEEDS_RETRY;
1139			break;
1140		default:
1141			rtn = FAILED;
1142			break;
1143		}
1144	} else if (rtn != FAILED) {
1145		scsi_abort_eh_cmnd(scmd);
1146		rtn = FAILED;
1147	}
1148
1149	scsi_eh_restore_cmnd(scmd, &ses);
1150
1151	return rtn;
1152}
1153
1154/**
1155 * scsi_request_sense - Request sense data from a particular target.
1156 * @scmd:	SCSI cmd for request sense.
1157 *
1158 * Notes:
1159 *    Some hosts automatically obtain this information, others require
1160 *    that we obtain it on our own. This function will *not* return until
1161 *    the command either times out, or it completes.
1162 */
1163static int scsi_request_sense(struct scsi_cmnd *scmd)
1164{
1165	return scsi_send_eh_cmnd(scmd, NULL, 0, scmd->device->eh_timeout, ~0);
1166}
1167
1168static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)
1169{
1170	if (!blk_rq_is_passthrough(scmd->request)) {
1171		struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
1172		if (sdrv->eh_action)
1173			rtn = sdrv->eh_action(scmd, rtn);
1174	}
1175	return rtn;
1176}
1177
1178/**
1179 * scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
1180 * @scmd:	Original SCSI cmd that eh has finished.
1181 * @done_q:	Queue for processed commands.
1182 *
1183 * Notes:
1184 *    We don't want to use the normal command completion while we are are
1185 *    still handling errors - it may cause other commands to be queued,
1186 *    and that would disturb what we are doing.  Thus we really want to
1187 *    keep a list of pending commands for final completion, and once we
1188 *    are ready to leave error handling we handle completion for real.
1189 */
1190void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
1191{
1192	list_move_tail(&scmd->eh_entry, done_q);
1193}
1194EXPORT_SYMBOL(scsi_eh_finish_cmd);
1195
1196/**
1197 * scsi_eh_get_sense - Get device sense data.
1198 * @work_q:	Queue of commands to process.
1199 * @done_q:	Queue of processed commands.
1200 *
1201 * Description:
1202 *    See if we need to request sense information.  if so, then get it
1203 *    now, so we have a better idea of what to do.
1204 *
1205 * Notes:
1206 *    This has the unfortunate side effect that if a shost adapter does
1207 *    not automatically request sense information, we end up shutting
1208 *    it down before we request it.
1209 *
1210 *    All drivers should request sense information internally these days,
1211 *    so for now all I have to say is tough noogies if you end up in here.
1212 *
1213 *    XXX: Long term this code should go away, but that needs an audit of
1214 *         all LLDDs first.
1215 */
1216int scsi_eh_get_sense(struct list_head *work_q,
1217		      struct list_head *done_q)
1218{
1219	struct scsi_cmnd *scmd, *next;
1220	struct Scsi_Host *shost;
1221	int rtn;
1222
1223	/*
1224	 * If SCSI_EH_ABORT_SCHEDULED has been set, it is timeout IO,
1225	 * should not get sense.
1226	 */
1227	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1228		if ((scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) ||
1229		    SCSI_SENSE_VALID(scmd))
1230			continue;
1231
1232		shost = scmd->device->host;
1233		if (scsi_host_eh_past_deadline(shost)) {
1234			SCSI_LOG_ERROR_RECOVERY(3,
1235				scmd_printk(KERN_INFO, scmd,
1236					    "%s: skip request sense, past eh deadline\n",
1237					     current->comm));
1238			break;
1239		}
1240		if (status_byte(scmd->result) != CHECK_CONDITION)
1241			/*
1242			 * don't request sense if there's no check condition
1243			 * status because the error we're processing isn't one
1244			 * that has a sense code (and some devices get
1245			 * confused by sense requests out of the blue)
1246			 */
1247			continue;
1248
1249		SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
1250						  "%s: requesting sense\n",
1251						  current->comm));
1252		rtn = scsi_request_sense(scmd);
1253		if (rtn != SUCCESS)
1254			continue;
1255
1256		SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1257			"sense requested, result %x\n", scmd->result));
1258		SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
1259
1260		rtn = scsi_decide_disposition(scmd);
1261
1262		/*
1263		 * if the result was normal, then just pass it along to the
1264		 * upper level.
1265		 */
1266		if (rtn == SUCCESS)
1267			/* we don't want this command reissued, just
1268			 * finished with the sense data, so set
1269			 * retries to the max allowed to ensure it
1270			 * won't get reissued */
1271			scmd->retries = scmd->allowed;
1272		else if (rtn != NEEDS_RETRY)
1273			continue;
1274
1275		scsi_eh_finish_cmd(scmd, done_q);
1276	}
1277
1278	return list_empty(work_q);
1279}
1280EXPORT_SYMBOL_GPL(scsi_eh_get_sense);
1281
1282/**
1283 * scsi_eh_tur - Send TUR to device.
1284 * @scmd:	&scsi_cmnd to send TUR
1285 *
1286 * Return value:
1287 *    0 - Device is ready. 1 - Device NOT ready.
1288 */
1289static int scsi_eh_tur(struct scsi_cmnd *scmd)
1290{
1291	static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
1292	int retry_cnt = 1, rtn;
1293
1294retry_tur:
1295	rtn = scsi_send_eh_cmnd(scmd, tur_command, 6,
1296				scmd->device->eh_timeout, 0);
1297
1298	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1299		"%s return: %x\n", __func__, rtn));
1300
1301	switch (rtn) {
1302	case NEEDS_RETRY:
1303		if (retry_cnt--)
1304			goto retry_tur;
1305		/*FALLTHRU*/
1306	case SUCCESS:
1307		return 0;
1308	default:
1309		return 1;
1310	}
1311}
1312
1313/**
1314 * scsi_eh_test_devices - check if devices are responding from error recovery.
1315 * @cmd_list:	scsi commands in error recovery.
1316 * @work_q:	queue for commands which still need more error recovery
1317 * @done_q:	queue for commands which are finished
1318 * @try_stu:	boolean on if a STU command should be tried in addition to TUR.
1319 *
1320 * Decription:
1321 *    Tests if devices are in a working state.  Commands to devices now in
1322 *    a working state are sent to the done_q while commands to devices which
1323 *    are still failing to respond are returned to the work_q for more
1324 *    processing.
1325 **/
1326static int scsi_eh_test_devices(struct list_head *cmd_list,
1327				struct list_head *work_q,
1328				struct list_head *done_q, int try_stu)
1329{
1330	struct scsi_cmnd *scmd, *next;
1331	struct scsi_device *sdev;
1332	int finish_cmds;
1333
1334	while (!list_empty(cmd_list)) {
1335		scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
1336		sdev = scmd->device;
1337
1338		if (!try_stu) {
1339			if (scsi_host_eh_past_deadline(sdev->host)) {
1340				/* Push items back onto work_q */
1341				list_splice_init(cmd_list, work_q);
1342				SCSI_LOG_ERROR_RECOVERY(3,
1343					sdev_printk(KERN_INFO, sdev,
1344						    "%s: skip test device, past eh deadline",
1345						    current->comm));
1346				break;
1347			}
1348		}
1349
1350		finish_cmds = !scsi_device_online(scmd->device) ||
1351			(try_stu && !scsi_eh_try_stu(scmd) &&
1352			 !scsi_eh_tur(scmd)) ||
1353			!scsi_eh_tur(scmd);
1354
1355		list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
1356			if (scmd->device == sdev) {
1357				if (finish_cmds &&
1358				    (try_stu ||
1359				     scsi_eh_action(scmd, SUCCESS) == SUCCESS))
1360					scsi_eh_finish_cmd(scmd, done_q);
1361				else
1362					list_move_tail(&scmd->eh_entry, work_q);
1363			}
1364	}
1365	return list_empty(work_q);
1366}
1367
1368/**
1369 * scsi_eh_try_stu - Send START_UNIT to device.
1370 * @scmd:	&scsi_cmnd to send START_UNIT
1371 *
1372 * Return value:
1373 *    0 - Device is ready. 1 - Device NOT ready.
1374 */
1375static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
1376{
1377	static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0};
1378
1379	if (scmd->device->allow_restart) {
1380		int i, rtn = NEEDS_RETRY;
1381
1382		for (i = 0; rtn == NEEDS_RETRY && i < 2; i++)
1383			rtn = scsi_send_eh_cmnd(scmd, stu_command, 6, scmd->device->request_queue->rq_timeout, 0);
1384
1385		if (rtn == SUCCESS)
1386			return 0;
1387	}
1388
1389	return 1;
1390}
1391
1392 /**
1393 * scsi_eh_stu - send START_UNIT if needed
1394 * @shost:	&scsi host being recovered.
1395 * @work_q:	&list_head for pending commands.
1396 * @done_q:	&list_head for processed commands.
1397 *
1398 * Notes:
1399 *    If commands are failing due to not ready, initializing command required,
1400 *	try revalidating the device, which will end up sending a start unit.
1401 */
1402static int scsi_eh_stu(struct Scsi_Host *shost,
1403			      struct list_head *work_q,
1404			      struct list_head *done_q)
1405{
1406	struct scsi_cmnd *scmd, *stu_scmd, *next;
1407	struct scsi_device *sdev;
1408
1409	shost_for_each_device(sdev, shost) {
1410		if (scsi_host_eh_past_deadline(shost)) {
1411			SCSI_LOG_ERROR_RECOVERY(3,
1412				sdev_printk(KERN_INFO, sdev,
1413					    "%s: skip START_UNIT, past eh deadline\n",
1414					    current->comm));
1415			break;
1416		}
1417		stu_scmd = NULL;
1418		list_for_each_entry(scmd, work_q, eh_entry)
1419			if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
1420			    scsi_check_sense(scmd) == FAILED ) {
1421				stu_scmd = scmd;
1422				break;
1423			}
1424
1425		if (!stu_scmd)
1426			continue;
1427
1428		SCSI_LOG_ERROR_RECOVERY(3,
1429			sdev_printk(KERN_INFO, sdev,
1430				     "%s: Sending START_UNIT\n",
1431				    current->comm));
1432
1433		if (!scsi_eh_try_stu(stu_scmd)) {
1434			if (!scsi_device_online(sdev) ||
1435			    !scsi_eh_tur(stu_scmd)) {
1436				list_for_each_entry_safe(scmd, next,
1437							  work_q, eh_entry) {
1438					if (scmd->device == sdev &&
1439					    scsi_eh_action(scmd, SUCCESS) == SUCCESS)
1440						scsi_eh_finish_cmd(scmd, done_q);
1441				}
1442			}
1443		} else {
1444			SCSI_LOG_ERROR_RECOVERY(3,
1445				sdev_printk(KERN_INFO, sdev,
1446					    "%s: START_UNIT failed\n",
1447					    current->comm));
1448		}
1449	}
1450
1451	return list_empty(work_q);
1452}
1453
1454
1455/**
1456 * scsi_eh_bus_device_reset - send bdr if needed
1457 * @shost:	scsi host being recovered.
1458 * @work_q:	&list_head for pending commands.
1459 * @done_q:	&list_head for processed commands.
1460 *
1461 * Notes:
1462 *    Try a bus device reset.  Still, look to see whether we have multiple
1463 *    devices that are jammed or not - if we have multiple devices, it
1464 *    makes no sense to try bus_device_reset - we really would need to try
1465 *    a bus_reset instead.
1466 */
1467static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
1468				    struct list_head *work_q,
1469				    struct list_head *done_q)
1470{
1471	struct scsi_cmnd *scmd, *bdr_scmd, *next;
1472	struct scsi_device *sdev;
1473	int rtn;
1474
1475	shost_for_each_device(sdev, shost) {
1476		if (scsi_host_eh_past_deadline(shost)) {
1477			SCSI_LOG_ERROR_RECOVERY(3,
1478				sdev_printk(KERN_INFO, sdev,
1479					    "%s: skip BDR, past eh deadline\n",
1480					     current->comm));
1481			break;
1482		}
1483		bdr_scmd = NULL;
1484		list_for_each_entry(scmd, work_q, eh_entry)
1485			if (scmd->device == sdev) {
1486				bdr_scmd = scmd;
1487				break;
1488			}
1489
1490		if (!bdr_scmd)
1491			continue;
1492
1493		SCSI_LOG_ERROR_RECOVERY(3,
1494			sdev_printk(KERN_INFO, sdev,
1495				     "%s: Sending BDR\n", current->comm));
1496		rtn = scsi_try_bus_device_reset(bdr_scmd);
1497		if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
1498			if (!scsi_device_online(sdev) ||
1499			    rtn == FAST_IO_FAIL ||
1500			    !scsi_eh_tur(bdr_scmd)) {
1501				list_for_each_entry_safe(scmd, next,
1502							 work_q, eh_entry) {
1503					if (scmd->device == sdev &&
1504					    scsi_eh_action(scmd, rtn) != FAILED)
1505						scsi_eh_finish_cmd(scmd,
1506								   done_q);
1507				}
1508			}
1509		} else {
1510			SCSI_LOG_ERROR_RECOVERY(3,
1511				sdev_printk(KERN_INFO, sdev,
1512					    "%s: BDR failed\n", current->comm));
1513		}
1514	}
1515
1516	return list_empty(work_q);
1517}
1518
1519/**
1520 * scsi_eh_target_reset - send target reset if needed
1521 * @shost:	scsi host being recovered.
1522 * @work_q:	&list_head for pending commands.
1523 * @done_q:	&list_head for processed commands.
1524 *
1525 * Notes:
1526 *    Try a target reset.
1527 */
1528static int scsi_eh_target_reset(struct Scsi_Host *shost,
1529				struct list_head *work_q,
1530				struct list_head *done_q)
1531{
1532	LIST_HEAD(tmp_list);
1533	LIST_HEAD(check_list);
1534
1535	list_splice_init(work_q, &tmp_list);
1536
1537	while (!list_empty(&tmp_list)) {
1538		struct scsi_cmnd *next, *scmd;
1539		int rtn;
1540		unsigned int id;
1541
1542		if (scsi_host_eh_past_deadline(shost)) {
1543			/* push back on work queue for further processing */
1544			list_splice_init(&check_list, work_q);
1545			list_splice_init(&tmp_list, work_q);
1546			SCSI_LOG_ERROR_RECOVERY(3,
1547				shost_printk(KERN_INFO, shost,
1548					    "%s: Skip target reset, past eh deadline\n",
1549					     current->comm));
1550			return list_empty(work_q);
1551		}
1552
1553		scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
1554		id = scmd_id(scmd);
1555
1556		SCSI_LOG_ERROR_RECOVERY(3,
1557			shost_printk(KERN_INFO, shost,
1558				     "%s: Sending target reset to target %d\n",
1559				     current->comm, id));
1560		rtn = scsi_try_target_reset(scmd);
1561		if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
1562			SCSI_LOG_ERROR_RECOVERY(3,
1563				shost_printk(KERN_INFO, shost,
1564					     "%s: Target reset failed"
1565					     " target: %d\n",
1566					     current->comm, id));
1567		list_for_each_entry_safe(scmd, next, &tmp_list, eh_entry) {
1568			if (scmd_id(scmd) != id)
1569				continue;
1570
1571			if (rtn == SUCCESS)
1572				list_move_tail(&scmd->eh_entry, &check_list);
1573			else if (rtn == FAST_IO_FAIL)
1574				scsi_eh_finish_cmd(scmd, done_q);
1575			else
1576				/* push back on work queue for further processing */
1577				list_move(&scmd->eh_entry, work_q);
1578		}
1579	}
1580
1581	return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
1582}
1583
1584/**
1585 * scsi_eh_bus_reset - send a bus reset
1586 * @shost:	&scsi host being recovered.
1587 * @work_q:	&list_head for pending commands.
1588 * @done_q:	&list_head for processed commands.
1589 */
1590static int scsi_eh_bus_reset(struct Scsi_Host *shost,
1591			     struct list_head *work_q,
1592			     struct list_head *done_q)
1593{
1594	struct scsi_cmnd *scmd, *chan_scmd, *next;
1595	LIST_HEAD(check_list);
1596	unsigned int channel;
1597	int rtn;
1598
1599	/*
1600	 * we really want to loop over the various channels, and do this on
1601	 * a channel by channel basis.  we should also check to see if any
1602	 * of the failed commands are on soft_reset devices, and if so, skip
1603	 * the reset.
1604	 */
1605
1606	for (channel = 0; channel <= shost->max_channel; channel++) {
1607		if (scsi_host_eh_past_deadline(shost)) {
1608			list_splice_init(&check_list, work_q);
1609			SCSI_LOG_ERROR_RECOVERY(3,
1610				shost_printk(KERN_INFO, shost,
1611					    "%s: skip BRST, past eh deadline\n",
1612					     current->comm));
1613			return list_empty(work_q);
1614		}
1615
1616		chan_scmd = NULL;
1617		list_for_each_entry(scmd, work_q, eh_entry) {
1618			if (channel == scmd_channel(scmd)) {
1619				chan_scmd = scmd;
1620				break;
1621				/*
1622				 * FIXME add back in some support for
1623				 * soft_reset devices.
1624				 */
1625			}
1626		}
1627
1628		if (!chan_scmd)
1629			continue;
1630		SCSI_LOG_ERROR_RECOVERY(3,
1631			shost_printk(KERN_INFO, shost,
1632				     "%s: Sending BRST chan: %d\n",
1633				     current->comm, channel));
1634		rtn = scsi_try_bus_reset(chan_scmd);
1635		if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
1636			list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1637				if (channel == scmd_channel(scmd)) {
1638					if (rtn == FAST_IO_FAIL)
1639						scsi_eh_finish_cmd(scmd,
1640								   done_q);
1641					else
1642						list_move_tail(&scmd->eh_entry,
1643							       &check_list);
1644				}
1645			}
1646		} else {
1647			SCSI_LOG_ERROR_RECOVERY(3,
1648				shost_printk(KERN_INFO, shost,
1649					     "%s: BRST failed chan: %d\n",
1650					     current->comm, channel));
1651		}
1652	}
1653	return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
1654}
1655
1656/**
1657 * scsi_eh_host_reset - send a host reset
1658 * @shost:	host to be reset.
1659 * @work_q:	&list_head for pending commands.
1660 * @done_q:	&list_head for processed commands.
1661 */
1662static int scsi_eh_host_reset(struct Scsi_Host *shost,
1663			      struct list_head *work_q,
1664			      struct list_head *done_q)
1665{
1666	struct scsi_cmnd *scmd, *next;
1667	LIST_HEAD(check_list);
1668	int rtn;
1669
1670	if (!list_empty(work_q)) {
1671		scmd = list_entry(work_q->next,
1672				  struct scsi_cmnd, eh_entry);
1673
1674		SCSI_LOG_ERROR_RECOVERY(3,
1675			shost_printk(KERN_INFO, shost,
1676				     "%s: Sending HRST\n",
1677				     current->comm));
1678
1679		rtn = scsi_try_host_reset(scmd);
1680		if (rtn == SUCCESS) {
1681			list_splice_init(work_q, &check_list);
1682		} else if (rtn == FAST_IO_FAIL) {
1683			list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1684					scsi_eh_finish_cmd(scmd, done_q);
1685			}
1686		} else {
1687			SCSI_LOG_ERROR_RECOVERY(3,
1688				shost_printk(KERN_INFO, shost,
1689					     "%s: HRST failed\n",
1690					     current->comm));
1691		}
1692	}
1693	return scsi_eh_test_devices(&check_list, work_q, done_q, 1);
1694}
1695
1696/**
1697 * scsi_eh_offline_sdevs - offline scsi devices that fail to recover
1698 * @work_q:	&list_head for pending commands.
1699 * @done_q:	&list_head for processed commands.
1700 */
1701static void scsi_eh_offline_sdevs(struct list_head *work_q,
1702				  struct list_head *done_q)
1703{
1704	struct scsi_cmnd *scmd, *next;
1705	struct scsi_device *sdev;
1706
1707	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1708		sdev_printk(KERN_INFO, scmd->device, "Device offlined - "
1709			    "not ready after error recovery\n");
1710		sdev = scmd->device;
1711
1712		mutex_lock(&sdev->state_mutex);
1713		scsi_device_set_state(sdev, SDEV_OFFLINE);
1714		mutex_unlock(&sdev->state_mutex);
1715
1716		scsi_eh_finish_cmd(scmd, done_q);
1717	}
1718	return;
1719}
1720
1721/**
1722 * scsi_noretry_cmd - determine if command should be failed fast
1723 * @scmd:	SCSI cmd to examine.
1724 */
1725int scsi_noretry_cmd(struct scsi_cmnd *scmd)
1726{
1727	switch (host_byte(scmd->result)) {
1728	case DID_OK:
1729		break;
1730	case DID_TIME_OUT:
1731		goto check_type;
1732	case DID_BUS_BUSY:
1733		return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
1734	case DID_PARITY:
1735		return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
1736	case DID_ERROR:
1737		if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
1738		    status_byte(scmd->result) == RESERVATION_CONFLICT)
1739			return 0;
1740		/* fall through */
1741	case DID_SOFT_ERROR:
1742		return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
1743	}
1744
1745	if (status_byte(scmd->result) != CHECK_CONDITION)
1746		return 0;
1747
1748check_type:
1749	/*
1750	 * assume caller has checked sense and determined
1751	 * the check condition was retryable.
1752	 */
1753	if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
1754	    blk_rq_is_passthrough(scmd->request))
1755		return 1;
1756	else
1757		return 0;
1758}
1759
1760/**
1761 * scsi_decide_disposition - Disposition a cmd on return from LLD.
1762 * @scmd:	SCSI cmd to examine.
1763 *
1764 * Notes:
1765 *    This is *only* called when we are examining the status after sending
1766 *    out the actual data command.  any commands that are queued for error
1767 *    recovery (e.g. test_unit_ready) do *not* come through here.
1768 *
1769 *    When this routine r…

Large files files are truncated, but you can click here to view the full file