2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* scsi_error.c Copyright (C) 1997 Eric Youngdale
|
|
|
|
*
|
|
|
|
* SCSI error/timeout handling
|
|
|
|
* Initial versions: Eric Youngdale. Based upon conversations with
|
2011-03-21 20:47:31 +01:00
|
|
|
* Leonard Zubkoff and David Miller at Linux Expo,
|
2005-04-17 00:20:36 +02:00
|
|
|
* ideas originating from all over the place.
|
|
|
|
*
|
|
|
|
* Restructured scsi_unjam_host and associated functions.
|
|
|
|
* September 04, 2002 Mike Anderson (andmike@us.ibm.com)
|
|
|
|
*
|
|
|
|
* Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
|
2011-03-21 20:47:31 +01:00
|
|
|
* minor cleanups.
|
2005-04-17 00:20:36 +02:00
|
|
|
* September 30, 2002 Mike Anderson (andmike@us.ibm.com)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/sched.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/gfp.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/kernel.h>
|
2007-07-17 13:03:35 +02:00
|
|
|
#include <linux/freezer.h>
|
2005-09-06 14:04:26 +02:00
|
|
|
#include <linux/kthread.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
|
|
|
#include <scsi/scsi.h>
|
2006-06-10 18:01:03 +02:00
|
|
|
#include <scsi/scsi_cmnd.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <scsi/scsi_dbg.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_eh.h>
|
2006-03-13 14:28:57 +01:00
|
|
|
#include <scsi/scsi_transport.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_ioctl.h>
|
|
|
|
|
|
|
|
#include "scsi_priv.h"
|
|
|
|
#include "scsi_logging.h"
|
2007-08-10 23:50:42 +02:00
|
|
|
#include "scsi_transport_api.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-04-01 13:41:40 +02:00
|
|
|
#include <trace/events/scsi.h>
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define SENSE_TIMEOUT (10*HZ)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These should *probably* be handled by the host itself.
|
|
|
|
* Since it is allowed to sleep, it probably should.
|
|
|
|
*/
|
|
|
|
#define BUS_RESET_SETTLE_TIME (10)
|
|
|
|
#define HOST_RESET_SETTLE_TIME (10)
|
|
|
|
|
2011-05-19 20:41:12 +02:00
|
|
|
static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* called with shost->host_lock held */
|
|
|
|
void scsi_eh_wakeup(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
if (shost->host_busy == shost->host_failed) {
|
2010-04-01 13:41:40 +02:00
|
|
|
trace_scsi_eh_wakeup(shost);
|
2005-09-19 16:50:04 +02:00
|
|
|
wake_up_process(shost->ehandler);
|
2005-04-17 00:20:36 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(5,
|
|
|
|
printk("Waking error handler thread\n"));
|
|
|
|
}
|
|
|
|
}
|
2006-05-19 14:07:05 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_schedule_eh - schedule EH for SCSI host
|
|
|
|
* @shost: SCSI host to invoke error handling on.
|
|
|
|
*
|
|
|
|
* Schedule SCSI EH without scmd.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2006-05-19 14:07:05 +02:00
|
|
|
void scsi_schedule_eh(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
|
|
|
|
if (scsi_host_set_state(shost, SHOST_RECOVERY) == 0 ||
|
|
|
|
scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY) == 0) {
|
|
|
|
shost->host_eh_scheduled++;
|
|
|
|
scsi_eh_wakeup(shost);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_schedule_eh);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_scmd_add - add scsi cmd to error handling.
|
|
|
|
* @scmd: scmd to run eh on.
|
|
|
|
* @eh_flag: optional SCSI_EH flag.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 0 on failure.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = scmd->device->host;
|
|
|
|
unsigned long flags;
|
2005-09-18 22:05:20 +02:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-19 16:50:04 +02:00
|
|
|
if (!shost->ehandler)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2005-09-18 22:05:20 +02:00
|
|
|
if (scsi_host_set_state(shost, SHOST_RECOVERY))
|
|
|
|
if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY))
|
|
|
|
goto out_unlock;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-18 22:05:20 +02:00
|
|
|
ret = 1;
|
2005-06-19 13:43:26 +02:00
|
|
|
scmd->eh_eflags |= eh_flag;
|
2005-04-17 00:20:36 +02:00
|
|
|
list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
|
|
|
|
shost->host_failed++;
|
|
|
|
scsi_eh_wakeup(shost);
|
2005-09-18 22:05:20 +02:00
|
|
|
out_unlock:
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2005-09-18 22:05:20 +02:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_times_out - Timeout function for normal scsi commands.
|
2008-09-14 14:55:09 +02:00
|
|
|
* @req: request that is timing out.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* We do not need to lock this. There is the potential for a race
|
|
|
|
* only in that the normal completion handling might run, but if the
|
|
|
|
* normal completion function determines that the timer has already
|
|
|
|
* fired, then it mustn't do anything.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2008-09-14 14:55:09 +02:00
|
|
|
enum blk_eh_timer_return scsi_times_out(struct request *req)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-09-14 14:55:09 +02:00
|
|
|
struct scsi_cmnd *scmd = req->special;
|
|
|
|
enum blk_eh_timer_return rtn = BLK_EH_NOT_HANDLED;
|
2011-03-21 20:47:31 +01:00
|
|
|
struct Scsi_Host *host = scmd->device->host;
|
2007-03-16 23:44:41 +01:00
|
|
|
|
2010-04-01 13:41:40 +02:00
|
|
|
trace_scsi_dispatch_cmd_timeout(scmd);
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_log_completion(scmd, TIMEOUT_ERROR);
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
if (host->transportt->eh_timed_out)
|
|
|
|
rtn = host->transportt->eh_timed_out(scmd);
|
|
|
|
else if (host->hostt->eh_timed_out)
|
|
|
|
rtn = host->hostt->eh_timed_out(scmd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-11-05 15:03:15 +01:00
|
|
|
if (unlikely(rtn == BLK_EH_NOT_HANDLED &&
|
|
|
|
!scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD))) {
|
2005-09-18 22:05:20 +02:00
|
|
|
scmd->result |= DID_TIME_OUT << 16;
|
2008-11-05 15:03:15 +01:00
|
|
|
rtn = BLK_EH_HANDLED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-09-14 14:55:09 +02:00
|
|
|
|
2008-11-05 15:03:15 +01:00
|
|
|
return rtn;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_block_when_processing_errors - Prevent cmds from being queued.
|
|
|
|
* @sdev: Device on which we are performing recovery.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* We block until the host is out of error recovery, and then check to
|
|
|
|
* see whether the host or the device is offline.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 0 when dev was taken offline by error recovery. 1 OK to proceed.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_block_when_processing_errors(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
int online;
|
|
|
|
|
2005-09-18 22:05:20 +02:00
|
|
|
wait_event(sdev->host->host_wait, !scsi_host_in_recovery(sdev->host));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
online = scsi_device_online(sdev);
|
|
|
|
|
2008-07-04 08:47:27 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(5, printk("%s: rtn: %d\n", __func__,
|
2005-04-17 00:20:36 +02:00
|
|
|
online));
|
|
|
|
|
|
|
|
return online;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_block_when_processing_errors);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCSI_LOGGING
|
|
|
|
/**
|
|
|
|
* scsi_eh_prt_fail_stats - Log info on failures.
|
|
|
|
* @shost: scsi host being recovered.
|
|
|
|
* @work_q: Queue of scsi cmds to process.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *scmd;
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
int total_failures = 0;
|
|
|
|
int cmd_failed = 0;
|
|
|
|
int cmd_cancel = 0;
|
|
|
|
int devices_failed = 0;
|
|
|
|
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
list_for_each_entry(scmd, work_q, eh_entry) {
|
|
|
|
if (scmd->device == sdev) {
|
|
|
|
++total_failures;
|
2005-06-19 13:43:26 +02:00
|
|
|
if (scmd->eh_eflags & SCSI_EH_CANCEL_CMD)
|
2005-04-17 00:20:36 +02:00
|
|
|
++cmd_cancel;
|
2011-03-21 20:47:31 +01:00
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
++cmd_failed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd_cancel || cmd_failed) {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
2005-10-02 18:45:08 +02:00
|
|
|
sdev_printk(KERN_INFO, sdev,
|
|
|
|
"%s: cmds failed: %d, cancel: %d\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__, cmd_failed,
|
2005-10-02 18:45:08 +02:00
|
|
|
cmd_cancel));
|
2005-04-17 00:20:36 +02:00
|
|
|
cmd_cancel = 0;
|
|
|
|
cmd_failed = 0;
|
|
|
|
++devices_failed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(2, printk("Total of %d commands on %d"
|
|
|
|
" devices require eh work\n",
|
2011-03-21 20:47:31 +01:00
|
|
|
total_failures, devices_failed));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_check_sense - Examine scsi cmd sense
|
|
|
|
* @scmd: Cmd to have sense checked.
|
|
|
|
*
|
|
|
|
* Return value:
|
2011-01-18 10:13:11 +01:00
|
|
|
* SUCCESS or FAILED or NEEDS_RETRY or TARGET_ERROR
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* When a deferred error is detected the current command has
|
|
|
|
* not been executed and needs retrying.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_check_sense(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2008-05-01 23:49:46 +02:00
|
|
|
struct scsi_device *sdev = scmd->device;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
|
|
|
|
if (! scsi_command_normalize_sense(scmd, &sshdr))
|
|
|
|
return FAILED; /* no valid sense data */
|
|
|
|
|
|
|
|
if (scsi_sense_is_deferred(&sshdr))
|
|
|
|
return NEEDS_RETRY;
|
|
|
|
|
2008-05-01 23:49:46 +02:00
|
|
|
if (sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh &&
|
|
|
|
sdev->scsi_dh_data->scsi_dh->check_sense) {
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = sdev->scsi_dh_data->scsi_dh->check_sense(sdev, &sshdr);
|
|
|
|
if (rc != SCSI_RETURN_NOT_HANDLED)
|
|
|
|
return rc;
|
|
|
|
/* handler does not care. Drop down to default handling */
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Previous logic looked for FILEMARK, EOM or ILI which are
|
|
|
|
* mainly associated with tapes and returned SUCCESS.
|
|
|
|
*/
|
|
|
|
if (sshdr.response_code == 0x70) {
|
|
|
|
/* fixed format */
|
|
|
|
if (scmd->sense_buffer[2] & 0xe0)
|
|
|
|
return SUCCESS;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* descriptor format: look for "stream commands sense data
|
|
|
|
* descriptor" (see SSC-3). Assume single sense data
|
|
|
|
* descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
|
|
|
|
*/
|
|
|
|
if ((sshdr.additional_length > 3) &&
|
|
|
|
(scmd->sense_buffer[8] == 0x4) &&
|
|
|
|
(scmd->sense_buffer[11] & 0xe0))
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (sshdr.sense_key) {
|
|
|
|
case NO_SENSE:
|
|
|
|
return SUCCESS;
|
|
|
|
case RECOVERED_ERROR:
|
|
|
|
return /* soft_error */ SUCCESS;
|
|
|
|
|
|
|
|
case ABORTED_COMMAND:
|
2008-07-17 10:28:33 +02:00
|
|
|
if (sshdr.asc == 0x10) /* DIF */
|
|
|
|
return SUCCESS;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return NEEDS_RETRY;
|
|
|
|
case NOT_READY:
|
|
|
|
case UNIT_ATTENTION:
|
|
|
|
/*
|
|
|
|
* if we are expecting a cc/ua because of a bus reset that we
|
|
|
|
* performed, treat this just as a retry. otherwise this is
|
|
|
|
* information that we should pass up to the upper-level driver
|
|
|
|
* so that we can deal with it there.
|
|
|
|
*/
|
|
|
|
if (scmd->device->expecting_cc_ua) {
|
2011-08-11 13:25:20 +02:00
|
|
|
/*
|
|
|
|
* Because some device does not queue unit
|
|
|
|
* attentions correctly, we carefully check
|
|
|
|
* additional sense code and qualifier so as
|
|
|
|
* not to squash media change unit attention.
|
|
|
|
*/
|
|
|
|
if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
|
|
|
|
scmd->device->expecting_cc_ua = 0;
|
|
|
|
return NEEDS_RETRY;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
/*
|
2011-03-21 20:47:31 +01:00
|
|
|
* if the device is in the process of becoming ready, we
|
2005-04-17 00:20:36 +02:00
|
|
|
* should retry.
|
|
|
|
*/
|
|
|
|
if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
|
|
|
|
return NEEDS_RETRY;
|
|
|
|
/*
|
|
|
|
* if the device is not started, we need to wake
|
|
|
|
* the error handler to start the motor
|
|
|
|
*/
|
|
|
|
if (scmd->device->allow_restart &&
|
|
|
|
(sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
|
|
|
|
return FAILED;
|
2010-05-04 22:51:40 +02:00
|
|
|
|
2010-04-25 14:03:57 +02:00
|
|
|
if (sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
|
|
|
|
scmd_printk(KERN_WARNING, scmd,
|
|
|
|
"Warning! Received an indication that the "
|
|
|
|
"LUN assignments on this target have "
|
|
|
|
"changed. The Linux SCSI layer does not "
|
|
|
|
"automatically remap LUN assignments.\n");
|
|
|
|
else if (sshdr.asc == 0x3f)
|
|
|
|
scmd_printk(KERN_WARNING, scmd,
|
|
|
|
"Warning! Received an indication that the "
|
|
|
|
"operating parameters on this target have "
|
|
|
|
"changed. The Linux SCSI layer does not "
|
|
|
|
"automatically adjust these parameters.\n");
|
|
|
|
|
2011-02-26 07:59:44 +01:00
|
|
|
if (sshdr.asc == 0x38 && sshdr.ascq == 0x07)
|
|
|
|
scmd_printk(KERN_WARNING, scmd,
|
|
|
|
"Warning! Received an indication that the "
|
|
|
|
"LUN reached a thin provisioning soft "
|
|
|
|
"threshold.\n");
|
|
|
|
|
2010-11-10 14:54:09 +01:00
|
|
|
/*
|
|
|
|
* Pass the UA upwards for a determination in the completion
|
|
|
|
* functions.
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-18 10:13:11 +01:00
|
|
|
/* these are not supported */
|
2005-04-17 00:20:36 +02:00
|
|
|
case COPY_ABORTED:
|
|
|
|
case VOLUME_OVERFLOW:
|
|
|
|
case MISCOMPARE:
|
2011-01-18 10:13:11 +01:00
|
|
|
case BLANK_CHECK:
|
|
|
|
case DATA_PROTECT:
|
|
|
|
return TARGET_ERROR;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
case MEDIUM_ERROR:
|
2006-11-30 04:45:23 +01:00
|
|
|
if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
|
|
|
|
sshdr.asc == 0x13 || /* AMNF DATA FIELD */
|
|
|
|
sshdr.asc == 0x14) { /* RECORD NOT FOUND */
|
2011-01-18 10:13:11 +01:00
|
|
|
return TARGET_ERROR;
|
2006-11-30 04:45:23 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return NEEDS_RETRY;
|
|
|
|
|
|
|
|
case HARDWARE_ERROR:
|
|
|
|
if (scmd->device->retry_hwerror)
|
2008-08-12 21:11:58 +02:00
|
|
|
return ADD_TO_MLQUEUE;
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2011-01-18 10:13:11 +01:00
|
|
|
return TARGET_ERROR;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
case ILLEGAL_REQUEST:
|
|
|
|
default:
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-23 00:46:33 +02:00
|
|
|
static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct scsi_host_template *sht = sdev->host->hostt;
|
|
|
|
struct scsi_device *tmp_sdev;
|
|
|
|
|
|
|
|
if (!sht->change_queue_depth ||
|
|
|
|
sdev->queue_depth >= sdev->max_queue_depth)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (time_before(jiffies,
|
|
|
|
sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (time_before(jiffies,
|
|
|
|
sdev->last_queue_full_time + sdev->queue_ramp_up_period))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk all devices of a target and do
|
|
|
|
* ramp up on them.
|
|
|
|
*/
|
|
|
|
shost_for_each_device(tmp_sdev, sdev->host) {
|
|
|
|
if (tmp_sdev->channel != sdev->channel ||
|
|
|
|
tmp_sdev->id != sdev->id ||
|
|
|
|
tmp_sdev->queue_depth == sdev->max_queue_depth)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* call back into LLD to increase queue_depth by one
|
|
|
|
* with ramp up reason code.
|
|
|
|
*/
|
|
|
|
sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1,
|
|
|
|
SCSI_QDEPTH_RAMP_UP);
|
|
|
|
sdev->last_queue_ramp_up = jiffies;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-16 02:46:44 +02:00
|
|
|
static void scsi_handle_queue_full(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct scsi_host_template *sht = sdev->host->hostt;
|
|
|
|
struct scsi_device *tmp_sdev;
|
|
|
|
|
|
|
|
if (!sht->change_queue_depth)
|
|
|
|
return;
|
|
|
|
|
|
|
|
shost_for_each_device(tmp_sdev, sdev->host) {
|
|
|
|
if (tmp_sdev->channel != sdev->channel ||
|
|
|
|
tmp_sdev->id != sdev->id)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* We do not know the number of commands that were at
|
|
|
|
* the device when we got the queue full so we start
|
|
|
|
* from the highest possible value and work our way down.
|
|
|
|
*/
|
|
|
|
sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth - 1,
|
|
|
|
SCSI_QDEPTH_QFULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
|
|
|
|
* @scmd: SCSI cmd to examine.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* This is *only* called when we are examining the status of commands
|
|
|
|
* queued during error recovery. the main difference here is that we
|
|
|
|
* don't allow for the possibility of retries here, and we are a lot
|
|
|
|
* more restrictive about what we consider acceptable.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* first check the host byte, to see if there is anything in there
|
|
|
|
* that would indicate what we need to do.
|
|
|
|
*/
|
|
|
|
if (host_byte(scmd->result) == DID_RESET) {
|
|
|
|
/*
|
|
|
|
* rats. we are already in the error handler, so we now
|
|
|
|
* get to try and figure out what to do next. if the sense
|
|
|
|
* is valid, we have a pretty good idea of what to do.
|
|
|
|
* if not, we mark it as FAILED.
|
|
|
|
*/
|
|
|
|
return scsi_check_sense(scmd);
|
|
|
|
}
|
|
|
|
if (host_byte(scmd->result) != DID_OK)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* next, check the message byte.
|
|
|
|
*/
|
|
|
|
if (msg_byte(scmd->result) != COMMAND_COMPLETE)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* now, check the status byte to see if this indicates
|
|
|
|
* anything special.
|
|
|
|
*/
|
|
|
|
switch (status_byte(scmd->result)) {
|
|
|
|
case GOOD:
|
2009-10-23 00:46:33 +02:00
|
|
|
scsi_handle_queue_ramp_up(scmd->device);
|
2005-04-17 00:20:36 +02:00
|
|
|
case COMMAND_TERMINATED:
|
|
|
|
return SUCCESS;
|
|
|
|
case CHECK_CONDITION:
|
|
|
|
return scsi_check_sense(scmd);
|
|
|
|
case CONDITION_GOOD:
|
|
|
|
case INTERMEDIATE_GOOD:
|
|
|
|
case INTERMEDIATE_C_GOOD:
|
|
|
|
/*
|
|
|
|
* who knows? FIXME(eric)
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
2009-08-10 18:59:28 +02:00
|
|
|
case RESERVATION_CONFLICT:
|
2010-08-06 22:17:24 +02:00
|
|
|
if (scmd->cmnd[0] == TEST_UNIT_READY)
|
|
|
|
/* it is a success, we probed the device and
|
|
|
|
* found it */
|
|
|
|
return SUCCESS;
|
|
|
|
/* otherwise, we failed to send the command */
|
|
|
|
return FAILED;
|
2005-04-17 00:20:36 +02:00
|
|
|
case QUEUE_FULL:
|
2009-10-16 02:46:44 +02:00
|
|
|
scsi_handle_queue_full(scmd->device);
|
|
|
|
/* fall through */
|
|
|
|
case BUSY:
|
2010-07-29 10:10:16 +02:00
|
|
|
return NEEDS_RETRY;
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_done - Completion function for error handling.
|
|
|
|
* @scmd: Cmd that is done.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void scsi_eh_done(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2011-03-21 20:47:31 +01:00
|
|
|
struct completion *eh_action;
|
2005-12-08 04:46:27 +01:00
|
|
|
|
2005-10-31 18:49:52 +01:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
|
|
|
printk("%s scmd: %p result: %x\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__, scmd, scmd->result));
|
2005-12-08 04:46:27 +01:00
|
|
|
|
|
|
|
eh_action = scmd->device->host->eh_action;
|
|
|
|
if (eh_action)
|
|
|
|
complete(eh_action);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-01-31 00:51:17 +01:00
|
|
|
/**
|
|
|
|
* scsi_try_host_reset - ask host adapter to reset itself
|
|
|
|
* @scmd: SCSI cmd to send hsot reset.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-01-31 00:51:17 +01:00
|
|
|
static int scsi_try_host_reset(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int rtn;
|
2011-03-21 20:47:31 +01:00
|
|
|
struct Scsi_Host *host = scmd->device->host;
|
|
|
|
struct scsi_host_template *hostt = host->hostt;
|
2007-01-31 00:51:17 +01:00
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Host RST\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__));
|
2007-01-31 00:51:17 +01:00
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->eh_host_reset_handler)
|
2007-01-31 00:51:17 +01:00
|
|
|
return FAILED;
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
rtn = hostt->eh_host_reset_handler(scmd);
|
2007-01-31 00:51:17 +01:00
|
|
|
|
|
|
|
if (rtn == SUCCESS) {
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->skip_settle_delay)
|
2007-01-31 00:51:17 +01:00
|
|
|
ssleep(HOST_RESET_SETTLE_TIME);
|
2011-03-21 20:47:31 +01:00
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
|
|
|
scsi_report_bus_reset(host, scmd_channel(scmd));
|
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
2007-01-31 00:51:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_try_bus_reset - ask host to perform a bus reset
|
|
|
|
* @scmd: SCSI cmd to send bus reset.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-01-31 00:51:17 +01:00
|
|
|
static int scsi_try_bus_reset(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int rtn;
|
2011-03-21 20:47:31 +01:00
|
|
|
struct Scsi_Host *host = scmd->device->host;
|
|
|
|
struct scsi_host_template *hostt = host->hostt;
|
2007-01-31 00:51:17 +01:00
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Bus RST\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__));
|
2007-01-31 00:51:17 +01:00
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->eh_bus_reset_handler)
|
2007-01-31 00:51:17 +01:00
|
|
|
return FAILED;
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
rtn = hostt->eh_bus_reset_handler(scmd);
|
2007-01-31 00:51:17 +01:00
|
|
|
|
|
|
|
if (rtn == SUCCESS) {
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->skip_settle_delay)
|
2007-01-31 00:51:17 +01:00
|
|
|
ssleep(BUS_RESET_SETTLE_TIME);
|
2011-03-21 20:47:31 +01:00
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
|
|
|
scsi_report_bus_reset(host, scmd_channel(scmd));
|
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
2007-01-31 00:51:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2008-03-01 01:25:19 +01:00
|
|
|
static void __scsi_report_device_reset(struct scsi_device *sdev, void *data)
|
|
|
|
{
|
|
|
|
sdev->was_reset = 1;
|
|
|
|
sdev->expecting_cc_ua = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_try_target_reset - Ask host to perform a target reset
|
|
|
|
* @scmd: SCSI cmd used to send a target reset
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* There is no timeout for this operation. if this operation is
|
|
|
|
* unreliable for a given host, then the host itself needs to put a
|
|
|
|
* timer on it, and set the host back to a consistent state prior to
|
|
|
|
* returning.
|
|
|
|
*/
|
|
|
|
static int scsi_try_target_reset(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int rtn;
|
2011-03-21 20:47:31 +01:00
|
|
|
struct Scsi_Host *host = scmd->device->host;
|
|
|
|
struct scsi_host_template *hostt = host->hostt;
|
2008-03-01 01:25:19 +01:00
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->eh_target_reset_handler)
|
2008-03-01 01:25:19 +01:00
|
|
|
return FAILED;
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
rtn = hostt->eh_target_reset_handler(scmd);
|
2008-03-01 01:25:19 +01:00
|
|
|
if (rtn == SUCCESS) {
|
2011-03-21 20:47:31 +01:00
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
2008-03-01 01:25:19 +01:00
|
|
|
__starget_for_each_device(scsi_target(scmd->device), NULL,
|
|
|
|
__scsi_report_device_reset);
|
2011-03-21 20:47:31 +01:00
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
2008-03-01 01:25:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2007-01-31 00:51:17 +01:00
|
|
|
/**
|
|
|
|
* scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
|
|
|
|
* @scmd: SCSI cmd used to send BDR
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* There is no timeout for this operation. if this operation is
|
|
|
|
* unreliable for a given host, then the host itself needs to put a
|
|
|
|
* timer on it, and set the host back to a consistent state prior to
|
|
|
|
* returning.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-01-31 00:51:17 +01:00
|
|
|
static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
int rtn;
|
2011-03-21 20:47:31 +01:00
|
|
|
struct scsi_host_template *hostt = scmd->device->host->hostt;
|
2007-01-31 00:51:17 +01:00
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->eh_device_reset_handler)
|
2007-01-31 00:51:17 +01:00
|
|
|
return FAILED;
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
rtn = hostt->eh_device_reset_handler(scmd);
|
2008-03-01 01:25:19 +01:00
|
|
|
if (rtn == SUCCESS)
|
|
|
|
__scsi_report_device_reset(scmd->device, NULL);
|
2007-01-31 00:51:17 +01:00
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt, struct scsi_cmnd *scmd)
|
2007-01-31 00:51:17 +01:00
|
|
|
{
|
2011-03-21 20:47:31 +01:00
|
|
|
if (!hostt->eh_abort_handler)
|
2007-01-31 00:51:17 +01:00
|
|
|
return FAILED;
|
|
|
|
|
2011-03-21 20:47:31 +01:00
|
|
|
return hostt->eh_abort_handler(scmd);
|
2007-01-31 00:51:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2011-03-21 20:47:31 +01:00
|
|
|
if (scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd) != SUCCESS)
|
2007-01-31 00:51:17 +01:00
|
|
|
if (scsi_try_bus_device_reset(scmd) != SUCCESS)
|
2008-03-01 01:25:19 +01:00
|
|
|
if (scsi_try_target_reset(scmd) != SUCCESS)
|
|
|
|
if (scsi_try_bus_reset(scmd) != SUCCESS)
|
|
|
|
scsi_try_host_reset(scmd);
|
2007-01-31 00:51:17 +01:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
2007-10-08 16:36:45 +02:00
|
|
|
* scsi_eh_prep_cmnd - Save a scsi command info as part of error recory
|
2006-11-04 20:04:21 +01:00
|
|
|
* @scmd: SCSI command structure to hijack
|
2007-10-08 16:36:45 +02:00
|
|
|
* @ses: structure to save restore information
|
2007-10-08 16:35:19 +02:00
|
|
|
* @cmnd: CDB to send. Can be NULL if no new cmnd is needed
|
2008-04-30 10:19:47 +02:00
|
|
|
* @cmnd_size: size in bytes of @cmnd (must be <= BLK_MAX_CDB)
|
2007-10-08 16:35:19 +02:00
|
|
|
* @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
|
2006-11-04 20:04:21 +01:00
|
|
|
*
|
2007-10-08 16:36:45 +02:00
|
|
|
* This function is used to save a scsi command information before re-execution
|
2007-10-08 16:35:19 +02:00
|
|
|
* as part of the error recovery process. If @sense_bytes is 0 the command
|
|
|
|
* sent must be one that does not transfer any data. If @sense_bytes != 0
|
|
|
|
* @cmnd is ignored and this functions sets up a REQUEST_SENSE command
|
|
|
|
* and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-10-08 16:36:45 +02:00
|
|
|
void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses,
|
|
|
|
unsigned char *cmnd, int cmnd_size, unsigned sense_bytes)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-04-17 22:00:23 +02:00
|
|
|
struct scsi_device *sdev = scmd->device;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-08 20:42:15 +02:00
|
|
|
/*
|
|
|
|
* We need saved copies of a number of fields - this is because
|
|
|
|
* error handling may need to overwrite these with different values
|
|
|
|
* to run different commands, and once error handling is complete,
|
|
|
|
* we will need to restore these values prior to running the actual
|
|
|
|
* command.
|
|
|
|
*/
|
2007-10-08 16:36:45 +02:00
|
|
|
ses->cmd_len = scmd->cmd_len;
|
2008-04-30 10:19:47 +02:00
|
|
|
ses->cmnd = scmd->cmnd;
|
2007-10-08 16:36:45 +02:00
|
|
|
ses->data_direction = scmd->sc_data_direction;
|
2007-12-13 12:47:40 +01:00
|
|
|
ses->sdb = scmd->sdb;
|
2007-12-13 12:50:53 +01:00
|
|
|
ses->next_rq = scmd->request->next_rq;
|
2007-10-08 16:36:45 +02:00
|
|
|
ses->result = scmd->result;
|
2008-07-21 16:25:52 +02:00
|
|
|
ses->underflow = scmd->underflow;
|
2008-07-17 10:28:31 +02:00
|
|
|
ses->prot_op = scmd->prot_op;
|
2006-07-08 20:42:15 +02:00
|
|
|
|
2008-07-17 10:28:31 +02:00
|
|
|
scmd->prot_op = SCSI_PROT_NORMAL;
|
2008-04-30 10:19:47 +02:00
|
|
|
scmd->cmnd = ses->eh_cmnd;
|
|
|
|
memset(scmd->cmnd, 0, BLK_MAX_CDB);
|
2007-12-13 12:47:40 +01:00
|
|
|
memset(&scmd->sdb, 0, sizeof(scmd->sdb));
|
2007-12-13 12:50:53 +01:00
|
|
|
scmd->request->next_rq = NULL;
|
2007-12-13 12:47:40 +01:00
|
|
|
|
2007-10-08 16:35:19 +02:00
|
|
|
if (sense_bytes) {
|
2007-12-13 12:47:40 +01:00
|
|
|
scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
|
|
|
|
sense_bytes);
|
2007-10-08 16:36:45 +02:00
|
|
|
sg_init_one(&ses->sense_sgl, scmd->sense_buffer,
|
2007-12-13 12:47:40 +01:00
|
|
|
scmd->sdb.length);
|
|
|
|
scmd->sdb.table.sgl = &ses->sense_sgl;
|
2007-10-08 16:35:19 +02:00
|
|
|
scmd->sc_data_direction = DMA_FROM_DEVICE;
|
2007-12-13 12:47:40 +01:00
|
|
|
scmd->sdb.table.nents = 1;
|
2007-10-08 16:35:19 +02:00
|
|
|
scmd->cmnd[0] = REQUEST_SENSE;
|
2007-12-13 12:47:40 +01:00
|
|
|
scmd->cmnd[4] = scmd->sdb.length;
|
2007-10-08 16:35:19 +02:00
|
|
|
scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
|
2006-07-08 20:42:15 +02:00
|
|
|
} else {
|
|
|
|
scmd->sc_data_direction = DMA_NONE;
|
2007-10-08 16:35:19 +02:00
|
|
|
if (cmnd) {
|
2008-04-30 10:19:47 +02:00
|
|
|
BUG_ON(cmnd_size > BLK_MAX_CDB);
|
2007-10-08 16:35:19 +02:00
|
|
|
memcpy(scmd->cmnd, cmnd, cmnd_size);
|
|
|
|
scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
|
|
|
|
}
|
2006-07-08 20:42:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
scmd->underflow = 0;
|
|
|
|
|
2007-10-08 16:35:19 +02:00
|
|
|
if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN)
|
2005-04-17 00:20:36 +02:00
|
|
|
scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
|
2005-04-17 22:00:23 +02:00
|
|
|
(sdev->lun << 5 & 0xe0);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-08 20:42:15 +02:00
|
|
|
/*
|
|
|
|
* Zero the sense buffer. The scsi spec mandates that any
|
|
|
|
* untransferred sense data should be interpreted as being zero.
|
|
|
|
*/
|
2008-01-13 07:46:13 +01:00
|
|
|
memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
2007-10-08 16:36:45 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_eh_prep_cmnd);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_restore_cmnd - Restore a scsi command info as part of error recory
|
|
|
|
* @scmd: SCSI command structure to restore
|
2009-04-27 20:54:22 +02:00
|
|
|
* @ses: saved information from a coresponding call to scsi_eh_prep_cmnd
|
2007-10-08 16:36:45 +02:00
|
|
|
*
|
2009-04-27 20:54:22 +02:00
|
|
|
* Undo any damage done by above scsi_eh_prep_cmnd().
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-10-08 16:36:45 +02:00
|
|
|
void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Restore original data
|
|
|
|
*/
|
|
|
|
scmd->cmd_len = ses->cmd_len;
|
2008-04-30 10:19:47 +02:00
|
|
|
scmd->cmnd = ses->cmnd;
|
2007-10-08 16:36:45 +02:00
|
|
|
scmd->sc_data_direction = ses->data_direction;
|
2007-12-13 12:47:40 +01:00
|
|
|
scmd->sdb = ses->sdb;
|
2007-12-13 12:50:53 +01:00
|
|
|
scmd->request->next_rq = ses->next_rq;
|
2007-10-08 16:36:45 +02:00
|
|
|
scmd->result = ses->result;
|
2008-07-21 16:25:52 +02:00
|
|
|
scmd->underflow = ses->underflow;
|
2008-07-17 10:28:31 +02:00
|
|
|
scmd->prot_op = ses->prot_op;
|
2007-10-08 16:36:45 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_eh_restore_cmnd);
|
2006-07-08 20:42:15 +02:00
|
|
|
|
2007-10-08 16:36:45 +02:00
|
|
|
/**
|
|
|
|
* scsi_send_eh_cmnd - submit a scsi command as part of error recory
|
|
|
|
* @scmd: SCSI command structure to hijack
|
|
|
|
* @cmnd: CDB to send
|
|
|
|
* @cmnd_size: size in bytes of @cmnd
|
|
|
|
* @timeout: timeout for this request
|
|
|
|
* @sense_bytes: size of sense data to copy or 0
|
|
|
|
*
|
|
|
|
* This function is used to send a scsi command down to a target device
|
|
|
|
* as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* SUCCESS or FAILED or NEEDS_RETRY
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-10-08 16:36:45 +02:00
|
|
|
static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
|
|
|
|
int cmnd_size, int timeout, unsigned sense_bytes)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = scmd->device;
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
|
|
|
DECLARE_COMPLETION_ONSTACK(done);
|
|
|
|
unsigned long timeleft;
|
|
|
|
struct scsi_eh_save ses;
|
|
|
|
int rtn;
|
|
|
|
|
|
|
|
scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
|
2005-10-31 18:49:52 +01:00
|
|
|
shost->eh_action = &done;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
scsi_log_send(scmd);
|
2010-11-16 08:10:29 +01:00
|
|
|
scmd->scsi_done = scsi_eh_done;
|
|
|
|
shost->hostt->queuecommand(shost, scmd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-31 18:49:52 +01:00
|
|
|
timeleft = wait_for_completion_timeout(&done, timeout);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-17 22:00:23 +02:00
|
|
|
shost->eh_action = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-31 18:49:52 +01:00
|
|
|
scsi_log_completion(scmd, SUCCESS);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-31 18:49:52 +01:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
|
|
|
printk("%s: scmd: %p, timeleft: %ld\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__, scmd, timeleft));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-31 18:49:52 +01:00
|
|
|
* If there is time left scsi_eh_done got called, and we will
|
|
|
|
* examine the actual status codes to see whether the command
|
|
|
|
* actually did complete normally, else tell the host to forget
|
|
|
|
* about this command.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-10-31 18:49:52 +01:00
|
|
|
if (timeleft) {
|
2005-04-17 00:20:36 +02:00
|
|
|
rtn = scsi_eh_completed_normally(scmd);
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
|
|
|
printk("%s: scsi_eh_completed_normally %x\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__, rtn));
|
2005-10-31 18:49:52 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (rtn) {
|
|
|
|
case SUCCESS:
|
|
|
|
case NEEDS_RETRY:
|
|
|
|
case FAILED:
|
2011-01-18 10:13:11 +01:00
|
|
|
case TARGET_ERROR:
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2009-09-17 17:00:26 +02:00
|
|
|
case ADD_TO_MLQUEUE:
|
|
|
|
rtn = NEEDS_RETRY;
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
|
|
|
rtn = FAILED;
|
|
|
|
break;
|
|
|
|
}
|
2005-10-31 18:49:52 +01:00
|
|
|
} else {
|
2007-01-31 00:51:17 +01:00
|
|
|
scsi_abort_eh_cmnd(scmd);
|
2005-10-31 18:49:52 +01:00
|
|
|
rtn = FAILED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-08 16:36:45 +02:00
|
|
|
scsi_eh_restore_cmnd(scmd, &ses);
|
2005-04-17 00:20:36 +02:00
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_request_sense - Request sense data from a particular target.
|
|
|
|
* @scmd: SCSI cmd for request sense.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Some hosts automatically obtain this information, others require
|
|
|
|
* that we obtain it on our own. This function will *not* return until
|
|
|
|
* the command either times out, or it completes.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_request_sense(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2007-10-08 16:35:19 +02:00
|
|
|
return scsi_send_eh_cmnd(scmd, NULL, 0, SENSE_TIMEOUT, ~0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
|
|
|
|
* @scmd: Original SCSI cmd that eh has finished.
|
|
|
|
* @done_q: Queue for processed commands.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* We don't want to use the normal command completion while we are are
|
|
|
|
* still handling errors - it may cause other commands to be queued,
|
2007-11-03 19:30:39 +01:00
|
|
|
* and that would disturb what we are doing. Thus we really want to
|
2005-04-17 00:20:36 +02:00
|
|
|
* keep a list of pending commands for final completion, and once we
|
|
|
|
* are ready to leave error handling we handle completion for real.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2006-01-23 05:09:36 +01:00
|
|
|
void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
scmd->device->host->host_failed--;
|
2005-06-19 13:43:26 +02:00
|
|
|
scmd->eh_eflags = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
list_move_tail(&scmd->eh_entry, done_q);
|
|
|
|
}
|
2006-01-23 05:09:36 +01:00
|
|
|
EXPORT_SYMBOL(scsi_eh_finish_cmd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_get_sense - Get device sense data.
|
|
|
|
* @work_q: Queue of commands to process.
|
2007-11-03 19:30:39 +01:00
|
|
|
* @done_q: Queue of processed commands.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* See if we need to request sense information. if so, then get it
|
2011-03-21 20:47:31 +01:00
|
|
|
* now, so we have a better idea of what to do.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* This has the unfortunate side effect that if a shost adapter does
|
2007-11-03 19:30:39 +01:00
|
|
|
* not automatically request sense information, we end up shutting
|
2005-04-17 00:20:36 +02:00
|
|
|
* it down before we request it.
|
|
|
|
*
|
|
|
|
* All drivers should request sense information internally these days,
|
|
|
|
* so for now all I have to say is tough noogies if you end up in here.
|
|
|
|
*
|
|
|
|
* XXX: Long term this code should go away, but that needs an audit of
|
|
|
|
* all LLDDs first.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-01-26 23:08:49 +01:00
|
|
|
int scsi_eh_get_sense(struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
int rtn;
|
|
|
|
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
|
2005-06-19 13:43:26 +02:00
|
|
|
if ((scmd->eh_eflags & SCSI_EH_CANCEL_CMD) ||
|
2005-04-17 00:20:36 +02:00
|
|
|
SCSI_SENSE_VALID(scmd))
|
|
|
|
continue;
|
|
|
|
|
2005-10-25 00:04:06 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
|
|
|
|
"%s: requesting sense\n",
|
|
|
|
current->comm));
|
2005-04-17 00:20:36 +02:00
|
|
|
rtn = scsi_request_sense(scmd);
|
|
|
|
if (rtn != SUCCESS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("sense requested for %p"
|
|
|
|
" result %x\n", scmd,
|
|
|
|
scmd->result));
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense("bh", scmd));
|
|
|
|
|
|
|
|
rtn = scsi_decide_disposition(scmd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the result was normal, then just pass it along to the
|
|
|
|
* upper level.
|
|
|
|
*/
|
|
|
|
if (rtn == SUCCESS)
|
|
|
|
/* we don't want this command reissued, just
|
|
|
|
* finished with the sense data, so set
|
|
|
|
* retries to the max allowed to ensure it
|
|
|
|
* won't get reissued */
|
|
|
|
scmd->retries = scmd->allowed;
|
|
|
|
else if (rtn != NEEDS_RETRY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
}
|
|
|
|
|
|
|
|
return list_empty(work_q);
|
|
|
|
}
|
2007-01-26 23:08:49 +01:00
|
|
|
EXPORT_SYMBOL_GPL(scsi_eh_get_sense);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_tur - Send TUR to device.
|
2007-11-03 19:30:39 +01:00
|
|
|
* @scmd: &scsi_cmnd to send TUR
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 0 - Device is ready. 1 - Device NOT ready.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_tur(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
|
|
|
|
int retry_cnt = 1, rtn;
|
|
|
|
|
|
|
|
retry_tur:
|
2006-08-26 09:00:22 +02:00
|
|
|
rtn = scsi_send_eh_cmnd(scmd, tur_command, 6, SENSE_TIMEOUT, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd %p rtn %x\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__, scmd, rtn));
|
2006-07-08 20:42:15 +02:00
|
|
|
|
|
|
|
switch (rtn) {
|
|
|
|
case NEEDS_RETRY:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retry_cnt--)
|
|
|
|
goto retry_tur;
|
2006-07-08 20:42:15 +02:00
|
|
|
/*FALLTHRU*/
|
|
|
|
case SUCCESS:
|
2005-03-30 22:05:45 +02:00
|
|
|
return 0;
|
2006-07-08 20:42:15 +02:00
|
|
|
default:
|
|
|
|
return 1;
|
2005-03-30 22:05:45 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2011-05-19 20:41:12 +02:00
|
|
|
/**
|
|
|
|
* scsi_eh_test_devices - check if devices are responding from error recovery.
|
|
|
|
* @cmd_list: scsi commands in error recovery.
|
|
|
|
* @work_q: queue for commands which still need more error recovery
|
|
|
|
* @done_q: queue for commands which are finished
|
|
|
|
* @try_stu: boolean on if a STU command should be tried in addition to TUR.
|
|
|
|
*
|
|
|
|
* Decription:
|
|
|
|
* Tests if devices are in a working state. Commands to devices now in
|
|
|
|
* a working state are sent to the done_q while commands to devices which
|
|
|
|
* are still failing to respond are returned to the work_q for more
|
|
|
|
* processing.
|
|
|
|
**/
|
|
|
|
static int scsi_eh_test_devices(struct list_head *cmd_list,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q, int try_stu)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *scmd, *next;
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
int finish_cmds;
|
|
|
|
|
|
|
|
while (!list_empty(cmd_list)) {
|
|
|
|
scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
|
|
|
|
sdev = scmd->device;
|
|
|
|
|
|
|
|
finish_cmds = !scsi_device_online(scmd->device) ||
|
|
|
|
(try_stu && !scsi_eh_try_stu(scmd) &&
|
|
|
|
!scsi_eh_tur(scmd)) ||
|
|
|
|
!scsi_eh_tur(scmd);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
|
|
|
|
if (scmd->device == sdev) {
|
|
|
|
if (finish_cmds)
|
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
else
|
|
|
|
list_move_tail(&scmd->eh_entry, work_q);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list_empty(work_q);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
2007-11-03 19:30:39 +01:00
|
|
|
* scsi_eh_abort_cmds - abort pending commands.
|
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Decription:
|
|
|
|
* Try and see whether or not it makes sense to try and abort the
|
2007-11-03 19:30:39 +01:00
|
|
|
* running command. This only works out to be the case if we have one
|
|
|
|
* command that has timed out. If the command simply failed, it makes
|
2005-04-17 00:20:36 +02:00
|
|
|
* no sense to try and abort the command, since as far as the shost
|
|
|
|
* adapter is concerned, it isn't running.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_abort_cmds(struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *next;
|
2011-05-19 20:41:12 +02:00
|
|
|
LIST_HEAD(check_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
int rtn;
|
|
|
|
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
|
2005-06-19 13:43:26 +02:00
|
|
|
if (!(scmd->eh_eflags & SCSI_EH_CANCEL_CMD))
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting cmd:"
|
|
|
|
"0x%p\n", current->comm,
|
|
|
|
scmd));
|
2011-03-21 20:47:31 +01:00
|
|
|
rtn = scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd);
|
2010-03-24 16:50:30 +01:00
|
|
|
if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
|
2005-06-19 13:43:26 +02:00
|
|
|
scmd->eh_eflags &= ~SCSI_EH_CANCEL_CMD;
|
2011-05-19 20:41:12 +02:00
|
|
|
if (rtn == FAST_IO_FAIL)
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
2011-05-19 20:41:12 +02:00
|
|
|
else
|
|
|
|
list_move_tail(&scmd->eh_entry, &check_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting"
|
|
|
|
" cmd failed:"
|
|
|
|
"0x%p\n",
|
|
|
|
current->comm,
|
|
|
|
scmd));
|
|
|
|
}
|
|
|
|
|
2011-05-19 20:41:12 +02:00
|
|
|
return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_try_stu - Send START_UNIT to device.
|
2007-11-03 19:30:39 +01:00
|
|
|
* @scmd: &scsi_cmnd to send START_UNIT
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 0 - Device is ready. 1 - Device NOT ready.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0};
|
|
|
|
|
2006-07-08 20:42:15 +02:00
|
|
|
if (scmd->device->allow_restart) {
|
2007-03-29 22:25:52 +02:00
|
|
|
int i, rtn = NEEDS_RETRY;
|
|
|
|
|
|
|
|
for (i = 0; rtn == NEEDS_RETRY && i < 2; i++)
|
2008-11-30 17:32:26 +01:00
|
|
|
rtn = scsi_send_eh_cmnd(scmd, stu_command, 6, scmd->device->request_queue->rq_timeout, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-08 20:42:15 +02:00
|
|
|
if (rtn == SUCCESS)
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_stu - send START_UNIT if needed
|
2007-11-03 19:30:39 +01:00
|
|
|
* @shost: &scsi host being recovered.
|
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* If commands are failing due to not ready, initializing command required,
|
2011-03-21 20:47:31 +01:00
|
|
|
* try revalidating the device, which will end up sending a start unit.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_stu(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *stu_scmd, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct scsi_device *sdev;
|
|
|
|
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
stu_scmd = NULL;
|
|
|
|
list_for_each_entry(scmd, work_q, eh_entry)
|
|
|
|
if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
|
|
|
|
scsi_check_sense(scmd) == FAILED ) {
|
|
|
|
stu_scmd = scmd;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!stu_scmd)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending START_UNIT to sdev:"
|
|
|
|
" 0x%p\n", current->comm, sdev));
|
|
|
|
|
|
|
|
if (!scsi_eh_try_stu(stu_scmd)) {
|
|
|
|
if (!scsi_device_online(sdev) ||
|
|
|
|
!scsi_eh_tur(stu_scmd)) {
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next,
|
|
|
|
work_q, eh_entry) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (scmd->device == sdev)
|
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
|
|
|
printk("%s: START_UNIT failed to sdev:"
|
|
|
|
" 0x%p\n", current->comm, sdev));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return list_empty(work_q);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_bus_device_reset - send bdr if needed
|
|
|
|
* @shost: scsi host being recovered.
|
2007-11-03 19:30:39 +01:00
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
2007-11-03 19:30:39 +01:00
|
|
|
* Try a bus device reset. Still, look to see whether we have multiple
|
2005-04-17 00:20:36 +02:00
|
|
|
* devices that are jammed or not - if we have multiple devices, it
|
|
|
|
* makes no sense to try bus_device_reset - we really would need to try
|
2011-03-21 20:47:31 +01:00
|
|
|
* a bus_reset instead.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *bdr_scmd, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct scsi_device *sdev;
|
|
|
|
int rtn;
|
|
|
|
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
bdr_scmd = NULL;
|
|
|
|
list_for_each_entry(scmd, work_q, eh_entry)
|
|
|
|
if (scmd->device == sdev) {
|
|
|
|
bdr_scmd = scmd;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdr_scmd)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BDR sdev:"
|
|
|
|
" 0x%p\n", current->comm,
|
|
|
|
sdev));
|
|
|
|
rtn = scsi_try_bus_device_reset(bdr_scmd);
|
2010-03-24 16:50:30 +01:00
|
|
|
if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!scsi_device_online(sdev) ||
|
2010-03-24 16:50:30 +01:00
|
|
|
rtn == FAST_IO_FAIL ||
|
2005-04-17 00:20:36 +02:00
|
|
|
!scsi_eh_tur(bdr_scmd)) {
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next,
|
|
|
|
work_q, eh_entry) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (scmd->device == sdev)
|
|
|
|
scsi_eh_finish_cmd(scmd,
|
|
|
|
done_q);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BDR"
|
|
|
|
" failed sdev:"
|
|
|
|
"0x%p\n",
|
|
|
|
current->comm,
|
|
|
|
sdev));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return list_empty(work_q);
|
|
|
|
}
|
|
|
|
|
2008-03-01 01:25:19 +01:00
|
|
|
/**
|
|
|
|
* scsi_eh_target_reset - send target reset if needed
|
|
|
|
* @shost: scsi host being recovered.
|
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Try a target reset.
|
|
|
|
*/
|
|
|
|
static int scsi_eh_target_reset(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2010-10-25 22:53:41 +02:00
|
|
|
LIST_HEAD(tmp_list);
|
2011-05-19 20:41:12 +02:00
|
|
|
LIST_HEAD(check_list);
|
2008-03-01 01:25:19 +01:00
|
|
|
|
2010-10-25 22:53:41 +02:00
|
|
|
list_splice_init(work_q, &tmp_list);
|
|
|
|
|
|
|
|
while (!list_empty(&tmp_list)) {
|
|
|
|
struct scsi_cmnd *next, *scmd;
|
|
|
|
int rtn;
|
|
|
|
unsigned int id;
|
|
|
|
|
|
|
|
scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
|
|
|
|
id = scmd_id(scmd);
|
2008-03-01 01:25:19 +01:00
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending target reset "
|
|
|
|
"to target %d\n",
|
|
|
|
current->comm, id));
|
2010-10-25 22:53:41 +02:00
|
|
|
rtn = scsi_try_target_reset(scmd);
|
|
|
|
if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
|
2008-03-01 01:25:19 +01:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Target reset"
|
|
|
|
" failed target: "
|
|
|
|
"%d\n",
|
|
|
|
current->comm, id));
|
2010-10-25 22:53:41 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, &tmp_list, eh_entry) {
|
|
|
|
if (scmd_id(scmd) != id)
|
|
|
|
continue;
|
|
|
|
|
2011-05-19 20:41:12 +02:00
|
|
|
if (rtn == SUCCESS)
|
|
|
|
list_move_tail(&scmd->eh_entry, &check_list);
|
|
|
|
else if (rtn == FAST_IO_FAIL)
|
2010-10-25 22:53:41 +02:00
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
else
|
|
|
|
/* push back on work queue for further processing */
|
|
|
|
list_move(&scmd->eh_entry, work_q);
|
|
|
|
}
|
|
|
|
}
|
2008-03-01 01:25:19 +01:00
|
|
|
|
2011-05-19 20:41:12 +02:00
|
|
|
return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
|
2008-03-01 01:25:19 +01:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
2011-03-21 20:47:31 +01:00
|
|
|
* scsi_eh_bus_reset - send a bus reset
|
2007-11-03 19:30:39 +01:00
|
|
|
* @shost: &scsi host being recovered.
|
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_bus_reset(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *chan_scmd, *next;
|
2011-05-19 20:41:12 +02:00
|
|
|
LIST_HEAD(check_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int channel;
|
|
|
|
int rtn;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we really want to loop over the various channels, and do this on
|
|
|
|
* a channel by channel basis. we should also check to see if any
|
|
|
|
* of the failed commands are on soft_reset devices, and if so, skip
|
2011-03-21 20:47:31 +01:00
|
|
|
* the reset.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
for (channel = 0; channel <= shost->max_channel; channel++) {
|
|
|
|
chan_scmd = NULL;
|
|
|
|
list_for_each_entry(scmd, work_q, eh_entry) {
|
2005-10-25 00:05:09 +02:00
|
|
|
if (channel == scmd_channel(scmd)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
chan_scmd = scmd;
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* FIXME add back in some support for
|
|
|
|
* soft_reset devices.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!chan_scmd)
|
|
|
|
continue;
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BRST chan:"
|
|
|
|
" %d\n", current->comm,
|
|
|
|
channel));
|
|
|
|
rtn = scsi_try_bus_reset(chan_scmd);
|
2010-03-24 16:50:30 +01:00
|
|
|
if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
|
2011-05-19 20:41:12 +02:00
|
|
|
if (channel == scmd_channel(scmd)) {
|
|
|
|
if (rtn == FAST_IO_FAIL)
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_eh_finish_cmd(scmd,
|
|
|
|
done_q);
|
2011-05-19 20:41:12 +02:00
|
|
|
else
|
|
|
|
list_move_tail(&scmd->eh_entry,
|
|
|
|
&check_list);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BRST"
|
|
|
|
" failed chan: %d\n",
|
|
|
|
current->comm,
|
|
|
|
channel));
|
|
|
|
}
|
|
|
|
}
|
2011-05-19 20:41:12 +02:00
|
|
|
return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-03-21 20:47:31 +01:00
|
|
|
* scsi_eh_host_reset - send a host reset
|
2005-04-17 00:20:36 +02:00
|
|
|
* @work_q: list_head for processed commands.
|
|
|
|
* @done_q: list_head for processed commands.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int scsi_eh_host_reset(struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *next;
|
2011-05-19 20:41:12 +02:00
|
|
|
LIST_HEAD(check_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
int rtn;
|
|
|
|
|
|
|
|
if (!list_empty(work_q)) {
|
|
|
|
scmd = list_entry(work_q->next,
|
|
|
|
struct scsi_cmnd, eh_entry);
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending HRST\n"
|
|
|
|
, current->comm));
|
|
|
|
|
|
|
|
rtn = scsi_try_host_reset(scmd);
|
2011-05-19 20:41:12 +02:00
|
|
|
if (rtn == SUCCESS) {
|
|
|
|
list_splice_init(work_q, &check_list);
|
|
|
|
} else if (rtn == FAST_IO_FAIL) {
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: HRST"
|
|
|
|
" failed\n",
|
|
|
|
current->comm));
|
|
|
|
}
|
|
|
|
}
|
2011-05-19 20:41:12 +02:00
|
|
|
return scsi_eh_test_devices(&check_list, work_q, done_q, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_offline_sdevs - offline scsi devices that fail to recover
|
|
|
|
* @work_q: list_head for processed commands.
|
|
|
|
* @done_q: list_head for processed commands.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void scsi_eh_offline_sdevs(struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
|
2007-08-17 19:02:10 +02:00
|
|
|
sdev_printk(KERN_INFO, scmd->device, "Device offlined - "
|
|
|
|
"not ready after error recovery\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_device_set_state(scmd->device, SDEV_OFFLINE);
|
2005-06-19 13:43:26 +02:00
|
|
|
if (scmd->eh_eflags & SCSI_EH_CANCEL_CMD) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* FIXME: Handle lost cmds.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
scsi_eh_finish_cmd(scmd, done_q);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-20 01:45:31 +02:00
|
|
|
/**
|
|
|
|
* scsi_noretry_cmd - determinte if command should be failed fast
|
|
|
|
* @scmd: SCSI cmd to examine.
|
|
|
|
*/
|
|
|
|
int scsi_noretry_cmd(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
switch (host_byte(scmd->result)) {
|
|
|
|
case DID_OK:
|
|
|
|
break;
|
|
|
|
case DID_BUS_BUSY:
|
2010-08-07 18:17:56 +02:00
|
|
|
return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
|
2008-08-20 01:45:31 +02:00
|
|
|
case DID_PARITY:
|
2010-08-07 18:17:56 +02:00
|
|
|
return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
|
2008-08-20 01:45:31 +02:00
|
|
|
case DID_ERROR:
|
|
|
|
if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
|
|
|
|
status_byte(scmd->result) == RESERVATION_CONFLICT)
|
|
|
|
return 0;
|
|
|
|
/* fall through */
|
|
|
|
case DID_SOFT_ERROR:
|
2010-08-07 18:17:56 +02:00
|
|
|
return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
|
2008-08-20 01:45:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (status_byte(scmd->result)) {
|
|
|
|
case CHECK_CONDITION:
|
|
|
|
/*
|
|
|
|
* assume caller has checked sense and determinted
|
|
|
|
* the check condition was retryable.
|
|
|
|
*/
|
2010-07-09 02:38:26 +02:00
|
|
|
if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
|
|
|
|
scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
|
|
|
|
return 1;
|
2008-08-20 01:45:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* scsi_decide_disposition - Disposition a cmd on return from LLD.
|
|
|
|
* @scmd: SCSI cmd to examine.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* This is *only* called when we are examining the status after sending
|
|
|
|
* out the actual data command. any commands that are queued for error
|
|
|
|
* recovery (e.g. test_unit_ready) do *not* come through here.
|
|
|
|
*
|
|
|
|
* When this routine returns failed, it means the error handler thread
|
|
|
|
* is woken. In cases where the error code indicates an error that
|
|
|
|
* doesn't require the error handler read (i.e. we don't need to
|
|
|
|
* abort/reset), this function should return SUCCESS.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_decide_disposition(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
int rtn;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the device is offline, then we clearly just pass the result back
|
|
|
|
* up to the top level.
|
|
|
|
*/
|
|
|
|
if (!scsi_device_online(scmd->device)) {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(5, printk("%s: device offline - report"
|
|
|
|
" as SUCCESS\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__));
|
2005-04-17 00:20:36 +02:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* first check the host byte, to see if there is anything in there
|
|
|
|
* that would indicate what we need to do.
|
|
|
|
*/
|
|
|
|
switch (host_byte(scmd->result)) {
|
|
|
|
case DID_PASSTHROUGH:
|
|
|
|
/*
|
|
|
|
* no matter what, pass this through to the upper layer.
|
|
|
|
* nuke this special code so that it looks like we are saying
|
|
|
|
* did_ok.
|
|
|
|
*/
|
|
|
|
scmd->result &= 0xff00ffff;
|
|
|
|
return SUCCESS;
|
|
|
|
case DID_OK:
|
|
|
|
/*
|
|
|
|
* looks good. drop through, and check the next byte.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case DID_NO_CONNECT:
|
|
|
|
case DID_BAD_TARGET:
|
|
|
|
case DID_ABORT:
|
|
|
|
/*
|
|
|
|
* note - this means that we just report the status back
|
|
|
|
* to the top level driver, not that we actually think
|
|
|
|
* that it indicates SUCCESS.
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
|
|
|
/*
|
|
|
|
* when the low level driver returns did_soft_error,
|
2011-03-21 20:47:31 +01:00
|
|
|
* it is responsible for keeping an internal retry counter
|
2005-04-17 00:20:36 +02:00
|
|
|
* in order to avoid endless loops (db)
|
|
|
|
*
|
|
|
|
* actually this is a bug in this function here. we should
|
|
|
|
* be mindful of the maximum number of retries specified
|
|
|
|
* and not get stuck in a loop.
|
|
|
|
*/
|
|
|
|
case DID_SOFT_ERROR:
|
|
|
|
goto maybe_retry;
|
|
|
|
case DID_IMM_RETRY:
|
|
|
|
return NEEDS_RETRY;
|
|
|
|
|
2005-04-13 00:49:09 +02:00
|
|
|
case DID_REQUEUE:
|
|
|
|
return ADD_TO_MLQUEUE;
|
[SCSI] scsi: add transport host byte errors (v3)
Currently, if there is a transport problem the iscsi drivers will return
outstanding commands (commands being exeucted by the driver/fw/hw) with
DID_BUS_BUSY and block the session so no new commands can be queued.
Commands that are caught between the failure handling and blocking are
failed with DID_IMM_RETRY or one of the scsi ml queuecommand return values.
When the recovery_timeout fires, the iscsi drivers then fail IO with
DID_NO_CONNECT.
For fcp, some drivers will fail some outstanding IO (disk but possibly not
tape) with DID_BUS_BUSY or DID_ERROR or some other value that causes a retry
and hits the scsi_error.c failfast check, block the rport, and commands
caught in the race are failed with DID_IMM_RETRY. Other drivers, may
hold onto all IO and wait for the terminate_rport_io or dev_loss_tmo_callbk
to be called.
The following patches attempt to unify what upper layers will see drivers
like multipath can make a good guess. This relies on drivers being
hooked into their transport class.
This first patch just defines two new host byte errors so drivers can
return the same value for when a rport/session is blocked and for
when the fast_io_fail_tmo fires.
The idea is that if the LLD/class detects a problem and is going to block
a rport/session, then if the LLD wants or must return the command to scsi-ml,
then it can return it with DID_TRANSPORT_DISRUPTED. This will requeue
the IO into the same scsi queue it came from, until the fast io fail timer
fires and the class decides what to do.
When using multipath and the fast_io_fail_tmo fires then the class
can fail commands with DID_TRANSPORT_FAILFAST or drivers can use
DID_TRANSPORT_FAILFAST in their terminate_rport_io callbacks or
the equivlent in iscsi if we ever implement more advanced recovery methods.
A LLD, like lpfc, could continue to return DID_ERROR and then it will hit
the normal failfast path, so drivers do not have fully be ported to
work better. The point of the patches is that upper layers will
not see a failure that could be recovered from while the rport/session is
blocked until fast_io_fail_tmo/recovery_timeout fires.
V3
Remove some comments.
V2
Fixed patch/diff errors and renamed DID_TRANSPORT_BLOCKED to
DID_TRANSPORT_DISRUPTED.
V1
initial patch.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-20 01:45:25 +02:00
|
|
|
case DID_TRANSPORT_DISRUPTED:
|
|
|
|
/*
|
|
|
|
* LLD/transport was disrupted during processing of the IO.
|
|
|
|
* The transport class is now blocked/blocking,
|
|
|
|
* and the transport will decide what to do with the IO
|
2008-11-05 02:47:19 +01:00
|
|
|
* based on its timers and recovery capablilities if
|
|
|
|
* there are enough retries.
|
[SCSI] scsi: add transport host byte errors (v3)
Currently, if there is a transport problem the iscsi drivers will return
outstanding commands (commands being exeucted by the driver/fw/hw) with
DID_BUS_BUSY and block the session so no new commands can be queued.
Commands that are caught between the failure handling and blocking are
failed with DID_IMM_RETRY or one of the scsi ml queuecommand return values.
When the recovery_timeout fires, the iscsi drivers then fail IO with
DID_NO_CONNECT.
For fcp, some drivers will fail some outstanding IO (disk but possibly not
tape) with DID_BUS_BUSY or DID_ERROR or some other value that causes a retry
and hits the scsi_error.c failfast check, block the rport, and commands
caught in the race are failed with DID_IMM_RETRY. Other drivers, may
hold onto all IO and wait for the terminate_rport_io or dev_loss_tmo_callbk
to be called.
The following patches attempt to unify what upper layers will see drivers
like multipath can make a good guess. This relies on drivers being
hooked into their transport class.
This first patch just defines two new host byte errors so drivers can
return the same value for when a rport/session is blocked and for
when the fast_io_fail_tmo fires.
The idea is that if the LLD/class detects a problem and is going to block
a rport/session, then if the LLD wants or must return the command to scsi-ml,
then it can return it with DID_TRANSPORT_DISRUPTED. This will requeue
the IO into the same scsi queue it came from, until the fast io fail timer
fires and the class decides what to do.
When using multipath and the fast_io_fail_tmo fires then the class
can fail commands with DID_TRANSPORT_FAILFAST or drivers can use
DID_TRANSPORT_FAILFAST in their terminate_rport_io callbacks or
the equivlent in iscsi if we ever implement more advanced recovery methods.
A LLD, like lpfc, could continue to return DID_ERROR and then it will hit
the normal failfast path, so drivers do not have fully be ported to
work better. The point of the patches is that upper layers will
not see a failure that could be recovered from while the rport/session is
blocked until fast_io_fail_tmo/recovery_timeout fires.
V3
Remove some comments.
V2
Fixed patch/diff errors and renamed DID_TRANSPORT_BLOCKED to
DID_TRANSPORT_DISRUPTED.
V1
initial patch.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-20 01:45:25 +02:00
|
|
|
*/
|
2008-11-05 02:47:19 +01:00
|
|
|
goto maybe_retry;
|
[SCSI] scsi: add transport host byte errors (v3)
Currently, if there is a transport problem the iscsi drivers will return
outstanding commands (commands being exeucted by the driver/fw/hw) with
DID_BUS_BUSY and block the session so no new commands can be queued.
Commands that are caught between the failure handling and blocking are
failed with DID_IMM_RETRY or one of the scsi ml queuecommand return values.
When the recovery_timeout fires, the iscsi drivers then fail IO with
DID_NO_CONNECT.
For fcp, some drivers will fail some outstanding IO (disk but possibly not
tape) with DID_BUS_BUSY or DID_ERROR or some other value that causes a retry
and hits the scsi_error.c failfast check, block the rport, and commands
caught in the race are failed with DID_IMM_RETRY. Other drivers, may
hold onto all IO and wait for the terminate_rport_io or dev_loss_tmo_callbk
to be called.
The following patches attempt to unify what upper layers will see drivers
like multipath can make a good guess. This relies on drivers being
hooked into their transport class.
This first patch just defines two new host byte errors so drivers can
return the same value for when a rport/session is blocked and for
when the fast_io_fail_tmo fires.
The idea is that if the LLD/class detects a problem and is going to block
a rport/session, then if the LLD wants or must return the command to scsi-ml,
then it can return it with DID_TRANSPORT_DISRUPTED. This will requeue
the IO into the same scsi queue it came from, until the fast io fail timer
fires and the class decides what to do.
When using multipath and the fast_io_fail_tmo fires then the class
can fail commands with DID_TRANSPORT_FAILFAST or drivers can use
DID_TRANSPORT_FAILFAST in their terminate_rport_io callbacks or
the equivlent in iscsi if we ever implement more advanced recovery methods.
A LLD, like lpfc, could continue to return DID_ERROR and then it will hit
the normal failfast path, so drivers do not have fully be ported to
work better. The point of the patches is that upper layers will
not see a failure that could be recovered from while the rport/session is
blocked until fast_io_fail_tmo/recovery_timeout fires.
V3
Remove some comments.
V2
Fixed patch/diff errors and renamed DID_TRANSPORT_BLOCKED to
DID_TRANSPORT_DISRUPTED.
V1
initial patch.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-20 01:45:25 +02:00
|
|
|
case DID_TRANSPORT_FAILFAST:
|
|
|
|
/*
|
|
|
|
* The transport decided to failfast the IO (most likely
|
|
|
|
* the fast io fail tmo fired), so send IO directly upwards.
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
2005-04-17 00:20:36 +02:00
|
|
|
case DID_ERROR:
|
|
|
|
if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
|
|
|
|
status_byte(scmd->result) == RESERVATION_CONFLICT)
|
|
|
|
/*
|
|
|
|
* execute reservation conflict processing code
|
|
|
|
* lower down
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
/* fallthrough */
|
|
|
|
case DID_BUS_BUSY:
|
|
|
|
case DID_PARITY:
|
|
|
|
goto maybe_retry;
|
|
|
|
case DID_TIME_OUT:
|
|
|
|
/*
|
|
|
|
* when we scan the bus, we get timeout messages for
|
|
|
|
* these commands if there is no device available.
|
|
|
|
* other hosts report did_no_connect for the same thing.
|
|
|
|
*/
|
|
|
|
if ((scmd->cmnd[0] == TEST_UNIT_READY ||
|
|
|
|
scmd->cmnd[0] == INQUIRY)) {
|
|
|
|
return SUCCESS;
|
|
|
|
} else {
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
case DID_RESET:
|
|
|
|
return SUCCESS;
|
|
|
|
default:
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* next, check the message byte.
|
|
|
|
*/
|
|
|
|
if (msg_byte(scmd->result) != COMMAND_COMPLETE)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check the status byte to see if this indicates anything special.
|
|
|
|
*/
|
|
|
|
switch (status_byte(scmd->result)) {
|
|
|
|
case QUEUE_FULL:
|
2009-10-16 02:46:44 +02:00
|
|
|
scsi_handle_queue_full(scmd->device);
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* the case of trying to send too many commands to a
|
|
|
|
* tagged queueing device.
|
|
|
|
*/
|
|
|
|
case BUSY:
|
|
|
|
/*
|
|
|
|
* device can't talk to us at the moment. Should only
|
|
|
|
* occur (SAM-3) when the task queue is empty, so will cause
|
|
|
|
* the empty queue handling to trigger a stall in the
|
|
|
|
* device.
|
|
|
|
*/
|
|
|
|
return ADD_TO_MLQUEUE;
|
|
|
|
case GOOD:
|
2009-10-23 00:46:33 +02:00
|
|
|
scsi_handle_queue_ramp_up(scmd->device);
|
2005-04-17 00:20:36 +02:00
|
|
|
case COMMAND_TERMINATED:
|
|
|
|
return SUCCESS;
|
2008-11-06 11:57:52 +01:00
|
|
|
case TASK_ABORTED:
|
|
|
|
goto maybe_retry;
|
2005-04-17 00:20:36 +02:00
|
|
|
case CHECK_CONDITION:
|
|
|
|
rtn = scsi_check_sense(scmd);
|
|
|
|
if (rtn == NEEDS_RETRY)
|
|
|
|
goto maybe_retry;
|
2011-01-18 10:13:11 +01:00
|
|
|
else if (rtn == TARGET_ERROR) {
|
|
|
|
/*
|
|
|
|
* Need to modify host byte to signal a
|
|
|
|
* permanent target failure
|
|
|
|
*/
|
|
|
|
scmd->result |= (DID_TARGET_FAILURE << 16);
|
|
|
|
rtn = SUCCESS;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
/* if rtn == FAILED, we have no sense information;
|
|
|
|
* returning FAILED will wake the error handler thread
|
|
|
|
* to collect the sense and redo the decide
|
|
|
|
* disposition */
|
|
|
|
return rtn;
|
|
|
|
case CONDITION_GOOD:
|
|
|
|
case INTERMEDIATE_GOOD:
|
|
|
|
case INTERMEDIATE_C_GOOD:
|
|
|
|
case ACA_ACTIVE:
|
|
|
|
/*
|
|
|
|
* who knows? FIXME(eric)
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
|
|
|
|
|
|
|
case RESERVATION_CONFLICT:
|
2005-10-02 18:45:08 +02:00
|
|
|
sdev_printk(KERN_INFO, scmd->device,
|
|
|
|
"reservation conflict\n");
|
2011-01-18 10:13:11 +01:00
|
|
|
scmd->result |= (DID_NEXUS_FAILURE << 16);
|
2005-04-17 00:20:36 +02:00
|
|
|
return SUCCESS; /* causes immediate i/o error */
|
|
|
|
default:
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
maybe_retry:
|
|
|
|
|
|
|
|
/* we requeue for retry because the error was retryable, and
|
|
|
|
* the request was not marked fast fail. Note that above,
|
|
|
|
* even if the request is marked fast fail, we still requeue
|
|
|
|
* for queue congestion conditions (QUEUE_FULL or BUSY) */
|
2006-02-25 00:10:04 +01:00
|
|
|
if ((++scmd->retries) <= scmd->allowed
|
2008-08-20 01:45:31 +02:00
|
|
|
&& !scsi_noretry_cmd(scmd)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
return NEEDS_RETRY;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* no more retries - report this one back to upper level.
|
|
|
|
*/
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-13 17:23:45 +01:00
|
|
|
static void eh_lock_door_done(struct request *req, int uptodate)
|
|
|
|
{
|
|
|
|
__blk_put_request(req->q, req);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* scsi_eh_lock_door - Prevent medium removal for the specified device
|
|
|
|
* @sdev: SCSI device to prevent medium removal
|
|
|
|
*
|
|
|
|
* Locking:
|
2009-05-17 16:30:48 +02:00
|
|
|
* We must be called from process context.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the
|
|
|
|
* head of the devices request queue, and continue.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void scsi_eh_lock_door(struct scsi_device *sdev)
|
|
|
|
{
|
2008-12-13 17:23:45 +01:00
|
|
|
struct request *req;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-05-17 16:30:48 +02:00
|
|
|
/*
|
|
|
|
* blk_get_request with GFP_KERNEL (__GFP_WAIT) sleeps until a
|
|
|
|
* request becomes available
|
|
|
|
*/
|
2008-12-13 17:23:45 +01:00
|
|
|
req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-13 17:23:45 +01:00
|
|
|
req->cmd[0] = ALLOW_MEDIUM_REMOVAL;
|
|
|
|
req->cmd[1] = 0;
|
|
|
|
req->cmd[2] = 0;
|
|
|
|
req->cmd[3] = 0;
|
|
|
|
req->cmd[4] = SCSI_REMOVAL_PREVENT;
|
|
|
|
req->cmd[5] = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-13 17:23:45 +01:00
|
|
|
req->cmd_len = COMMAND_SIZE(req->cmd[0]);
|
|
|
|
|
|
|
|
req->cmd_type = REQ_TYPE_BLOCK_PC;
|
|
|
|
req->cmd_flags |= REQ_QUIET;
|
|
|
|
req->timeout = 10 * HZ;
|
|
|
|
req->retries = 5;
|
|
|
|
|
|
|
|
blk_execute_rq_nowait(req->q, NULL, req, 1, eh_lock_door_done);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_restart_operations - restart io operations to the specified host.
|
|
|
|
* @shost: Host we are restarting.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* When we entered the error handler, we blocked all further i/o to
|
|
|
|
* this device. we need to 'reverse' this process.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void scsi_restart_operations(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
2005-09-18 22:05:20 +02:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the door was locked, we need to insert a door lock request
|
|
|
|
* onto the head of the SCSI request queue for the device. There
|
|
|
|
* is no point trying to lock the door of an off-line device.
|
|
|
|
*/
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
if (scsi_device_online(sdev) && sdev->locked)
|
|
|
|
scsi_eh_lock_door(sdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* next free up anything directly waiting upon the host. this
|
|
|
|
* will be requests for character device operations, and also for
|
|
|
|
* ioctls to queued block devices.
|
|
|
|
*/
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: waking up host to restart\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-18 22:05:20 +02:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
if (scsi_host_set_state(shost, SHOST_RUNNING))
|
|
|
|
if (scsi_host_set_state(shost, SHOST_CANCEL))
|
|
|
|
BUG_ON(scsi_host_set_state(shost, SHOST_DEL));
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
wake_up(&shost->host_wait);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* finally we need to re-initiate requests that may be pending. we will
|
|
|
|
* have had everything blocked while error handling is taking place, and
|
|
|
|
* now that error recovery is done, we will need to ensure that these
|
|
|
|
* requests are started.
|
|
|
|
*/
|
|
|
|
scsi_run_host_queues(shost);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_ready_devs - check device ready state and recover if not.
|
|
|
|
* @shost: host to be recovered.
|
2007-11-03 19:30:39 +01:00
|
|
|
* @work_q: &list_head for pending commands.
|
|
|
|
* @done_q: &list_head for processed commands.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2007-01-26 23:08:49 +01:00
|
|
|
void scsi_eh_ready_devs(struct Scsi_Host *shost,
|
|
|
|
struct list_head *work_q,
|
|
|
|
struct list_head *done_q)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (!scsi_eh_stu(shost, work_q, done_q))
|
|
|
|
if (!scsi_eh_bus_device_reset(shost, work_q, done_q))
|
2008-03-01 01:25:19 +01:00
|
|
|
if (!scsi_eh_target_reset(shost, work_q, done_q))
|
|
|
|
if (!scsi_eh_bus_reset(shost, work_q, done_q))
|
|
|
|
if (!scsi_eh_host_reset(work_q, done_q))
|
|
|
|
scsi_eh_offline_sdevs(work_q,
|
|
|
|
done_q);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-01-26 23:08:49 +01:00
|
|
|
EXPORT_SYMBOL_GPL(scsi_eh_ready_devs);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_eh_flush_done_q - finish processed commands or retry them.
|
|
|
|
* @done_q: list_head of processed commands.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2006-01-23 05:09:36 +01:00
|
|
|
void scsi_eh_flush_done_q(struct list_head *done_q)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-19 13:43:56 +02:00
|
|
|
struct scsi_cmnd *scmd, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-19 13:43:56 +02:00
|
|
|
list_for_each_entry_safe(scmd, next, done_q, eh_entry) {
|
|
|
|
list_del_init(&scmd->eh_entry);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (scsi_device_online(scmd->device) &&
|
2008-08-20 01:45:31 +02:00
|
|
|
!scsi_noretry_cmd(scmd) &&
|
2006-02-25 00:10:04 +01:00
|
|
|
(++scmd->retries <= scmd->allowed)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush"
|
|
|
|
" retry cmd: %p\n",
|
|
|
|
current->comm,
|
|
|
|
scmd));
|
|
|
|
scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
|
|
|
|
} else {
|
2005-05-17 02:42:15 +02:00
|
|
|
/*
|
|
|
|
* If just we got sense for the device (called
|
|
|
|
* scsi_eh_get_sense), scmd->result is already
|
|
|
|
* set, do not set DRIVER_TIMEOUT.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!scmd->result)
|
|
|
|
scmd->result |= (DRIVER_TIMEOUT << 24);
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush finish"
|
|
|
|
" cmd: %p\n",
|
|
|
|
current->comm, scmd));
|
|
|
|
scsi_finish_command(scmd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-01-23 05:09:36 +01:00
|
|
|
EXPORT_SYMBOL(scsi_eh_flush_done_q);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_unjam_host - Attempt to fix a host which has a cmd that failed.
|
|
|
|
* @shost: Host to unjam.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* When we come in here, we *know* that all commands on the bus have
|
|
|
|
* either completed, failed or timed out. we also know that no further
|
|
|
|
* commands are being sent to the host, so things are relatively quiet
|
|
|
|
* and we have freedom to fiddle with things as we wish.
|
|
|
|
*
|
|
|
|
* This is only the *default* implementation. it is possible for
|
|
|
|
* individual drivers to supply their own version of this function, and
|
|
|
|
* if the maintainer wishes to do this, it is strongly suggested that
|
|
|
|
* this function be taken as a template and modified. this function
|
|
|
|
* was designed to correctly handle problems for about 95% of the
|
|
|
|
* different cases out there, and it should always provide at least a
|
|
|
|
* reasonable amount of error recovery.
|
|
|
|
*
|
|
|
|
* Any command marked 'failed' or 'timeout' must eventually have
|
|
|
|
* scsi_finish_cmd() called for it. we do all of the retry stuff
|
|
|
|
* here, so when we restart the host after we return it should have an
|
|
|
|
* empty queue.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void scsi_unjam_host(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(eh_work_q);
|
|
|
|
LIST_HEAD(eh_done_q);
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
list_splice_init(&shost->eh_cmd_q, &eh_work_q);
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q));
|
|
|
|
|
|
|
|
if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q))
|
|
|
|
if (!scsi_eh_abort_cmds(&eh_work_q, &eh_done_q))
|
|
|
|
scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q);
|
|
|
|
|
|
|
|
scsi_eh_flush_done_q(&eh_done_q);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-29 01:01:55 +02:00
|
|
|
* scsi_error_handler - SCSI error handler thread
|
2005-04-17 00:20:36 +02:00
|
|
|
* @data: Host for which we are running.
|
|
|
|
*
|
|
|
|
* Notes:
|
2005-10-29 01:01:55 +02:00
|
|
|
* This is the main error handling loop. This is run as a kernel thread
|
|
|
|
* for every SCSI host and handles all error handling activity.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_error_handler(void *data)
|
|
|
|
{
|
2005-10-29 01:01:55 +02:00
|
|
|
struct Scsi_Host *shost = data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-29 01:01:55 +02:00
|
|
|
* We use TASK_INTERRUPTIBLE so that the thread is not
|
|
|
|
* counted against the load average as a running process.
|
|
|
|
* We never actually get interrupted because kthread_run
|
2008-12-23 00:54:00 +01:00
|
|
|
* disables signal delivery for the created thread.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-09-19 16:50:04 +02:00
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
while (!kthread_should_stop()) {
|
2006-05-15 13:57:20 +02:00
|
|
|
if ((shost->host_failed == 0 && shost->host_eh_scheduled == 0) ||
|
2005-09-19 16:50:04 +02:00
|
|
|
shost->host_failed != shost->host_busy) {
|
2005-10-29 01:01:55 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(1,
|
|
|
|
printk("Error handler scsi_eh_%d sleeping\n",
|
|
|
|
shost->host_no));
|
2005-09-19 16:50:04 +02:00
|
|
|
schedule();
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-19 16:50:04 +02:00
|
|
|
__set_current_state(TASK_RUNNING);
|
2005-10-29 01:01:55 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(1,
|
|
|
|
printk("Error handler scsi_eh_%d waking up\n",
|
|
|
|
shost->host_no));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We have a host that is failing for some reason. Figure out
|
|
|
|
* what we need to do to get it up and online again (if we can).
|
|
|
|
* If we fail, we end up taking the thing offline.
|
|
|
|
*/
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 16:41:42 +02:00
|
|
|
if (scsi_autopm_get_host(shost) != 0) {
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(1,
|
|
|
|
printk(KERN_ERR "Error handler scsi_eh_%d "
|
|
|
|
"unable to autoresume\n",
|
|
|
|
shost->host_no));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-04-01 19:21:04 +02:00
|
|
|
if (shost->transportt->eh_strategy_handler)
|
|
|
|
shost->transportt->eh_strategy_handler(shost);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
scsi_unjam_host(shost);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note - if the above fails completely, the action is to take
|
|
|
|
* individual devices offline and flush the queue of any
|
|
|
|
* outstanding requests that may have been pending. When we
|
|
|
|
* restart, we restart any I/O to any other devices on the bus
|
|
|
|
* which are still online.
|
|
|
|
*/
|
|
|
|
scsi_restart_operations(shost);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 16:41:42 +02:00
|
|
|
scsi_autopm_put_host(shost);
|
2005-09-19 16:50:04 +02:00
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-10-19 14:22:13 +02:00
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
|
2005-10-29 01:01:55 +02:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(1,
|
|
|
|
printk("Error handler scsi_eh_%d exiting\n", shost->host_no));
|
2005-09-19 16:50:04 +02:00
|
|
|
shost->ehandler = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_report_bus_reset()
|
|
|
|
*
|
|
|
|
* Purpose: Utility function used by low-level drivers to report that
|
|
|
|
* they have observed a bus reset on the bus being handled.
|
|
|
|
*
|
|
|
|
* Arguments: shost - Host in question
|
|
|
|
* channel - channel on which reset was observed.
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Lock status: Host lock must be held.
|
|
|
|
*
|
|
|
|
* Notes: This only needs to be called if the reset is one which
|
|
|
|
* originates from an unknown location. Resets originated
|
|
|
|
* by the mid-level itself don't need to call this, but there
|
|
|
|
* should be no harm.
|
|
|
|
*
|
|
|
|
* The main purpose of this is to make sure that a CHECK_CONDITION
|
|
|
|
* is properly treated.
|
|
|
|
*/
|
|
|
|
void scsi_report_bus_reset(struct Scsi_Host *shost, int channel)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
|
|
|
|
__shost_for_each_device(sdev, shost) {
|
2008-03-01 01:25:19 +01:00
|
|
|
if (channel == sdev_channel(sdev))
|
|
|
|
__scsi_report_device_reset(sdev, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_report_bus_reset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_report_device_reset()
|
|
|
|
*
|
|
|
|
* Purpose: Utility function used by low-level drivers to report that
|
|
|
|
* they have observed a device reset on the device being handled.
|
|
|
|
*
|
|
|
|
* Arguments: shost - Host in question
|
|
|
|
* channel - channel on which reset was observed
|
|
|
|
* target - target on which reset was observed
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Lock status: Host lock must be held
|
|
|
|
*
|
|
|
|
* Notes: This only needs to be called if the reset is one which
|
|
|
|
* originates from an unknown location. Resets originated
|
|
|
|
* by the mid-level itself don't need to call this, but there
|
|
|
|
* should be no harm.
|
|
|
|
*
|
|
|
|
* The main purpose of this is to make sure that a CHECK_CONDITION
|
|
|
|
* is properly treated.
|
|
|
|
*/
|
|
|
|
void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
|
|
|
|
__shost_for_each_device(sdev, shost) {
|
2005-10-25 00:05:09 +02:00
|
|
|
if (channel == sdev_channel(sdev) &&
|
2008-03-01 01:25:19 +01:00
|
|
|
target == sdev_id(sdev))
|
|
|
|
__scsi_report_device_reset(sdev, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_report_device_reset);
|
|
|
|
|
|
|
|
static void
|
|
|
|
scsi_reset_provider_done_command(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_reset_provider
|
|
|
|
*
|
|
|
|
* Purpose: Send requested reset to a bus or device at any phase.
|
|
|
|
*
|
|
|
|
* Arguments: device - device to send reset to
|
|
|
|
* flag - reset type (see scsi.h)
|
|
|
|
*
|
|
|
|
* Returns: SUCCESS/FAILURE.
|
|
|
|
*
|
|
|
|
* Notes: This is used by the SCSI Generic driver to provide
|
|
|
|
* Bus/Device reset capability.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
scsi_reset_provider(struct scsi_device *dev, int flag)
|
|
|
|
{
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 16:41:42 +02:00
|
|
|
struct scsi_cmnd *scmd;
|
2006-03-08 20:50:12 +01:00
|
|
|
struct Scsi_Host *shost = dev->host;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct request req;
|
2006-03-08 20:50:12 +01:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
int rtn;
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 16:41:42 +02:00
|
|
|
if (scsi_autopm_get_host(shost) < 0)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
scmd = scsi_get_command(dev, GFP_KERNEL);
|
2008-04-29 09:54:37 +02:00
|
|
|
blk_rq_init(NULL, &req);
|
2005-04-17 00:20:36 +02:00
|
|
|
scmd->request = &req;
|
2005-06-19 13:40:52 +02:00
|
|
|
|
2008-04-30 10:19:47 +02:00
|
|
|
scmd->cmnd = req.cmd;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
scmd->scsi_done = scsi_reset_provider_done_command;
|
2007-12-13 12:47:40 +01:00
|
|
|
memset(&scmd->sdb, 0, sizeof(scmd->sdb));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
scmd->cmd_len = 0;
|
|
|
|
|
|
|
|
scmd->sc_data_direction = DMA_BIDIRECTIONAL;
|
|
|
|
|
2006-03-08 20:50:12 +01:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
shost->tmf_in_progress = 1;
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (flag) {
|
|
|
|
case SCSI_TRY_RESET_DEVICE:
|
|
|
|
rtn = scsi_try_bus_device_reset(scmd);
|
|
|
|
if (rtn == SUCCESS)
|
|
|
|
break;
|
|
|
|
/* FALLTHROUGH */
|
2008-03-01 01:25:19 +01:00
|
|
|
case SCSI_TRY_RESET_TARGET:
|
|
|
|
rtn = scsi_try_target_reset(scmd);
|
|
|
|
if (rtn == SUCCESS)
|
|
|
|
break;
|
|
|
|
/* FALLTHROUGH */
|
2005-04-17 00:20:36 +02:00
|
|
|
case SCSI_TRY_RESET_BUS:
|
|
|
|
rtn = scsi_try_bus_reset(scmd);
|
|
|
|
if (rtn == SUCCESS)
|
|
|
|
break;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case SCSI_TRY_RESET_HOST:
|
|
|
|
rtn = scsi_try_host_reset(scmd);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rtn = FAILED;
|
|
|
|
}
|
|
|
|
|
2006-03-08 20:50:12 +01:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
shost->tmf_in_progress = 0;
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* be sure to wake up anyone who was sleeping or had their queue
|
|
|
|
* suspended while we performed the TMF.
|
|
|
|
*/
|
|
|
|
SCSI_LOG_ERROR_RECOVERY(3,
|
|
|
|
printk("%s: waking up host to restart after TMF\n",
|
2008-07-04 08:47:27 +02:00
|
|
|
__func__));
|
2006-03-08 20:50:12 +01:00
|
|
|
|
|
|
|
wake_up(&shost->host_wait);
|
|
|
|
|
|
|
|
scsi_run_host_queues(shost);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
scsi_next_command(scmd);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 16:41:42 +02:00
|
|
|
scsi_autopm_put_host(shost);
|
2005-04-17 00:20:36 +02:00
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_reset_provider);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_normalize_sense - normalize main elements from either fixed or
|
|
|
|
* descriptor sense data format into a common format.
|
|
|
|
*
|
|
|
|
* @sense_buffer: byte array containing sense data returned by device
|
|
|
|
* @sb_len: number of valid bytes in sense_buffer
|
|
|
|
* @sshdr: pointer to instance of structure that common
|
|
|
|
* elements are written to.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* The "main elements" from sense data are: response_code, sense_key,
|
|
|
|
* asc, ascq and additional_length (only for descriptor format).
|
|
|
|
*
|
|
|
|
* Typically this function can be called after a device has
|
|
|
|
* responded to a SCSI command with the CHECK_CONDITION status.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 1 if valid sense data information found, else 0;
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
2005-08-28 18:31:14 +02:00
|
|
|
if (!sense_buffer || !sb_len)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
|
|
|
|
|
|
|
|
sshdr->response_code = (sense_buffer[0] & 0x7f);
|
2005-08-28 18:31:14 +02:00
|
|
|
|
|
|
|
if (!scsi_sense_valid(sshdr))
|
|
|
|
return 0;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (sshdr->response_code >= 0x72) {
|
|
|
|
/*
|
|
|
|
* descriptor format
|
|
|
|
*/
|
|
|
|
if (sb_len > 1)
|
|
|
|
sshdr->sense_key = (sense_buffer[1] & 0xf);
|
|
|
|
if (sb_len > 2)
|
|
|
|
sshdr->asc = sense_buffer[2];
|
|
|
|
if (sb_len > 3)
|
|
|
|
sshdr->ascq = sense_buffer[3];
|
|
|
|
if (sb_len > 7)
|
|
|
|
sshdr->additional_length = sense_buffer[7];
|
|
|
|
} else {
|
2011-03-21 20:47:31 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* fixed format
|
|
|
|
*/
|
|
|
|
if (sb_len > 2)
|
|
|
|
sshdr->sense_key = (sense_buffer[2] & 0xf);
|
|
|
|
if (sb_len > 7) {
|
|
|
|
sb_len = (sb_len < (sense_buffer[7] + 8)) ?
|
|
|
|
sb_len : (sense_buffer[7] + 8);
|
|
|
|
if (sb_len > 12)
|
|
|
|
sshdr->asc = sense_buffer[12];
|
|
|
|
if (sb_len > 13)
|
|
|
|
sshdr->ascq = sense_buffer[13];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_normalize_sense);
|
|
|
|
|
|
|
|
int scsi_command_normalize_sense(struct scsi_cmnd *cmd,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
|
|
|
return scsi_normalize_sense(cmd->sense_buffer,
|
2008-01-13 07:46:13 +01:00
|
|
|
SCSI_SENSE_BUFFERSIZE, sshdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_command_normalize_sense);
|
|
|
|
|
|
|
|
/**
|
2007-11-03 19:30:39 +01:00
|
|
|
* scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format.
|
2005-04-17 00:20:36 +02:00
|
|
|
* @sense_buffer: byte array of descriptor format sense data
|
|
|
|
* @sb_len: number of valid bytes in sense_buffer
|
|
|
|
* @desc_type: value of descriptor type to find
|
|
|
|
* (e.g. 0 -> information)
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* only valid when sense data is in descriptor format
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* pointer to start of (first) descriptor if found else NULL
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
|
|
|
|
int desc_type)
|
|
|
|
{
|
|
|
|
int add_sen_len, add_len, desc_len, k;
|
|
|
|
const u8 * descp;
|
|
|
|
|
|
|
|
if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7])))
|
|
|
|
return NULL;
|
|
|
|
if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73))
|
|
|
|
return NULL;
|
|
|
|
add_sen_len = (add_sen_len < (sb_len - 8)) ?
|
|
|
|
add_sen_len : (sb_len - 8);
|
|
|
|
descp = &sense_buffer[8];
|
|
|
|
for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
|
|
|
|
descp += desc_len;
|
|
|
|
add_len = (k < (add_sen_len - 1)) ? descp[1]: -1;
|
|
|
|
desc_len = add_len + 2;
|
|
|
|
if (descp[0] == desc_type)
|
|
|
|
return descp;
|
|
|
|
if (add_len < 0) // short descriptor ??
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_sense_desc_find);
|
|
|
|
|
|
|
|
/**
|
2007-11-03 19:30:39 +01:00
|
|
|
* scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format)
|
2005-04-17 00:20:36 +02:00
|
|
|
* @sense_buffer: byte array of sense data
|
|
|
|
* @sb_len: number of valid bytes in sense_buffer
|
|
|
|
* @info_out: pointer to 64 integer where 8 or 4 byte information
|
|
|
|
* field will be placed if found.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 1 if information field found, 0 if not found.
|
2007-11-16 00:42:30 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len,
|
|
|
|
u64 * info_out)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
const u8 * ucp;
|
|
|
|
u64 ull;
|
|
|
|
|
|
|
|
if (sb_len < 7)
|
|
|
|
return 0;
|
|
|
|
switch (sense_buffer[0] & 0x7f) {
|
|
|
|
case 0x70:
|
|
|
|
case 0x71:
|
|
|
|
if (sense_buffer[0] & 0x80) {
|
|
|
|
*info_out = (sense_buffer[3] << 24) +
|
|
|
|
(sense_buffer[4] << 16) +
|
|
|
|
(sense_buffer[5] << 8) + sense_buffer[6];
|
|
|
|
return 1;
|
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
case 0x72:
|
|
|
|
case 0x73:
|
|
|
|
ucp = scsi_sense_desc_find(sense_buffer, sb_len,
|
|
|
|
0 /* info desc */);
|
|
|
|
if (ucp && (0xa == ucp[1])) {
|
|
|
|
ull = 0;
|
|
|
|
for (j = 0; j < 8; ++j) {
|
|
|
|
if (j > 0)
|
|
|
|
ull <<= 8;
|
|
|
|
ull |= ucp[4 + j];
|
|
|
|
}
|
|
|
|
*info_out = ull;
|
|
|
|
return 1;
|
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_get_sense_info_fld);
|
2008-03-25 01:26:49 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_build_sense_buffer - build sense data in a buffer
|
|
|
|
* @desc: Sense format (non zero == descriptor format,
|
|
|
|
* 0 == fixed format)
|
|
|
|
* @buf: Where to build sense data
|
|
|
|
* @key: Sense key
|
|
|
|
* @asc: Additional sense code
|
|
|
|
* @ascq: Additional sense code qualifier
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq)
|
|
|
|
{
|
|
|
|
if (desc) {
|
|
|
|
buf[0] = 0x72; /* descriptor, current */
|
|
|
|
buf[1] = key;
|
|
|
|
buf[2] = asc;
|
|
|
|
buf[3] = ascq;
|
|
|
|
buf[7] = 0;
|
|
|
|
} else {
|
|
|
|
buf[0] = 0x70; /* fixed, current */
|
|
|
|
buf[2] = key;
|
|
|
|
buf[7] = 0xa;
|
|
|
|
buf[12] = asc;
|
|
|
|
buf[13] = ascq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_build_sense_buffer);
|