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