2006-08-29 08:22:51 -06:00
|
|
|
/*
|
|
|
|
* Serial Attached SCSI (SAS) class SCSI Host glue.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Adaptec, Inc. All rights reserved.
|
|
|
|
* Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
|
|
|
|
*
|
|
|
|
* This file is licensed under GPLv2.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
|
|
* License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
|
|
* USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2007-04-26 07:38:01 -06:00
|
|
|
#include <linux/kthread.h>
|
2008-02-19 11:49:40 -07:00
|
|
|
#include <linux/firmware.h>
|
2011-05-27 07:37:25 -06:00
|
|
|
#include <linux/export.h>
|
2008-02-19 11:49:40 -07:00
|
|
|
#include <linux/ctype.h>
|
2007-04-26 07:38:01 -06:00
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
#include "sas_internal.h"
|
|
|
|
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
#include <scsi/scsi.h>
|
2006-10-30 16:18:39 -07:00
|
|
|
#include <scsi/scsi_eh.h>
|
2006-08-29 08:22:51 -06:00
|
|
|
#include <scsi/scsi_transport.h>
|
|
|
|
#include <scsi/scsi_transport_sas.h>
|
2006-10-18 15:43:37 -06:00
|
|
|
#include <scsi/sas_ata.h>
|
2006-08-29 08:22:51 -06:00
|
|
|
#include "../scsi_sas_internal.h"
|
2006-10-30 16:18:50 -07:00
|
|
|
#include "../scsi_transport_api.h"
|
2007-01-26 15:08:52 -07:00
|
|
|
#include "../scsi_priv.h"
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/blkdev.h>
|
2007-07-17 05:03:35 -06:00
|
|
|
#include <linux/freezer.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 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2006-08-29 08:22:51 -06:00
|
|
|
#include <linux/scatterlist.h>
|
2006-08-10 20:19:47 -06:00
|
|
|
#include <linux/libata.h>
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2011-12-07 00:24:42 -07:00
|
|
|
/* record final status and free the task */
|
|
|
|
static void sas_end_task(struct scsi_cmnd *sc, struct sas_task *task)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
|
|
|
struct task_status_struct *ts = &task->task_status;
|
|
|
|
int hs = 0, stat = 0;
|
|
|
|
|
|
|
|
if (ts->resp == SAS_TASK_UNDELIVERED) {
|
|
|
|
/* transport error */
|
|
|
|
hs = DID_NO_CONNECT;
|
|
|
|
} else { /* ts->resp == SAS_TASK_COMPLETE */
|
|
|
|
/* task delivered, what happened afterwards? */
|
|
|
|
switch (ts->stat) {
|
|
|
|
case SAS_DEV_NO_RESPONSE:
|
|
|
|
case SAS_INTERRUPTED:
|
|
|
|
case SAS_PHY_DOWN:
|
|
|
|
case SAS_NAK_R_ERR:
|
|
|
|
case SAS_OPEN_TO:
|
|
|
|
hs = DID_NO_CONNECT;
|
|
|
|
break;
|
|
|
|
case SAS_DATA_UNDERRUN:
|
2007-05-25 11:46:37 -06:00
|
|
|
scsi_set_resid(sc, ts->residual);
|
|
|
|
if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow)
|
2006-08-29 08:22:51 -06:00
|
|
|
hs = DID_ERROR;
|
|
|
|
break;
|
|
|
|
case SAS_DATA_OVERRUN:
|
|
|
|
hs = DID_ERROR;
|
|
|
|
break;
|
|
|
|
case SAS_QUEUE_FULL:
|
|
|
|
hs = DID_SOFT_ERROR; /* retry */
|
|
|
|
break;
|
|
|
|
case SAS_DEVICE_UNKNOWN:
|
|
|
|
hs = DID_BAD_TARGET;
|
|
|
|
break;
|
|
|
|
case SAS_SG_ERR:
|
|
|
|
hs = DID_PARITY;
|
|
|
|
break;
|
|
|
|
case SAS_OPEN_REJECT:
|
|
|
|
if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY)
|
|
|
|
hs = DID_SOFT_ERROR; /* retry */
|
|
|
|
else
|
|
|
|
hs = DID_ERROR;
|
|
|
|
break;
|
|
|
|
case SAS_PROTO_RESPONSE:
|
|
|
|
SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP "
|
|
|
|
"task; please report this\n",
|
|
|
|
task->dev->port->ha->sas_ha_name);
|
|
|
|
break;
|
|
|
|
case SAS_ABORTED_TASK:
|
|
|
|
hs = DID_ABORT;
|
|
|
|
break;
|
2010-07-27 14:51:13 -06:00
|
|
|
case SAM_STAT_CHECK_CONDITION:
|
2006-08-29 08:22:51 -06:00
|
|
|
memcpy(sc->sense_buffer, ts->buf,
|
2008-01-12 10:20:18 -07:00
|
|
|
min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size));
|
2010-07-27 14:51:13 -06:00
|
|
|
stat = SAM_STAT_CHECK_CONDITION;
|
2006-08-29 08:22:51 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
stat = ts->stat;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-12-07 00:24:42 -07:00
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
sc->result = (hs << 16) | stat;
|
2011-12-07 00:24:42 -07:00
|
|
|
ASSIGN_SAS_TASK(sc, NULL);
|
2006-08-29 08:22:51 -06:00
|
|
|
list_del_init(&task->list);
|
|
|
|
sas_free_task(task);
|
2011-12-07 00:24:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_scsi_task_done(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *sc = task->uldd_task;
|
2011-11-28 12:29:20 -07:00
|
|
|
struct domain_device *dev = task->dev;
|
|
|
|
struct sas_ha_struct *ha = dev->port->ha;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->done_lock, flags);
|
|
|
|
if (test_bit(SAS_HA_FROZEN, &ha->state))
|
|
|
|
task = NULL;
|
|
|
|
else
|
|
|
|
ASSIGN_SAS_TASK(sc, NULL);
|
|
|
|
spin_unlock_irqrestore(&dev->done_lock, flags);
|
2011-12-07 00:24:42 -07:00
|
|
|
|
2011-11-28 12:29:20 -07:00
|
|
|
if (unlikely(!task)) {
|
|
|
|
/* task will be completed by the error handler */
|
2011-12-07 00:24:42 -07:00
|
|
|
SAS_DPRINTK("task done but aborted\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(!sc)) {
|
|
|
|
SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n");
|
|
|
|
list_del_init(&task->list);
|
|
|
|
sas_free_task(task);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sas_end_task(sc, task);
|
2008-02-19 20:48:42 -07:00
|
|
|
sc->scsi_done(sc);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
|
|
|
|
struct domain_device *dev,
|
2006-09-24 19:55:40 -06:00
|
|
|
gfp_t gfp_flags)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
|
|
|
struct sas_task *task = sas_alloc_task(gfp_flags);
|
|
|
|
struct scsi_lun lun;
|
|
|
|
|
|
|
|
if (!task)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
task->uldd_task = cmd;
|
|
|
|
ASSIGN_SAS_TASK(cmd, task);
|
|
|
|
|
|
|
|
task->dev = dev;
|
|
|
|
task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */
|
|
|
|
|
|
|
|
task->ssp_task.retry_count = 1;
|
|
|
|
int_to_scsilun(cmd->device->lun, &lun);
|
|
|
|
memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8);
|
2010-09-03 03:56:16 -06:00
|
|
|
task->ssp_task.task_attr = TASK_ATTR_SIMPLE;
|
2013-05-07 16:38:18 -06:00
|
|
|
task->ssp_task.cmd = cmd;
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2007-05-25 11:46:37 -06:00
|
|
|
task->scatter = scsi_sglist(cmd);
|
|
|
|
task->num_scatter = scsi_sg_count(cmd);
|
|
|
|
task->total_xfer_len = scsi_bufflen(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
task->data_dir = cmd->sc_data_direction;
|
|
|
|
|
|
|
|
task->task_done = sas_scsi_task_done;
|
|
|
|
|
|
|
|
return task;
|
|
|
|
}
|
|
|
|
|
2006-10-18 15:43:37 -06:00
|
|
|
int sas_queue_up(struct sas_task *task)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = task->dev->port->ha;
|
|
|
|
struct scsi_core *core = &sas_ha->core;
|
|
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&core->task_queue_lock, flags);
|
|
|
|
if (sas_ha->lldd_queue_size < core->task_queue_size + 1) {
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
|
|
|
return -SAS_QUEUE_FULL;
|
|
|
|
}
|
|
|
|
list_add_tail(&task->list, &core->task_queue);
|
|
|
|
core->task_queue_size += 1;
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
2007-04-26 07:38:01 -06:00
|
|
|
wake_up_process(core->queue_thread);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-11 12:49:23 -06:00
|
|
|
int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
|
|
|
struct sas_internal *i = to_sas_internal(host->transportt);
|
2011-07-11 12:49:24 -06:00
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
|
|
|
struct sas_ha_struct *sas_ha = dev->port->ha;
|
|
|
|
struct sas_task *task;
|
|
|
|
int res = 0;
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2011-07-11 12:49:24 -06:00
|
|
|
/* If the device fell off, no sense in issuing commands */
|
2012-01-07 01:52:39 -07:00
|
|
|
if (test_bit(SAS_DEV_GONE, &dev->state)) {
|
2011-07-11 12:49:24 -06:00
|
|
|
cmd->result = DID_BAD_TARGET << 16;
|
|
|
|
goto out_done;
|
|
|
|
}
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2011-07-11 12:49:24 -06:00
|
|
|
if (dev_is_sata(dev)) {
|
2011-11-17 18:59:50 -07:00
|
|
|
spin_lock_irq(dev->sata_dev.ap->lock);
|
2011-07-11 12:49:24 -06:00
|
|
|
res = ata_sas_queuecmd(cmd, dev->sata_dev.ap);
|
2011-11-17 18:59:50 -07:00
|
|
|
spin_unlock_irq(dev->sata_dev.ap->lock);
|
2011-07-11 12:49:24 -06:00
|
|
|
return res;
|
|
|
|
}
|
2007-01-30 02:18:35 -07:00
|
|
|
|
2011-07-11 12:49:24 -06:00
|
|
|
task = sas_create_task(cmd, dev, GFP_ATOMIC);
|
|
|
|
if (!task)
|
2011-07-16 13:00:35 -06:00
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
2006-08-10 20:19:47 -06:00
|
|
|
|
2011-07-11 12:49:24 -06:00
|
|
|
/* Queue up, Direct Mode or Task Collector Mode. */
|
|
|
|
if (sas_ha->lldd_max_execute_num < 2)
|
|
|
|
res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
|
|
|
|
else
|
|
|
|
res = sas_queue_up(task);
|
|
|
|
|
|
|
|
if (res)
|
|
|
|
goto out_free_task;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_task:
|
|
|
|
SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
|
|
|
|
ASSIGN_SAS_TASK(cmd, NULL);
|
|
|
|
sas_free_task(task);
|
2011-07-16 13:00:35 -06:00
|
|
|
if (res == -SAS_QUEUE_FULL)
|
|
|
|
cmd->result = DID_SOFT_ERROR << 16; /* retry */
|
|
|
|
else
|
|
|
|
cmd->result = DID_ERROR << 16;
|
2011-07-11 12:49:24 -06:00
|
|
|
out_done:
|
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
return 0;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
2008-02-19 20:48:42 -07:00
|
|
|
static void sas_eh_finish_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host);
|
2012-01-09 11:12:52 -07:00
|
|
|
struct sas_task *task = TO_SAS_TASK(cmd);
|
2008-02-19 20:48:42 -07:00
|
|
|
|
2011-12-07 00:24:42 -07:00
|
|
|
/* At this point, we only get called following an actual abort
|
|
|
|
* of the task, so we should be guaranteed not to be racing with
|
|
|
|
* any completions from the LLD. Task is freed after this.
|
|
|
|
*/
|
|
|
|
sas_end_task(cmd, task);
|
|
|
|
|
2008-02-19 20:48:42 -07:00
|
|
|
/* now finish the command and move it on to the error
|
|
|
|
* handler done list, this also takes it off the
|
2011-12-07 00:24:42 -07:00
|
|
|
* error handler pending list.
|
|
|
|
*/
|
2008-02-19 20:48:42 -07:00
|
|
|
scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q);
|
|
|
|
}
|
|
|
|
|
2011-11-29 13:08:50 -07:00
|
|
|
static void sas_eh_defer_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
2012-01-09 11:12:52 -07:00
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
2011-11-29 13:08:50 -07:00
|
|
|
struct sas_ha_struct *ha = dev->port->ha;
|
2012-01-09 11:12:52 -07:00
|
|
|
struct sas_task *task = TO_SAS_TASK(cmd);
|
2011-11-29 13:08:50 -07:00
|
|
|
|
|
|
|
if (!dev_is_sata(dev)) {
|
|
|
|
sas_eh_finish_cmd(cmd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* report the timeout to libata */
|
|
|
|
sas_end_task(cmd, task);
|
|
|
|
list_move_tail(&cmd->eh_entry, &ha->eh_ata_q);
|
|
|
|
}
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
|
2008-02-22 16:07:52 -07:00
|
|
|
if (cmd->device->sdev_target == my_cmd->device->sdev_target &&
|
|
|
|
cmd->device->lun == my_cmd->device->lun)
|
2011-11-29 15:54:28 -07:00
|
|
|
sas_eh_defer_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_scsi_clear_queue_I_T(struct list_head *error_q,
|
|
|
|
struct domain_device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
|
|
|
|
struct domain_device *x = cmd_to_domain_dev(cmd);
|
|
|
|
|
|
|
|
if (x == dev)
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_scsi_clear_queue_port(struct list_head *error_q,
|
|
|
|
struct asd_sas_port *port)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
|
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
|
|
|
struct asd_sas_port *x = dev->port;
|
|
|
|
|
|
|
|
if (x == port)
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
enum task_disposition {
|
|
|
|
TASK_IS_DONE,
|
|
|
|
TASK_IS_ABORTED,
|
|
|
|
TASK_IS_AT_LU,
|
2011-11-28 12:29:20 -07:00
|
|
|
TASK_IS_NOT_AT_HA,
|
2006-08-29 08:22:51 -06:00
|
|
|
TASK_IS_NOT_AT_LU,
|
2007-01-11 15:15:46 -07:00
|
|
|
TASK_ABORT_FAILED,
|
2006-08-29 08:22:51 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static enum task_disposition sas_scsi_find_task(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *ha = task->dev->port->ha;
|
|
|
|
unsigned long flags;
|
|
|
|
int i, res;
|
|
|
|
struct sas_internal *si =
|
|
|
|
to_sas_internal(task->dev->port->ha->core.shost->transportt);
|
|
|
|
|
|
|
|
if (ha->lldd_max_execute_num > 1) {
|
|
|
|
struct scsi_core *core = &ha->core;
|
|
|
|
struct sas_task *t, *n;
|
|
|
|
|
2011-11-28 12:29:20 -07:00
|
|
|
mutex_lock(&core->task_queue_flush);
|
2006-08-29 08:22:51 -06:00
|
|
|
spin_lock_irqsave(&core->task_queue_lock, flags);
|
2011-11-28 12:29:20 -07:00
|
|
|
list_for_each_entry_safe(t, n, &core->task_queue, list)
|
2006-08-29 08:22:51 -06:00
|
|
|
if (task == t) {
|
|
|
|
list_del_init(&t->list);
|
2011-11-28 12:29:20 -07:00
|
|
|
break;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
2011-11-28 12:29:20 -07:00
|
|
|
mutex_unlock(&core->task_queue_flush);
|
|
|
|
|
|
|
|
if (task == t)
|
|
|
|
return TASK_IS_NOT_AT_HA;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 5; i++) {
|
2008-07-04 00:47:27 -06:00
|
|
|
SAS_DPRINTK("%s: aborting task 0x%p\n", __func__, task);
|
2006-08-29 08:22:51 -06:00
|
|
|
res = si->dft->lldd_abort_task(task);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
if (task->task_state_flags & SAS_TASK_STATE_DONE) {
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2008-07-04 00:47:27 -06:00
|
|
|
SAS_DPRINTK("%s: task 0x%p is done\n", __func__,
|
2006-08-29 08:22:51 -06:00
|
|
|
task);
|
|
|
|
return TASK_IS_DONE;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
|
|
|
|
if (res == TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
SAS_DPRINTK("%s: task 0x%p is aborted\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2006-08-29 08:22:51 -06:00
|
|
|
return TASK_IS_ABORTED;
|
|
|
|
} else if (si->dft->lldd_query_task) {
|
|
|
|
SAS_DPRINTK("%s: querying task 0x%p\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2006-08-29 08:22:51 -06:00
|
|
|
res = si->dft->lldd_query_task(task);
|
2007-01-11 15:15:46 -07:00
|
|
|
switch (res) {
|
|
|
|
case TMF_RESP_FUNC_SUCC:
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_DPRINTK("%s: task 0x%p at LU\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2006-08-29 08:22:51 -06:00
|
|
|
return TASK_IS_AT_LU;
|
2007-01-11 15:15:46 -07:00
|
|
|
case TMF_RESP_FUNC_COMPLETE:
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_DPRINTK("%s: task 0x%p not at LU\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2006-08-29 08:22:51 -06:00
|
|
|
return TASK_IS_NOT_AT_LU;
|
2007-01-11 15:15:46 -07:00
|
|
|
case TMF_RESP_FUNC_FAILED:
|
|
|
|
SAS_DPRINTK("%s: task 0x%p failed to abort\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2007-01-11 15:15:46 -07:00
|
|
|
return TASK_ABORT_FAILED;
|
|
|
|
}
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
int res = TMF_RESP_FUNC_FAILED;
|
|
|
|
struct scsi_lun lun;
|
|
|
|
struct sas_internal *i =
|
|
|
|
to_sas_internal(dev->port->ha->core.shost->transportt);
|
|
|
|
|
|
|
|
int_to_scsilun(cmd->device->lun, &lun);
|
|
|
|
|
2014-06-25 07:27:36 -06:00
|
|
|
SAS_DPRINTK("eh: device %llx LUN %llx has the task\n",
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_ADDR(dev->sas_addr),
|
|
|
|
cmd->device->lun);
|
|
|
|
|
|
|
|
if (i->dft->lldd_abort_task_set)
|
|
|
|
res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun);
|
|
|
|
|
|
|
|
if (res == TMF_RESP_FUNC_FAILED) {
|
|
|
|
if (i->dft->lldd_clear_task_set)
|
|
|
|
res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res == TMF_RESP_FUNC_FAILED) {
|
|
|
|
if (i->dft->lldd_lu_reset)
|
|
|
|
res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sas_recover_I_T(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
int res = TMF_RESP_FUNC_FAILED;
|
|
|
|
struct sas_internal *i =
|
|
|
|
to_sas_internal(dev->port->ha->core.shost->transportt);
|
|
|
|
|
|
|
|
SAS_DPRINTK("I_T nexus reset for dev %016llx\n",
|
|
|
|
SAS_ADDR(dev->sas_addr));
|
|
|
|
|
|
|
|
if (i->dft->lldd_I_T_nexus_reset)
|
|
|
|
res = i->dft->lldd_I_T_nexus_reset(dev);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:17 -07:00
|
|
|
/* take a reference on the last known good phy for this device */
|
|
|
|
struct sas_phy *sas_get_local_phy(struct domain_device *dev)
|
2007-01-11 15:15:17 -07:00
|
|
|
{
|
2011-12-21 22:33:17 -07:00
|
|
|
struct sas_ha_struct *ha = dev->port->ha;
|
|
|
|
struct sas_phy *phy;
|
|
|
|
unsigned long flags;
|
2007-01-11 15:15:17 -07:00
|
|
|
|
2011-12-21 22:33:17 -07:00
|
|
|
/* a published domain device always has a valid phy, it may be
|
|
|
|
* stale, but it is never NULL
|
|
|
|
*/
|
|
|
|
BUG_ON(!dev->phy);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ha->phy_port_lock, flags);
|
|
|
|
phy = dev->phy;
|
|
|
|
get_device(&phy->dev);
|
|
|
|
spin_unlock_irqrestore(&ha->phy_port_lock, flags);
|
|
|
|
|
|
|
|
return phy;
|
2007-01-11 15:15:17 -07:00
|
|
|
}
|
2011-12-21 22:33:17 -07:00
|
|
|
EXPORT_SYMBOL_GPL(sas_get_local_phy);
|
2007-01-11 15:15:17 -07:00
|
|
|
|
2012-06-22 00:30:48 -06:00
|
|
|
static void sas_wait_eh(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *ha = dev->port->ha;
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
if (dev_is_sata(dev)) {
|
|
|
|
ata_port_wait_eh(dev->sata_dev.ap);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
retry:
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
|
|
|
|
while (test_bit(SAS_DEV_EH_PENDING, &dev->state)) {
|
|
|
|
prepare_to_wait(&ha->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
schedule();
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
}
|
|
|
|
finish_wait(&ha->eh_wait_q, &wait);
|
|
|
|
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
|
|
|
|
/* make sure SCSI EH is complete */
|
|
|
|
if (scsi_host_in_recovery(ha->core.shost)) {
|
|
|
|
msleep(10);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sas_wait_eh);
|
|
|
|
|
2014-06-25 07:27:36 -06:00
|
|
|
static int sas_queue_reset(struct domain_device *dev, int reset_type,
|
|
|
|
u64 lun, int wait)
|
2012-06-22 00:30:48 -06:00
|
|
|
{
|
|
|
|
struct sas_ha_struct *ha = dev->port->ha;
|
|
|
|
int scheduled = 0, tries = 100;
|
|
|
|
|
|
|
|
/* ata: promote lun reset to bus reset */
|
|
|
|
if (dev_is_sata(dev)) {
|
|
|
|
sas_ata_schedule_reset(dev);
|
|
|
|
if (wait)
|
|
|
|
sas_ata_wait_eh(dev);
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!scheduled && tries--) {
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
if (!test_bit(SAS_DEV_EH_PENDING, &dev->state) &&
|
|
|
|
!test_bit(reset_type, &dev->state)) {
|
|
|
|
scheduled = 1;
|
|
|
|
ha->eh_active++;
|
|
|
|
list_add_tail(&dev->ssp_dev.eh_list_node, &ha->eh_dev_q);
|
|
|
|
set_bit(SAS_DEV_EH_PENDING, &dev->state);
|
|
|
|
set_bit(reset_type, &dev->state);
|
|
|
|
int_to_scsilun(lun, &dev->ssp_dev.reset_lun);
|
|
|
|
scsi_schedule_eh(ha->core.shost);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
|
|
|
|
if (wait)
|
|
|
|
sas_wait_eh(dev);
|
|
|
|
|
|
|
|
if (scheduled)
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
SAS_DPRINTK("%s reset of %s failed\n",
|
|
|
|
reset_type == SAS_DEV_LU_RESET ? "LUN" : "Bus",
|
|
|
|
dev_name(&dev->rphy->dev));
|
|
|
|
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
2012-06-22 00:30:53 -06:00
|
|
|
int sas_eh_abort_handler(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
struct sas_task *task = TO_SAS_TASK(cmd);
|
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
|
|
|
struct sas_internal *i = to_sas_internal(host->transportt);
|
|
|
|
|
|
|
|
if (current != host->ehandler)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
if (!i->dft->lldd_abort_task)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
res = i->dft->lldd_abort_task(task);
|
|
|
|
if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
|
|
|
|
return SUCCESS;
|
|
|
|
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sas_eh_abort_handler);
|
|
|
|
|
2007-01-30 00:48:19 -07:00
|
|
|
/* Attempt to send a LUN reset message to a device */
|
2007-01-26 15:08:52 -07:00
|
|
|
int sas_eh_device_reset_handler(struct scsi_cmnd *cmd)
|
2007-01-30 00:48:19 -07:00
|
|
|
{
|
|
|
|
int res;
|
2012-06-22 00:30:48 -06:00
|
|
|
struct scsi_lun lun;
|
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
|
|
|
struct sas_internal *i = to_sas_internal(host->transportt);
|
|
|
|
|
|
|
|
if (current != host->ehandler)
|
|
|
|
return sas_queue_reset(dev, SAS_DEV_LU_RESET, cmd->device->lun, 0);
|
2007-01-30 00:48:19 -07:00
|
|
|
|
|
|
|
int_to_scsilun(cmd->device->lun, &lun);
|
|
|
|
|
|
|
|
if (!i->dft->lldd_lu_reset)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
|
|
|
|
if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
|
|
|
|
return SUCCESS;
|
|
|
|
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd)
|
2007-01-26 15:08:52 -07:00
|
|
|
{
|
|
|
|
int res;
|
2012-06-22 00:30:58 -06:00
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
|
|
|
struct sas_internal *i = to_sas_internal(host->transportt);
|
2007-01-26 15:08:52 -07:00
|
|
|
|
2012-06-22 00:30:48 -06:00
|
|
|
if (current != host->ehandler)
|
|
|
|
return sas_queue_reset(dev, SAS_DEV_RESET, 0, 0);
|
|
|
|
|
2012-06-22 00:30:58 -06:00
|
|
|
if (!i->dft->lldd_I_T_nexus_reset)
|
|
|
|
return FAILED;
|
2011-12-21 22:33:17 -07:00
|
|
|
|
2012-06-22 00:30:58 -06:00
|
|
|
res = i->dft->lldd_I_T_nexus_reset(dev);
|
|
|
|
if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE ||
|
|
|
|
res == -ENODEV)
|
2007-01-26 15:08:52 -07:00
|
|
|
return SUCCESS;
|
|
|
|
|
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to reset a device */
|
2008-02-23 22:39:59 -07:00
|
|
|
static int try_to_reset_cmd_device(struct scsi_cmnd *cmd)
|
2007-01-26 15:08:52 -07:00
|
|
|
{
|
2007-01-30 00:48:19 -07:00
|
|
|
int res;
|
2008-02-23 22:39:59 -07:00
|
|
|
struct Scsi_Host *shost = cmd->device->host;
|
2007-01-30 00:48:19 -07:00
|
|
|
|
2007-01-26 15:08:52 -07:00
|
|
|
if (!shost->hostt->eh_device_reset_handler)
|
2007-01-30 00:48:19 -07:00
|
|
|
goto try_bus_reset;
|
|
|
|
|
|
|
|
res = shost->hostt->eh_device_reset_handler(cmd);
|
|
|
|
if (res == SUCCESS)
|
|
|
|
return res;
|
2007-01-26 15:08:52 -07:00
|
|
|
|
2007-01-30 00:48:19 -07:00
|
|
|
try_bus_reset:
|
|
|
|
if (shost->hostt->eh_bus_reset_handler)
|
|
|
|
return shost->hostt->eh_bus_reset_handler(cmd);
|
|
|
|
|
|
|
|
return FAILED;
|
2007-01-26 15:08:52 -07:00
|
|
|
}
|
|
|
|
|
2012-01-20 16:23:07 -07:00
|
|
|
static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *work_q)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd, *n;
|
|
|
|
enum task_disposition res = TASK_IS_DONE;
|
2007-01-11 15:15:17 -07:00
|
|
|
int tmf_resp, need_reset;
|
2006-08-29 08:22:51 -06:00
|
|
|
struct sas_internal *i = to_sas_internal(shost->transportt);
|
2007-01-26 15:08:52 -07:00
|
|
|
unsigned long flags;
|
|
|
|
struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
|
2012-01-09 11:12:52 -07:00
|
|
|
LIST_HEAD(done);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2012-01-09 11:12:52 -07:00
|
|
|
/* clean out any commands that won the completion vs eh race */
|
2007-01-26 15:08:52 -07:00
|
|
|
list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
|
2011-11-28 12:29:20 -07:00
|
|
|
struct domain_device *dev = cmd_to_domain_dev(cmd);
|
|
|
|
struct sas_task *task;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->done_lock, flags);
|
|
|
|
/* by this point the lldd has either observed
|
|
|
|
* SAS_HA_FROZEN and is leaving the task alone, or has
|
|
|
|
* won the race with eh and decided to complete it
|
|
|
|
*/
|
|
|
|
task = TO_SAS_TASK(cmd);
|
|
|
|
spin_unlock_irqrestore(&dev->done_lock, flags);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2007-01-26 15:08:52 -07:00
|
|
|
if (!task)
|
2012-01-09 11:12:52 -07:00
|
|
|
list_move_tail(&cmd->eh_entry, &done);
|
|
|
|
}
|
|
|
|
|
|
|
|
Again:
|
|
|
|
list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
|
|
|
|
struct sas_task *task = TO_SAS_TASK(cmd);
|
2007-01-26 15:08:52 -07:00
|
|
|
|
|
|
|
list_del_init(&cmd->eh_entry);
|
2007-01-11 15:15:17 -07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET;
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
|
2008-02-23 22:39:59 -07:00
|
|
|
if (need_reset) {
|
|
|
|
SAS_DPRINTK("%s: task 0x%p requests reset\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2008-02-23 22:39:59 -07:00
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_DPRINTK("trying to find task 0x%p\n", task);
|
|
|
|
res = sas_scsi_find_task(task);
|
|
|
|
|
|
|
|
cmd->eh_eflags = 0;
|
|
|
|
|
|
|
|
switch (res) {
|
2011-11-28 12:29:20 -07:00
|
|
|
case TASK_IS_NOT_AT_HA:
|
|
|
|
SAS_DPRINTK("%s: task 0x%p is not at ha: %s\n",
|
|
|
|
__func__, task,
|
|
|
|
cmd->retries ? "retry" : "aborted");
|
|
|
|
if (cmd->retries)
|
|
|
|
cmd->retries--;
|
|
|
|
sas_eh_finish_cmd(cmd);
|
|
|
|
continue;
|
2006-08-29 08:22:51 -06:00
|
|
|
case TASK_IS_DONE:
|
2008-07-04 00:47:27 -06:00
|
|
|
SAS_DPRINTK("%s: task 0x%p is done\n", __func__,
|
2006-08-29 08:22:51 -06:00
|
|
|
task);
|
2011-11-29 13:08:50 -07:00
|
|
|
sas_eh_defer_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
continue;
|
|
|
|
case TASK_IS_ABORTED:
|
|
|
|
SAS_DPRINTK("%s: task 0x%p is aborted\n",
|
2008-07-04 00:47:27 -06:00
|
|
|
__func__, task);
|
2011-11-29 13:08:50 -07:00
|
|
|
sas_eh_defer_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
continue;
|
|
|
|
case TASK_IS_AT_LU:
|
|
|
|
SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task);
|
2008-02-23 22:39:59 -07:00
|
|
|
reset:
|
2006-08-29 08:22:51 -06:00
|
|
|
tmf_resp = sas_recover_lu(task->dev, cmd);
|
|
|
|
if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
|
2014-06-25 07:27:36 -06:00
|
|
|
SAS_DPRINTK("dev %016llx LU %llx is "
|
2006-08-29 08:22:51 -06:00
|
|
|
"recovered\n",
|
|
|
|
SAS_ADDR(task->dev),
|
|
|
|
cmd->device->lun);
|
2011-11-29 15:54:28 -07:00
|
|
|
sas_eh_defer_cmd(cmd);
|
2007-01-26 15:08:52 -07:00
|
|
|
sas_scsi_clear_queue_lu(work_q, cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
goto Again;
|
|
|
|
}
|
|
|
|
/* fallthrough */
|
|
|
|
case TASK_IS_NOT_AT_LU:
|
2007-01-11 15:15:46 -07:00
|
|
|
case TASK_ABORT_FAILED:
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n",
|
|
|
|
task);
|
|
|
|
tmf_resp = sas_recover_I_T(task->dev);
|
2012-01-30 22:40:45 -07:00
|
|
|
if (tmf_resp == TMF_RESP_FUNC_COMPLETE ||
|
|
|
|
tmf_resp == -ENODEV) {
|
2008-02-23 22:39:59 -07:00
|
|
|
struct domain_device *dev = task->dev;
|
2006-08-29 08:22:51 -06:00
|
|
|
SAS_DPRINTK("I_T %016llx recovered\n",
|
|
|
|
SAS_ADDR(task->dev->sas_addr));
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
2008-02-23 22:39:59 -07:00
|
|
|
sas_scsi_clear_queue_I_T(work_q, dev);
|
2006-08-29 08:22:51 -06:00
|
|
|
goto Again;
|
|
|
|
}
|
|
|
|
/* Hammer time :-) */
|
2008-02-23 22:39:59 -07:00
|
|
|
try_to_reset_cmd_device(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
if (i->dft->lldd_clear_nexus_port) {
|
|
|
|
struct asd_sas_port *port = task->dev->port;
|
|
|
|
SAS_DPRINTK("clearing nexus for port:%d\n",
|
|
|
|
port->id);
|
|
|
|
res = i->dft->lldd_clear_nexus_port(port);
|
|
|
|
if (res == TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
SAS_DPRINTK("clear nexus port:%d "
|
|
|
|
"succeeded\n", port->id);
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
2007-01-26 15:08:52 -07:00
|
|
|
sas_scsi_clear_queue_port(work_q,
|
2006-08-29 08:22:51 -06:00
|
|
|
port);
|
|
|
|
goto Again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i->dft->lldd_clear_nexus_ha) {
|
|
|
|
SAS_DPRINTK("clear nexus ha\n");
|
|
|
|
res = i->dft->lldd_clear_nexus_ha(ha);
|
|
|
|
if (res == TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
SAS_DPRINTK("clear nexus ha "
|
|
|
|
"succeeded\n");
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
|
|
|
goto clear_q;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* If we are here -- this means that no amount
|
|
|
|
* of effort could recover from errors. Quite
|
|
|
|
* possibly the HA just disappeared.
|
|
|
|
*/
|
2014-06-25 07:27:36 -06:00
|
|
|
SAS_DPRINTK("error from device %llx, LUN %llx "
|
2006-08-29 08:22:51 -06:00
|
|
|
"couldn't be recovered in any way\n",
|
|
|
|
SAS_ADDR(task->dev->sas_addr),
|
|
|
|
cmd->device->lun);
|
|
|
|
|
2008-02-19 20:48:42 -07:00
|
|
|
sas_eh_finish_cmd(cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
goto clear_q;
|
|
|
|
}
|
|
|
|
}
|
2012-01-09 11:12:52 -07:00
|
|
|
out:
|
|
|
|
list_splice_tail(&done, work_q);
|
2011-11-29 13:08:50 -07:00
|
|
|
list_splice_tail_init(&ha->eh_ata_q, work_q);
|
2012-01-20 16:23:07 -07:00
|
|
|
return;
|
2012-01-09 11:12:52 -07:00
|
|
|
|
|
|
|
clear_q:
|
2008-07-04 00:47:27 -06:00
|
|
|
SAS_DPRINTK("--- Exit %s -- clear_q\n", __func__);
|
2008-02-19 20:48:42 -07:00
|
|
|
list_for_each_entry_safe(cmd, n, work_q, eh_entry)
|
|
|
|
sas_eh_finish_cmd(cmd);
|
2012-01-09 11:12:52 -07:00
|
|
|
goto out;
|
2007-01-26 15:08:52 -07:00
|
|
|
}
|
|
|
|
|
2012-06-22 00:30:48 -06:00
|
|
|
static void sas_eh_handle_resets(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
|
|
|
|
struct sas_internal *i = to_sas_internal(shost->transportt);
|
|
|
|
|
|
|
|
/* handle directed resets to sas devices */
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
while (!list_empty(&ha->eh_dev_q)) {
|
|
|
|
struct domain_device *dev;
|
|
|
|
struct ssp_device *ssp;
|
|
|
|
|
|
|
|
ssp = list_entry(ha->eh_dev_q.next, typeof(*ssp), eh_list_node);
|
|
|
|
list_del_init(&ssp->eh_list_node);
|
|
|
|
dev = container_of(ssp, typeof(*dev), ssp_dev);
|
|
|
|
kref_get(&dev->kref);
|
|
|
|
WARN_ONCE(dev_is_sata(dev), "ssp reset to ata device?\n");
|
|
|
|
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
|
|
|
|
if (test_and_clear_bit(SAS_DEV_LU_RESET, &dev->state))
|
|
|
|
i->dft->lldd_lu_reset(dev, ssp->reset_lun.scsi_lun);
|
|
|
|
|
|
|
|
if (test_and_clear_bit(SAS_DEV_RESET, &dev->state))
|
|
|
|
i->dft->lldd_I_T_nexus_reset(dev);
|
|
|
|
|
|
|
|
sas_put_device(dev);
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
clear_bit(SAS_DEV_EH_PENDING, &dev->state);
|
|
|
|
ha->eh_active--;
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
}
|
|
|
|
|
2012-06-22 00:25:27 -06:00
|
|
|
|
2007-01-26 15:08:52 -07:00
|
|
|
void sas_scsi_recover_host(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
|
|
|
|
LIST_HEAD(eh_work_q);
|
2012-06-22 00:25:27 -06:00
|
|
|
int tries = 0;
|
|
|
|
bool retry;
|
2007-01-26 15:08:52 -07:00
|
|
|
|
2012-06-22 00:25:27 -06:00
|
|
|
retry:
|
|
|
|
tries++;
|
|
|
|
retry = true;
|
|
|
|
spin_lock_irq(shost->host_lock);
|
2007-01-26 15:08:52 -07:00
|
|
|
list_splice_init(&shost->eh_cmd_q, &eh_work_q);
|
2012-06-22 00:25:27 -06:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2007-01-26 15:08:52 -07:00
|
|
|
|
2012-01-11 13:08:36 -07:00
|
|
|
SAS_DPRINTK("Enter %s busy: %d failed: %d\n",
|
2014-01-22 07:29:29 -07:00
|
|
|
__func__, atomic_read(&shost->host_busy), shost->host_failed);
|
2007-01-26 15:08:52 -07:00
|
|
|
/*
|
|
|
|
* Deal with commands that still have SAS tasks (i.e. they didn't
|
2012-01-20 16:23:07 -07:00
|
|
|
* complete via the normal sas_task completion mechanism),
|
|
|
|
* SAS_HA_FROZEN gives eh dominion over all sas_task completion.
|
2007-01-26 15:08:52 -07:00
|
|
|
*/
|
2011-11-28 12:29:20 -07:00
|
|
|
set_bit(SAS_HA_FROZEN, &ha->state);
|
2012-01-20 16:23:07 -07:00
|
|
|
sas_eh_handle_sas_errors(shost, &eh_work_q);
|
|
|
|
clear_bit(SAS_HA_FROZEN, &ha->state);
|
|
|
|
if (list_empty(&eh_work_q))
|
2007-01-26 15:08:52 -07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now deal with SCSI commands that completed ok but have a an error
|
|
|
|
* code (and hopefully sense data) attached. This is roughly what
|
|
|
|
* scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any
|
|
|
|
* command we see here has no sas_task and is thus unknown to the HA.
|
|
|
|
*/
|
2012-01-11 13:08:36 -07:00
|
|
|
sas_ata_eh(shost, &eh_work_q, &ha->eh_done_q);
|
|
|
|
if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q))
|
|
|
|
scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q);
|
2007-01-26 15:08:52 -07:00
|
|
|
|
|
|
|
out:
|
2011-11-28 12:29:20 -07:00
|
|
|
if (ha->lldd_max_execute_num > 1)
|
|
|
|
wake_up_process(ha->core.queue_thread);
|
|
|
|
|
2012-06-22 00:30:48 -06:00
|
|
|
sas_eh_handle_resets(shost);
|
|
|
|
|
2011-01-23 08:44:12 -07:00
|
|
|
/* now link into libata eh --- if we have any ata devices */
|
|
|
|
sas_ata_strategy_handler(shost);
|
|
|
|
|
2007-01-26 15:08:52 -07:00
|
|
|
scsi_eh_flush_done_q(&ha->eh_done_q);
|
2011-01-23 08:44:12 -07:00
|
|
|
|
2012-06-22 00:25:27 -06:00
|
|
|
/* check if any new eh work was scheduled during the last run */
|
|
|
|
spin_lock_irq(&ha->lock);
|
|
|
|
if (ha->eh_active == 0) {
|
|
|
|
shost->host_eh_scheduled = 0;
|
|
|
|
retry = false;
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&ha->lock);
|
|
|
|
|
|
|
|
if (retry)
|
|
|
|
goto retry;
|
|
|
|
|
|
|
|
SAS_DPRINTK("--- Exit %s: busy: %d failed: %d tries: %d\n",
|
2014-01-22 07:29:29 -07:00
|
|
|
__func__, atomic_read(&shost->host_busy),
|
|
|
|
shost->host_failed, tries);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
2008-09-14 06:55:09 -06:00
|
|
|
enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
2014-02-06 13:23:07 -07:00
|
|
|
scmd_dbg(cmd, "command %p timed out\n", cmd);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2008-09-14 06:55:09 -06:00
|
|
|
return BLK_EH_NOT_HANDLED;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
2006-08-10 20:19:47 -06:00
|
|
|
int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
|
|
|
|
{
|
|
|
|
struct domain_device *dev = sdev_to_domain_dev(sdev);
|
|
|
|
|
|
|
|
if (dev_is_sata(dev))
|
2009-01-16 08:17:09 -07:00
|
|
|
return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg);
|
2006-08-10 20:19:47 -06:00
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);
|
|
|
|
struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
|
|
|
|
struct domain_device *found_dev = NULL;
|
|
|
|
int i;
|
2007-01-11 15:15:40 -07:00
|
|
|
unsigned long flags;
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2007-01-11 15:15:40 -07:00
|
|
|
spin_lock_irqsave(&ha->phy_port_lock, flags);
|
2006-08-29 08:22:51 -06:00
|
|
|
for (i = 0; i < ha->num_phys; i++) {
|
|
|
|
struct asd_sas_port *port = ha->sas_port[i];
|
|
|
|
struct domain_device *dev;
|
|
|
|
|
|
|
|
spin_lock(&port->dev_list_lock);
|
|
|
|
list_for_each_entry(dev, &port->dev_list, dev_list_node) {
|
|
|
|
if (rphy == dev->rphy) {
|
|
|
|
found_dev = dev;
|
|
|
|
spin_unlock(&port->dev_list_lock);
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&port->dev_list_lock);
|
|
|
|
}
|
|
|
|
found:
|
2007-01-11 15:15:40 -07:00
|
|
|
spin_unlock_irqrestore(&ha->phy_port_lock, flags);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
return found_dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sas_target_alloc(struct scsi_target *starget)
|
|
|
|
{
|
2011-11-17 18:59:47 -07:00
|
|
|
struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent);
|
|
|
|
struct domain_device *found_dev = sas_find_dev_by_rphy(rphy);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
if (!found_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2011-11-17 18:59:47 -07:00
|
|
|
kref_get(&found_dev->kref);
|
2006-08-29 08:22:51 -06:00
|
|
|
starget->hostdata = found_dev;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-20 16:10:46 -06:00
|
|
|
#define SAS_DEF_QD 256
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
int sas_slave_configure(struct scsi_device *scsi_dev)
|
|
|
|
{
|
|
|
|
struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
|
|
|
|
struct sas_ha_struct *sas_ha;
|
|
|
|
|
|
|
|
BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE);
|
|
|
|
|
2006-08-10 20:19:47 -06:00
|
|
|
if (dev_is_sata(dev)) {
|
|
|
|
ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
sas_ha = dev->port->ha;
|
|
|
|
|
|
|
|
sas_read_port_mode_page(scsi_dev);
|
|
|
|
|
|
|
|
if (scsi_dev->tagged_supported) {
|
|
|
|
scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG);
|
|
|
|
scsi_activate_tcq(scsi_dev, SAS_DEF_QD);
|
|
|
|
} else {
|
2014-06-25 07:27:36 -06:00
|
|
|
SAS_DPRINTK("device %llx, LUN %llx doesn't support "
|
2006-08-29 08:22:51 -06:00
|
|
|
"TCQ\n", SAS_ADDR(dev->sas_addr),
|
|
|
|
scsi_dev->lun);
|
|
|
|
scsi_dev->tagged_supported = 0;
|
|
|
|
scsi_set_tag_type(scsi_dev, 0);
|
|
|
|
scsi_deactivate_tcq(scsi_dev, 1);
|
|
|
|
}
|
|
|
|
|
2007-01-26 15:08:58 -07:00
|
|
|
scsi_dev->allow_restart = 1;
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-20 16:10:46 -06:00
|
|
|
int sas_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
|
2006-08-29 08:22:51 -06:00
|
|
|
{
|
2011-09-20 16:10:46 -06:00
|
|
|
struct domain_device *dev = sdev_to_domain_dev(sdev);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
2011-09-20 16:10:33 -06:00
|
|
|
if (dev_is_sata(dev))
|
2011-09-20 16:10:46 -06:00
|
|
|
return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth,
|
|
|
|
reason);
|
|
|
|
|
|
|
|
switch (reason) {
|
|
|
|
case SCSI_QDEPTH_DEFAULT:
|
|
|
|
case SCSI_QDEPTH_RAMP_UP:
|
|
|
|
if (!sdev->tagged_supported)
|
|
|
|
depth = 1;
|
|
|
|
scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
|
|
|
|
break;
|
|
|
|
case SCSI_QDEPTH_QFULL:
|
|
|
|
scsi_track_queue_full(sdev, depth);
|
|
|
|
break;
|
|
|
|
default:
|
2009-10-15 18:46:39 -06:00
|
|
|
return -EOPNOTSUPP;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
2011-09-20 16:10:46 -06:00
|
|
|
return depth;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
|
|
|
|
{
|
2011-09-20 16:10:33 -06:00
|
|
|
struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
|
|
|
|
|
|
|
|
if (dev_is_sata(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
if (!scsi_dev->tagged_supported)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
scsi_deactivate_tcq(scsi_dev, 1);
|
|
|
|
|
|
|
|
scsi_set_tag_type(scsi_dev, qt);
|
|
|
|
scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
|
|
|
|
|
|
|
|
return qt;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sas_bios_param(struct scsi_device *scsi_dev,
|
|
|
|
struct block_device *bdev,
|
|
|
|
sector_t capacity, int *hsc)
|
|
|
|
{
|
|
|
|
hsc[0] = 255;
|
|
|
|
hsc[1] = 63;
|
|
|
|
sector_div(capacity, 255*63);
|
|
|
|
hsc[2] = capacity;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ---------- Task Collector Thread implementation ---------- */
|
|
|
|
|
|
|
|
static void sas_queue(struct sas_ha_struct *sas_ha)
|
|
|
|
{
|
|
|
|
struct scsi_core *core = &sas_ha->core;
|
|
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(q);
|
|
|
|
int can_queue;
|
|
|
|
int res;
|
|
|
|
struct sas_internal *i = to_sas_internal(core->shost->transportt);
|
|
|
|
|
2011-11-28 12:29:20 -07:00
|
|
|
mutex_lock(&core->task_queue_flush);
|
2006-08-29 08:22:51 -06:00
|
|
|
spin_lock_irqsave(&core->task_queue_lock, flags);
|
2007-04-26 07:38:01 -06:00
|
|
|
while (!kthread_should_stop() &&
|
2011-11-28 12:29:20 -07:00
|
|
|
!list_empty(&core->task_queue) &&
|
|
|
|
!test_bit(SAS_HA_FROZEN, &sas_ha->state)) {
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
|
|
|
|
if (can_queue >= 0) {
|
|
|
|
can_queue = core->task_queue_size;
|
|
|
|
list_splice_init(&core->task_queue, &q);
|
|
|
|
} else {
|
|
|
|
struct list_head *a, *n;
|
|
|
|
|
|
|
|
can_queue = sas_ha->lldd_queue_size;
|
|
|
|
list_for_each_safe(a, n, &core->task_queue) {
|
|
|
|
list_move_tail(a, &q);
|
|
|
|
if (--can_queue == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
can_queue = sas_ha->lldd_queue_size;
|
|
|
|
}
|
|
|
|
core->task_queue_size -= can_queue;
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
|
|
|
{
|
|
|
|
struct sas_task *task = list_entry(q.next,
|
|
|
|
struct sas_task,
|
|
|
|
list);
|
|
|
|
list_del_init(&q);
|
|
|
|
res = i->dft->lldd_execute_task(task, can_queue,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (unlikely(res))
|
|
|
|
__list_add(&q, task->list.prev, &task->list);
|
|
|
|
}
|
|
|
|
spin_lock_irqsave(&core->task_queue_lock, flags);
|
|
|
|
if (res) {
|
|
|
|
list_splice_init(&q, &core->task_queue); /*at head*/
|
|
|
|
core->task_queue_size += can_queue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
2011-11-28 12:29:20 -07:00
|
|
|
mutex_unlock(&core->task_queue_flush);
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sas_queue_thread -- The Task Collector thread
|
|
|
|
* @_sas_ha: pointer to struct sas_ha
|
|
|
|
*/
|
|
|
|
static int sas_queue_thread(void *_sas_ha)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = _sas_ha;
|
|
|
|
|
|
|
|
while (1) {
|
2007-04-26 07:38:01 -06:00
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
schedule();
|
2006-08-29 08:22:51 -06:00
|
|
|
sas_queue(sas_ha);
|
2007-04-26 07:38:01 -06:00
|
|
|
if (kthread_should_stop())
|
2006-08-29 08:22:51 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sas_init_queue(struct sas_ha_struct *sas_ha)
|
|
|
|
{
|
|
|
|
struct scsi_core *core = &sas_ha->core;
|
|
|
|
|
|
|
|
spin_lock_init(&core->task_queue_lock);
|
2011-11-28 12:29:20 -07:00
|
|
|
mutex_init(&core->task_queue_flush);
|
2006-08-29 08:22:51 -06:00
|
|
|
core->task_queue_size = 0;
|
|
|
|
INIT_LIST_HEAD(&core->task_queue);
|
|
|
|
|
2007-04-26 07:38:01 -06:00
|
|
|
core->queue_thread = kthread_run(sas_queue_thread, sas_ha,
|
|
|
|
"sas_queue_%d", core->shost->host_no);
|
|
|
|
if (IS_ERR(core->queue_thread))
|
|
|
|
return PTR_ERR(core->queue_thread);
|
|
|
|
return 0;
|
2006-08-29 08:22:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct scsi_core *core = &sas_ha->core;
|
|
|
|
struct sas_task *task, *n;
|
|
|
|
|
2007-04-26 07:38:01 -06:00
|
|
|
kthread_stop(core->queue_thread);
|
2006-08-29 08:22:51 -06:00
|
|
|
|
|
|
|
if (!list_empty(&core->task_queue))
|
|
|
|
SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
|
|
|
|
SAS_ADDR(sas_ha->sas_addr));
|
|
|
|
|
|
|
|
spin_lock_irqsave(&core->task_queue_lock, flags);
|
|
|
|
list_for_each_entry_safe(task, n, &core->task_queue, list) {
|
|
|
|
struct scsi_cmnd *cmd = task->uldd_task;
|
|
|
|
|
|
|
|
list_del_init(&task->list);
|
|
|
|
|
|
|
|
ASSIGN_SAS_TASK(cmd, NULL);
|
|
|
|
sas_free_task(task);
|
|
|
|
cmd->result = DID_ABORT << 16;
|
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&core->task_queue_lock, flags);
|
|
|
|
}
|
|
|
|
|
2007-01-11 15:15:20 -07:00
|
|
|
/*
|
|
|
|
* Tell an upper layer that it needs to initiate an abort for a given task.
|
|
|
|
* This should only ever be called by an LLDD.
|
|
|
|
*/
|
|
|
|
void sas_task_abort(struct sas_task *task)
|
2006-10-30 16:18:50 -07:00
|
|
|
{
|
2007-01-11 15:15:20 -07:00
|
|
|
struct scsi_cmnd *sc = task->uldd_task;
|
2006-10-30 16:18:50 -07:00
|
|
|
|
2007-01-11 15:15:20 -07:00
|
|
|
/* Escape for libsas internal commands */
|
|
|
|
if (!sc) {
|
2012-06-22 00:36:30 -06:00
|
|
|
struct sas_task_slow *slow = task->slow_task;
|
|
|
|
|
|
|
|
if (!slow)
|
|
|
|
return;
|
|
|
|
if (!del_timer(&slow->timer))
|
2006-10-30 16:18:50 -07:00
|
|
|
return;
|
2012-06-22 00:36:30 -06:00
|
|
|
slow->timer.function(slow->timer.data);
|
2007-01-11 15:15:20 -07:00
|
|
|
return;
|
|
|
|
}
|
2006-10-30 16:18:50 -07:00
|
|
|
|
2007-01-30 02:18:58 -07:00
|
|
|
if (dev_is_sata(task->dev)) {
|
|
|
|
sas_ata_task_abort(task);
|
2010-05-13 08:31:54 -06:00
|
|
|
} else {
|
|
|
|
struct request_queue *q = sc->device->request_queue;
|
|
|
|
unsigned long flags;
|
2007-01-30 02:18:58 -07:00
|
|
|
|
2010-05-13 08:31:54 -06:00
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
blk_abort_request(sc->request);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
2006-10-30 16:18:50 -07:00
|
|
|
}
|
|
|
|
|
2006-08-10 20:19:47 -06:00
|
|
|
void sas_target_destroy(struct scsi_target *starget)
|
|
|
|
{
|
2011-11-17 18:59:47 -07:00
|
|
|
struct domain_device *found_dev = starget->hostdata;
|
2006-08-10 20:19:47 -06:00
|
|
|
|
|
|
|
if (!found_dev)
|
|
|
|
return;
|
|
|
|
|
2011-11-17 18:59:47 -07:00
|
|
|
starget->hostdata = NULL;
|
|
|
|
sas_put_device(found_dev);
|
2006-08-10 20:19:47 -06:00
|
|
|
}
|
|
|
|
|
2008-02-19 11:49:40 -07:00
|
|
|
static void sas_parse_addr(u8 *sas_addr, const char *p)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < SAS_ADDR_SIZE; i++) {
|
|
|
|
u8 h, l;
|
|
|
|
if (!*p)
|
|
|
|
break;
|
|
|
|
h = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10;
|
|
|
|
p++;
|
|
|
|
l = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10;
|
|
|
|
p++;
|
|
|
|
sas_addr[i] = (h<<4) | l;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SAS_STRING_ADDR_SIZE 16
|
|
|
|
|
|
|
|
int sas_request_addr(struct Scsi_Host *shost, u8 *addr)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
const struct firmware *fw;
|
|
|
|
|
|
|
|
res = request_firmware(&fw, "sas_addr", &shost->shost_gendev);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
|
|
|
if (fw->size < SAS_STRING_ADDR_SIZE) {
|
|
|
|
res = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
sas_parse_addr(addr, fw->data);
|
|
|
|
|
|
|
|
out:
|
|
|
|
release_firmware(fw);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sas_request_addr);
|
|
|
|
|
2006-08-29 08:22:51 -06:00
|
|
|
EXPORT_SYMBOL_GPL(sas_queuecommand);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_target_alloc);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_slave_configure);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_change_queue_depth);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_change_queue_type);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_bios_param);
|
2006-10-30 16:18:50 -07:00
|
|
|
EXPORT_SYMBOL_GPL(sas_task_abort);
|
2006-11-07 18:28:55 -07:00
|
|
|
EXPORT_SYMBOL_GPL(sas_phy_reset);
|
2007-01-26 15:08:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler);
|
2007-01-30 00:48:19 -07:00
|
|
|
EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler);
|
2006-08-10 20:19:47 -06:00
|
|
|
EXPORT_SYMBOL_GPL(sas_target_destroy);
|
|
|
|
EXPORT_SYMBOL_GPL(sas_ioctl);
|