mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 11:41:38 -04:00
block: unify request timeout handling
Right now SCSI and others do their own command timeout handling. Move those bits to the block layer. Instead of having a timer per command, we try to be a bit more clever and simply have one per-queue. This avoids the overhead of having to tear down and setup a timer for each command, so it will result in a lot less timer fiddling. Signed-off-by: Mike Anderson <[email protected]> Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Jens Axboe
parent
608aeef17a
commit
242f9dcb8b
39 changed files with 399 additions and 339 deletions
|
|
@ -1139,7 +1139,7 @@ static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd
|
|||
srbcmd->id = cpu_to_le32(scmd_id(cmd));
|
||||
srbcmd->lun = cpu_to_le32(cmd->device->lun);
|
||||
srbcmd->flags = cpu_to_le32(flag);
|
||||
timeout = cmd->timeout_per_command/HZ;
|
||||
timeout = cmd->request->timeout/HZ;
|
||||
if (timeout == 0)
|
||||
timeout = 1;
|
||||
srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds
|
||||
|
|
|
|||
|
|
@ -464,7 +464,6 @@ int __gdth_execute(struct scsi_device *sdev, gdth_cmd_str *gdtcmd, char *cmnd,
|
|||
|
||||
/* use request field to save the ptr. to completion struct. */
|
||||
scp->request = (struct request *)&wait;
|
||||
scp->timeout_per_command = timeout*HZ;
|
||||
scp->cmd_len = 12;
|
||||
scp->cmnd = cmnd;
|
||||
cmndinfo.priority = IOCTL_PRI;
|
||||
|
|
@ -1995,23 +1994,12 @@ static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority)
|
|||
register Scsi_Cmnd *pscp;
|
||||
register Scsi_Cmnd *nscp;
|
||||
ulong flags;
|
||||
unchar b, t;
|
||||
|
||||
TRACE(("gdth_putq() priority %d\n",priority));
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
|
||||
if (!cmndinfo->internal_command) {
|
||||
if (!cmndinfo->internal_command)
|
||||
cmndinfo->priority = priority;
|
||||
b = scp->device->channel;
|
||||
t = scp->device->id;
|
||||
if (priority >= DEFAULT_PRI) {
|
||||
if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha,b)].lock) ||
|
||||
(b==ha->virt_bus && t<MAX_HDRIVES && ha->hdr[t].lock)) {
|
||||
TRACE2(("gdth_putq(): locked IO ->update_timeout()\n"));
|
||||
cmndinfo->timeout = gdth_update_timeout(scp, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ha->req_first==NULL) {
|
||||
ha->req_first = scp; /* queue was empty */
|
||||
|
|
@ -3899,6 +3887,39 @@ static const char *gdth_info(struct Scsi_Host *shp)
|
|||
return ((const char *)ha->binfo.type_string);
|
||||
}
|
||||
|
||||
static enum blk_eh_timer_return gdth_timed_out(struct scsi_cmnd *scp)
|
||||
{
|
||||
gdth_ha_str *ha = shost_priv(scp->device->host);
|
||||
struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
|
||||
unchar b, t;
|
||||
ulong flags;
|
||||
enum blk_eh_timer_return retval = BLK_EH_NOT_HANDLED;
|
||||
|
||||
TRACE(("%s() cmd 0x%x\n", scp->cmnd[0], __func__));
|
||||
b = scp->device->channel;
|
||||
t = scp->device->id;
|
||||
|
||||
/*
|
||||
* We don't really honor the command timeout, but we try to
|
||||
* honor 6 times of the actual command timeout! So reset the
|
||||
* timer if this is less than 6th timeout on this command!
|
||||
*/
|
||||
if (++cmndinfo->timeout_count < 6)
|
||||
retval = BLK_EH_RESET_TIMER;
|
||||
|
||||
/* Reset the timeout if it is locked IO */
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha, b)].lock) ||
|
||||
(b == ha->virt_bus && t < MAX_HDRIVES && ha->hdr[t].lock)) {
|
||||
TRACE2(("%s(): locked IO, reset timeout\n", __func__));
|
||||
retval = BLK_EH_RESET_TIMER;
|
||||
}
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
static int gdth_eh_bus_reset(Scsi_Cmnd *scp)
|
||||
{
|
||||
gdth_ha_str *ha = shost_priv(scp->device->host);
|
||||
|
|
@ -3992,7 +4013,7 @@ static int gdth_queuecommand(struct scsi_cmnd *scp,
|
|||
BUG_ON(!cmndinfo);
|
||||
|
||||
scp->scsi_done = done;
|
||||
gdth_update_timeout(scp, scp->timeout_per_command * 6);
|
||||
cmndinfo->timeout_count = 0;
|
||||
cmndinfo->priority = DEFAULT_PRI;
|
||||
|
||||
return __gdth_queuecommand(ha, scp, cmndinfo);
|
||||
|
|
@ -4096,12 +4117,10 @@ static int ioc_lockdrv(void __user *arg)
|
|||
ha->hdr[j].lock = 1;
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
gdth_wait_completion(ha, ha->bus_cnt, j);
|
||||
gdth_stop_timeout(ha, ha->bus_cnt, j);
|
||||
} else {
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
ha->hdr[j].lock = 0;
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
gdth_start_timeout(ha, ha->bus_cnt, j);
|
||||
gdth_next(ha);
|
||||
}
|
||||
}
|
||||
|
|
@ -4539,18 +4558,14 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
|
|||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
ha->raw[i].lock = 1;
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
for (j = 0; j < ha->tid_cnt; ++j) {
|
||||
for (j = 0; j < ha->tid_cnt; ++j)
|
||||
gdth_wait_completion(ha, i, j);
|
||||
gdth_stop_timeout(ha, i, j);
|
||||
}
|
||||
} else {
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
ha->raw[i].lock = 0;
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
for (j = 0; j < ha->tid_cnt; ++j) {
|
||||
gdth_start_timeout(ha, i, j);
|
||||
for (j = 0; j < ha->tid_cnt; ++j)
|
||||
gdth_next(ha);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -4644,6 +4659,7 @@ static struct scsi_host_template gdth_template = {
|
|||
.slave_configure = gdth_slave_configure,
|
||||
.bios_param = gdth_bios_param,
|
||||
.proc_info = gdth_proc_info,
|
||||
.eh_timed_out = gdth_timed_out,
|
||||
.proc_name = "gdth",
|
||||
.can_queue = GDTH_MAXCMDS,
|
||||
.this_id = -1,
|
||||
|
|
|
|||
|
|
@ -916,7 +916,7 @@ typedef struct {
|
|||
gdth_cmd_str *internal_cmd_str; /* crier for internal messages*/
|
||||
dma_addr_t sense_paddr; /* sense dma-addr */
|
||||
unchar priority;
|
||||
int timeout;
|
||||
int timeout_count; /* # of timeout calls */
|
||||
volatile int wait_for_completion;
|
||||
ushort status;
|
||||
ulong32 info;
|
||||
|
|
|
|||
|
|
@ -748,69 +748,3 @@ static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
|
|||
}
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
}
|
||||
|
||||
static void gdth_stop_timeout(gdth_ha_str *ha, int busnum, int id)
|
||||
{
|
||||
ulong flags;
|
||||
Scsi_Cmnd *scp;
|
||||
unchar b, t;
|
||||
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
|
||||
for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
|
||||
struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
|
||||
if (!cmndinfo->internal_command) {
|
||||
b = scp->device->channel;
|
||||
t = scp->device->id;
|
||||
if (t == (unchar)id && b == (unchar)busnum) {
|
||||
TRACE2(("gdth_stop_timeout(): update_timeout()\n"));
|
||||
cmndinfo->timeout = gdth_update_timeout(scp, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
}
|
||||
|
||||
static void gdth_start_timeout(gdth_ha_str *ha, int busnum, int id)
|
||||
{
|
||||
ulong flags;
|
||||
Scsi_Cmnd *scp;
|
||||
unchar b, t;
|
||||
|
||||
spin_lock_irqsave(&ha->smp_lock, flags);
|
||||
|
||||
for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
|
||||
struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
|
||||
if (!cmndinfo->internal_command) {
|
||||
b = scp->device->channel;
|
||||
t = scp->device->id;
|
||||
if (t == (unchar)id && b == (unchar)busnum) {
|
||||
TRACE2(("gdth_start_timeout(): update_timeout()\n"));
|
||||
gdth_update_timeout(scp, cmndinfo->timeout);
|
||||
}
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&ha->smp_lock, flags);
|
||||
}
|
||||
|
||||
static int gdth_update_timeout(Scsi_Cmnd *scp, int timeout)
|
||||
{
|
||||
int oldto;
|
||||
|
||||
oldto = scp->timeout_per_command;
|
||||
scp->timeout_per_command = timeout;
|
||||
|
||||
if (timeout == 0) {
|
||||
del_timer(&scp->eh_timeout);
|
||||
scp->eh_timeout.data = (unsigned long) NULL;
|
||||
scp->eh_timeout.expires = 0;
|
||||
} else {
|
||||
if (scp->eh_timeout.data != (unsigned long) NULL)
|
||||
del_timer(&scp->eh_timeout);
|
||||
scp->eh_timeout.data = (unsigned long) scp;
|
||||
scp->eh_timeout.expires = jiffies + timeout;
|
||||
add_timer(&scp->eh_timeout);
|
||||
}
|
||||
|
||||
return oldto;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,9 +20,6 @@ static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
|
|||
ulong64 *paddr);
|
||||
static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr);
|
||||
static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id);
|
||||
static void gdth_stop_timeout(gdth_ha_str *ha, int busnum, int id);
|
||||
static void gdth_start_timeout(gdth_ha_str *ha, int busnum, int id);
|
||||
static int gdth_update_timeout(Scsi_Cmnd *scp, int timeout);
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -756,7 +756,7 @@ static int ibmvscsi_queuecommand(struct scsi_cmnd *cmnd,
|
|||
init_event_struct(evt_struct,
|
||||
handle_cmd_rsp,
|
||||
VIOSRP_SRP_FORMAT,
|
||||
cmnd->timeout_per_command/HZ);
|
||||
cmnd->request->timeout/HZ);
|
||||
|
||||
evt_struct->cmnd = cmnd;
|
||||
evt_struct->cmnd_done = done;
|
||||
|
|
|
|||
|
|
@ -612,7 +612,7 @@ static int idescsi_queue (struct scsi_cmnd *cmd,
|
|||
pc->req_xfer = pc->buf_size = scsi_bufflen(cmd);
|
||||
pc->scsi_cmd = cmd;
|
||||
pc->done = done;
|
||||
pc->timeout = jiffies + cmd->timeout_per_command;
|
||||
pc->timeout = jiffies + cmd->request->timeout;
|
||||
|
||||
if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {
|
||||
printk ("ide-scsi: %s: que %lu, cmd = ", drive->name, cmd->serial_number);
|
||||
|
|
|
|||
|
|
@ -3670,7 +3670,8 @@ static int ipr_slave_configure(struct scsi_device *sdev)
|
|||
sdev->no_uld_attach = 1;
|
||||
}
|
||||
if (ipr_is_vset_device(res)) {
|
||||
sdev->timeout = IPR_VSET_RW_TIMEOUT;
|
||||
blk_queue_rq_timeout(sdev->request_queue,
|
||||
IPR_VSET_RW_TIMEOUT);
|
||||
blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
|
||||
}
|
||||
if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
|
||||
|
|
|
|||
|
|
@ -3818,7 +3818,7 @@ ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
|
|||
scb->cmd.dcdb.segment_4G = 0;
|
||||
scb->cmd.dcdb.enhanced_sg = 0;
|
||||
|
||||
TimeOut = scb->scsi_cmd->timeout_per_command;
|
||||
TimeOut = scb->scsi_cmd->request->timeout;
|
||||
|
||||
if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
|
||||
if (!scb->sg_len) {
|
||||
|
|
|
|||
|
|
@ -1476,12 +1476,12 @@ static void iscsi_start_tx(struct iscsi_conn *conn)
|
|||
scsi_queue_work(conn->session->host, &conn->xmitwork);
|
||||
}
|
||||
|
||||
static enum scsi_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
|
||||
static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
|
||||
{
|
||||
struct iscsi_cls_session *cls_session;
|
||||
struct iscsi_session *session;
|
||||
struct iscsi_conn *conn;
|
||||
enum scsi_eh_timer_return rc = EH_NOT_HANDLED;
|
||||
enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
|
||||
|
||||
cls_session = starget_to_session(scsi_target(scmd->device));
|
||||
session = cls_session->dd_data;
|
||||
|
|
@ -1494,14 +1494,14 @@ static enum scsi_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
|
|||
* We are probably in the middle of iscsi recovery so let
|
||||
* that complete and handle the error.
|
||||
*/
|
||||
rc = EH_RESET_TIMER;
|
||||
rc = BLK_EH_RESET_TIMER;
|
||||
goto done;
|
||||
}
|
||||
|
||||
conn = session->leadconn;
|
||||
if (!conn) {
|
||||
/* In the middle of shuting down */
|
||||
rc = EH_RESET_TIMER;
|
||||
rc = BLK_EH_RESET_TIMER;
|
||||
goto done;
|
||||
}
|
||||
|
||||
|
|
@ -1513,20 +1513,21 @@ static enum scsi_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
|
|||
*/
|
||||
if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) +
|
||||
(conn->ping_timeout * HZ), jiffies))
|
||||
rc = EH_RESET_TIMER;
|
||||
rc = BLK_EH_RESET_TIMER;
|
||||
/*
|
||||
* if we are about to check the transport then give the command
|
||||
* more time
|
||||
*/
|
||||
if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ),
|
||||
jiffies))
|
||||
rc = EH_RESET_TIMER;
|
||||
rc = BLK_EH_RESET_TIMER;
|
||||
/* if in the middle of checking the transport then give us more time */
|
||||
if (conn->ping_task)
|
||||
rc = EH_RESET_TIMER;
|
||||
rc = BLK_EH_RESET_TIMER;
|
||||
done:
|
||||
spin_unlock(&session->lock);
|
||||
debug_scsi("return %s\n", rc == EH_RESET_TIMER ? "timer reset" : "nh");
|
||||
debug_scsi("return %s\n", rc == BLK_EH_RESET_TIMER ?
|
||||
"timer reset" : "nh");
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -398,7 +398,7 @@ void sas_ata_task_abort(struct sas_task *task)
|
|||
|
||||
/* Bounce SCSI-initiated commands to the SCSI EH */
|
||||
if (qc->scsicmd) {
|
||||
scsi_req_abort_cmd(qc->scsicmd);
|
||||
blk_abort_request(qc->scsicmd->request);
|
||||
scsi_schedule_eh(qc->scsicmd->device->host);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ void sas_unregister_phys(struct sas_ha_struct *sas_ha);
|
|||
int sas_register_ports(struct sas_ha_struct *sas_ha);
|
||||
void sas_unregister_ports(struct sas_ha_struct *sas_ha);
|
||||
|
||||
enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *);
|
||||
enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *);
|
||||
|
||||
int sas_init_queue(struct sas_ha_struct *sas_ha);
|
||||
int sas_init_events(struct sas_ha_struct *sas_ha);
|
||||
|
|
|
|||
|
|
@ -673,43 +673,43 @@ out:
|
|||
return;
|
||||
}
|
||||
|
||||
enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
|
||||
enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
|
||||
{
|
||||
struct sas_task *task = TO_SAS_TASK(cmd);
|
||||
unsigned long flags;
|
||||
|
||||
if (!task) {
|
||||
cmd->timeout_per_command /= 2;
|
||||
cmd->request->timeout /= 2;
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, gone: %s\n",
|
||||
cmd, task, (cmd->timeout_per_command ?
|
||||
"EH_RESET_TIMER" : "EH_NOT_HANDLED"));
|
||||
if (!cmd->timeout_per_command)
|
||||
return EH_NOT_HANDLED;
|
||||
return EH_RESET_TIMER;
|
||||
cmd, task, (cmd->request->timeout ?
|
||||
"BLK_EH_RESET_TIMER" : "BLK_EH_NOT_HANDLED"));
|
||||
if (!cmd->request->timeout)
|
||||
return BLK_EH_NOT_HANDLED;
|
||||
return BLK_EH_RESET_TIMER;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&task->task_state_lock, flags);
|
||||
BUG_ON(task->task_state_flags & SAS_TASK_STATE_ABORTED);
|
||||
if (task->task_state_flags & SAS_TASK_STATE_DONE) {
|
||||
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n",
|
||||
cmd, task);
|
||||
return EH_HANDLED;
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, timed out: "
|
||||
"BLK_EH_HANDLED\n", cmd, task);
|
||||
return BLK_EH_HANDLED;
|
||||
}
|
||||
if (!(task->task_state_flags & SAS_TASK_AT_INITIATOR)) {
|
||||
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, not at initiator: "
|
||||
"EH_RESET_TIMER\n",
|
||||
"BLK_EH_RESET_TIMER\n",
|
||||
cmd, task);
|
||||
return EH_RESET_TIMER;
|
||||
return BLK_EH_RESET_TIMER;
|
||||
}
|
||||
task->task_state_flags |= SAS_TASK_STATE_ABORTED;
|
||||
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
||||
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_NOT_HANDLED\n",
|
||||
SAS_DPRINTK("command 0x%p, task 0x%p, timed out: BLK_EH_NOT_HANDLED\n",
|
||||
cmd, task);
|
||||
|
||||
return EH_NOT_HANDLED;
|
||||
return BLK_EH_NOT_HANDLED;
|
||||
}
|
||||
|
||||
int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
|
||||
|
|
@ -1039,7 +1039,7 @@ void sas_task_abort(struct sas_task *task)
|
|||
return;
|
||||
}
|
||||
|
||||
scsi_req_abort_cmd(sc);
|
||||
blk_abort_request(sc->request);
|
||||
scsi_schedule_eh(sc->device->host);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1167,7 +1167,7 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
|
|||
* cmd has not been completed within the timeout period.
|
||||
*/
|
||||
static enum
|
||||
scsi_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
|
||||
blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
|
||||
{
|
||||
struct megasas_cmd *cmd = (struct megasas_cmd *)scmd->SCp.ptr;
|
||||
struct megasas_instance *instance;
|
||||
|
|
@ -1175,7 +1175,7 @@ scsi_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
|
|||
|
||||
if (time_after(jiffies, scmd->jiffies_at_alloc +
|
||||
(MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
|
||||
return EH_NOT_HANDLED;
|
||||
return BLK_EH_NOT_HANDLED;
|
||||
}
|
||||
|
||||
instance = cmd->instance;
|
||||
|
|
@ -1189,7 +1189,7 @@ scsi_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
|
|||
|
||||
spin_unlock_irqrestore(instance->host->host_lock, flags);
|
||||
}
|
||||
return EH_RESET_TIMER;
|
||||
return BLK_EH_RESET_TIMER;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -4170,8 +4170,8 @@ static int ncr_queue_command (struct ncb *np, struct scsi_cmnd *cmd)
|
|||
**
|
||||
**----------------------------------------------------
|
||||
*/
|
||||
if (np->settle_time && cmd->timeout_per_command >= HZ) {
|
||||
u_long tlimit = jiffies + cmd->timeout_per_command - HZ;
|
||||
if (np->settle_time && cmd->request->timeout >= HZ) {
|
||||
u_long tlimit = jiffies + cmd->request->timeout - HZ;
|
||||
if (time_after(np->settle_time, tlimit))
|
||||
np->settle_time = tlimit;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2845,7 +2845,7 @@ qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
|
|||
memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
|
||||
|
||||
/* Set ISP command timeout. */
|
||||
pkt->timeout = cpu_to_le16(cmd->timeout_per_command/HZ);
|
||||
pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
|
||||
|
||||
/* Set device target ID and LUN */
|
||||
pkt->lun = SCSI_LUN_32(cmd);
|
||||
|
|
@ -3114,7 +3114,7 @@ qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
|
|||
memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
|
||||
|
||||
/* Set ISP command timeout. */
|
||||
pkt->timeout = cpu_to_le16(cmd->timeout_per_command/HZ);
|
||||
pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
|
||||
|
||||
/* Set device target ID and LUN */
|
||||
pkt->lun = SCSI_LUN_32(cmd);
|
||||
|
|
|
|||
|
|
@ -1542,7 +1542,7 @@ static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd)
|
|||
DEBUG2(printk(KERN_INFO
|
||||
"scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x,"
|
||||
"dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no,
|
||||
cmd, jiffies, cmd->timeout_per_command / HZ,
|
||||
cmd, jiffies, cmd->request->timeout / HZ,
|
||||
ha->dpc_flags, cmd->result, cmd->allowed));
|
||||
|
||||
/* FIXME: wait for hba to go online */
|
||||
|
|
@ -1598,7 +1598,7 @@ static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd)
|
|||
DEBUG2(printk(KERN_INFO
|
||||
"scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, "
|
||||
"to=%x,dpc_flags=%lx, status=%x allowed=%d\n",
|
||||
ha->host_no, cmd, jiffies, cmd->timeout_per_command / HZ,
|
||||
ha->host_no, cmd, jiffies, cmd->request->timeout / HZ,
|
||||
ha->dpc_flags, cmd->result, cmd->allowed));
|
||||
|
||||
stat = qla4xxx_reset_target(ha, ddb_entry);
|
||||
|
|
|
|||
|
|
@ -291,7 +291,6 @@ struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
|
|||
unsigned long flags;
|
||||
|
||||
cmd->device = dev;
|
||||
init_timer(&cmd->eh_timeout);
|
||||
INIT_LIST_HEAD(&cmd->list);
|
||||
spin_lock_irqsave(&dev->list_lock, flags);
|
||||
list_add_tail(&cmd->list, &dev->cmd_list);
|
||||
|
|
@ -652,14 +651,19 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
unsigned long timeout;
|
||||
int rtn = 0;
|
||||
|
||||
/*
|
||||
* We will use a queued command if possible, otherwise we will
|
||||
* emulate the queuing and calling of completion function ourselves.
|
||||
*/
|
||||
atomic_inc(&cmd->device->iorequest_cnt);
|
||||
|
||||
/* check if the device is still usable */
|
||||
if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
|
||||
/* in SDEV_DEL we error all commands. DID_NO_CONNECT
|
||||
* returns an immediate error upwards, and signals
|
||||
* that the device is no longer present */
|
||||
cmd->result = DID_NO_CONNECT << 16;
|
||||
atomic_inc(&cmd->device->iorequest_cnt);
|
||||
__scsi_done(cmd);
|
||||
scsi_done(cmd);
|
||||
/* return 0 (because the command has been processed) */
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -672,6 +676,7 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
* future requests should not occur until the device
|
||||
* transitions out of the suspend state.
|
||||
*/
|
||||
|
||||
scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
|
||||
|
||||
SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
|
||||
|
|
@ -714,20 +719,8 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
host->resetting = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* AK: unlikely race here: for some reason the timer could
|
||||
* expire before the serial number is set up below.
|
||||
*/
|
||||
scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
|
||||
|
||||
scsi_log_send(cmd);
|
||||
|
||||
/*
|
||||
* We will use a queued command if possible, otherwise we will
|
||||
* emulate the queuing and calling of completion function ourselves.
|
||||
*/
|
||||
atomic_inc(&cmd->device->iorequest_cnt);
|
||||
|
||||
/*
|
||||
* Before we queue this command, check if the command
|
||||
* length exceeds what the host adapter can handle.
|
||||
|
|
@ -744,6 +737,12 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
}
|
||||
|
||||
spin_lock_irqsave(host->host_lock, flags);
|
||||
/*
|
||||
* AK: unlikely race here: for some reason the timer could
|
||||
* expire before the serial number is set up below.
|
||||
*
|
||||
* TODO: kill serial or move to blk layer
|
||||
*/
|
||||
scsi_cmd_get_serial(host, cmd);
|
||||
|
||||
if (unlikely(host->shost_state == SHOST_DEL)) {
|
||||
|
|
@ -754,12 +753,8 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
}
|
||||
spin_unlock_irqrestore(host->host_lock, flags);
|
||||
if (rtn) {
|
||||
if (scsi_delete_timer(cmd)) {
|
||||
atomic_inc(&cmd->device->iodone_cnt);
|
||||
scsi_queue_insert(cmd,
|
||||
(rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
|
||||
rtn : SCSI_MLQUEUE_HOST_BUSY);
|
||||
}
|
||||
scsi_queue_insert(cmd, (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
|
||||
rtn : SCSI_MLQUEUE_HOST_BUSY);
|
||||
SCSI_LOG_MLQUEUE(3,
|
||||
printk("queuecommand : request rejected\n"));
|
||||
}
|
||||
|
|
@ -769,24 +764,6 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|||
return rtn;
|
||||
}
|
||||
|
||||
/**
|
||||
* scsi_req_abort_cmd -- Request command recovery for the specified command
|
||||
* @cmd: pointer to the SCSI command of interest
|
||||
*
|
||||
* This function requests that SCSI Core start recovery for the
|
||||
* command by deleting the timer and adding the command to the eh
|
||||
* queue. It can be called by either LLDDs or SCSI Core. LLDDs who
|
||||
* implement their own error recovery MAY ignore the timeout event if
|
||||
* they generated scsi_req_abort_cmd.
|
||||
*/
|
||||
void scsi_req_abort_cmd(struct scsi_cmnd *cmd)
|
||||
{
|
||||
if (!scsi_delete_timer(cmd))
|
||||
return;
|
||||
scsi_times_out(cmd);
|
||||
}
|
||||
EXPORT_SYMBOL(scsi_req_abort_cmd);
|
||||
|
||||
/**
|
||||
* scsi_done - Enqueue the finished SCSI command into the done queue.
|
||||
* @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
|
||||
|
|
@ -802,42 +779,7 @@ EXPORT_SYMBOL(scsi_req_abort_cmd);
|
|||
*/
|
||||
static void scsi_done(struct scsi_cmnd *cmd)
|
||||
{
|
||||
/*
|
||||
* We don't have to worry about this one timing out anymore.
|
||||
* If we are unable to remove the timer, then the command
|
||||
* has already timed out. In which case, we have no choice but to
|
||||
* let the timeout function run, as we have no idea where in fact
|
||||
* that function could really be. It might be on another processor,
|
||||
* etc, etc.
|
||||
*/
|
||||
if (!scsi_delete_timer(cmd))
|
||||
return;
|
||||
__scsi_done(cmd);
|
||||
}
|
||||
|
||||
/* Private entry to scsi_done() to complete a command when the timer
|
||||
* isn't running --- used by scsi_times_out */
|
||||
void __scsi_done(struct scsi_cmnd *cmd)
|
||||
{
|
||||
struct request *rq = cmd->request;
|
||||
|
||||
/*
|
||||
* Set the serial numbers back to zero
|
||||
*/
|
||||
cmd->serial_number = 0;
|
||||
|
||||
atomic_inc(&cmd->device->iodone_cnt);
|
||||
if (cmd->result)
|
||||
atomic_inc(&cmd->device->ioerr_cnt);
|
||||
|
||||
BUG_ON(!rq);
|
||||
|
||||
/*
|
||||
* The uptodate/nbytes values don't matter, as we allow partial
|
||||
* completes and thus will check this in the softirq callback
|
||||
*/
|
||||
rq->completion_data = cmd;
|
||||
blk_complete_request(rq);
|
||||
blk_complete_request(cmd->request);
|
||||
}
|
||||
|
||||
/* Move this to a header if it becomes more generally useful */
|
||||
|
|
|
|||
|
|
@ -111,70 +111,9 @@ int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* scsi_add_timer - Start timeout timer for a single scsi command.
|
||||
* @scmd: scsi command that is about to start running.
|
||||
* @timeout: amount of time to allow this command to run.
|
||||
* @complete: timeout function to call if timer isn't canceled.
|
||||
*
|
||||
* Notes:
|
||||
* This should be turned into an inline function. Each scsi command
|
||||
* has its own timer, and as it is added to the queue, we set up the
|
||||
* timer. When the command completes, we cancel the timer.
|
||||
*/
|
||||
void scsi_add_timer(struct scsi_cmnd *scmd, int timeout,
|
||||
void (*complete)(struct scsi_cmnd *))
|
||||
{
|
||||
|
||||
/*
|
||||
* If the clock was already running for this command, then
|
||||
* first delete the timer. The timer handling code gets rather
|
||||
* confused if we don't do this.
|
||||
*/
|
||||
if (scmd->eh_timeout.function)
|
||||
del_timer(&scmd->eh_timeout);
|
||||
|
||||
scmd->eh_timeout.data = (unsigned long)scmd;
|
||||
scmd->eh_timeout.expires = jiffies + timeout;
|
||||
scmd->eh_timeout.function = (void (*)(unsigned long)) complete;
|
||||
|
||||
SCSI_LOG_ERROR_RECOVERY(5, printk("%s: scmd: %p, time:"
|
||||
" %d, (%p)\n", __func__,
|
||||
scmd, timeout, complete));
|
||||
|
||||
add_timer(&scmd->eh_timeout);
|
||||
}
|
||||
|
||||
/**
|
||||
* scsi_delete_timer - Delete/cancel timer for a given function.
|
||||
* @scmd: Cmd that we are canceling timer for
|
||||
*
|
||||
* Notes:
|
||||
* This should be turned into an inline function.
|
||||
*
|
||||
* Return value:
|
||||
* 1 if we were able to detach the timer. 0 if we blew it, and the
|
||||
* timer function has already started to run.
|
||||
*/
|
||||
int scsi_delete_timer(struct scsi_cmnd *scmd)
|
||||
{
|
||||
int rtn;
|
||||
|
||||
rtn = del_timer(&scmd->eh_timeout);
|
||||
|
||||
SCSI_LOG_ERROR_RECOVERY(5, printk("%s: scmd: %p,"
|
||||
" rtn: %d\n", __func__,
|
||||
scmd, rtn));
|
||||
|
||||
scmd->eh_timeout.data = (unsigned long)NULL;
|
||||
scmd->eh_timeout.function = NULL;
|
||||
|
||||
return rtn;
|
||||
}
|
||||
|
||||
/**
|
||||
* scsi_times_out - Timeout function for normal scsi commands.
|
||||
* @scmd: Cmd that is timing out.
|
||||
* @req: request that is timing out.
|
||||
*
|
||||
* Notes:
|
||||
* We do not need to lock this. There is the potential for a race
|
||||
|
|
@ -182,9 +121,11 @@ int scsi_delete_timer(struct scsi_cmnd *scmd)
|
|||
* normal completion function determines that the timer has already
|
||||
* fired, then it mustn't do anything.
|
||||
*/
|
||||
void scsi_times_out(struct scsi_cmnd *scmd)
|
||||
enum blk_eh_timer_return scsi_times_out(struct request *req)
|
||||
{
|
||||
enum scsi_eh_timer_return (* eh_timed_out)(struct scsi_cmnd *);
|
||||
struct scsi_cmnd *scmd = req->special;
|
||||
enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
|
||||
enum blk_eh_timer_return rtn = BLK_EH_NOT_HANDLED;
|
||||
|
||||
scsi_log_completion(scmd, TIMEOUT_ERROR);
|
||||
|
||||
|
|
@ -196,22 +137,20 @@ void scsi_times_out(struct scsi_cmnd *scmd)
|
|||
eh_timed_out = NULL;
|
||||
|
||||
if (eh_timed_out)
|
||||
switch (eh_timed_out(scmd)) {
|
||||
case EH_HANDLED:
|
||||
__scsi_done(scmd);
|
||||
return;
|
||||
case EH_RESET_TIMER:
|
||||
scsi_add_timer(scmd, scmd->timeout_per_command,
|
||||
scsi_times_out);
|
||||
return;
|
||||
case EH_NOT_HANDLED:
|
||||
rtn = eh_timed_out(scmd);
|
||||
switch (rtn) {
|
||||
case BLK_EH_NOT_HANDLED:
|
||||
break;
|
||||
default:
|
||||
return rtn;
|
||||
}
|
||||
|
||||
if (unlikely(!scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD))) {
|
||||
scmd->result |= DID_TIME_OUT << 16;
|
||||
__scsi_done(scmd);
|
||||
return BLK_EH_HANDLED;
|
||||
}
|
||||
|
||||
return BLK_EH_NOT_HANDLED;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1793,7 +1732,6 @@ scsi_reset_provider(struct scsi_device *dev, int flag)
|
|||
|
||||
blk_rq_init(NULL, &req);
|
||||
scmd->request = &req;
|
||||
memset(&scmd->eh_timeout, 0, sizeof(scmd->eh_timeout));
|
||||
|
||||
scmd->cmnd = req.cmd;
|
||||
|
||||
|
|
@ -1804,8 +1742,6 @@ scsi_reset_provider(struct scsi_device *dev, int flag)
|
|||
|
||||
scmd->sc_data_direction = DMA_BIDIRECTIONAL;
|
||||
|
||||
init_timer(&scmd->eh_timeout);
|
||||
|
||||
spin_lock_irqsave(shost->host_lock, flags);
|
||||
shost->tmf_in_progress = 1;
|
||||
spin_unlock_irqrestore(shost->host_lock, flags);
|
||||
|
|
|
|||
|
|
@ -1181,7 +1181,6 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
|
|||
|
||||
cmd->transfersize = req->data_len;
|
||||
cmd->allowed = req->retries;
|
||||
cmd->timeout_per_command = req->timeout;
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd);
|
||||
|
|
@ -1416,17 +1415,26 @@ static void scsi_kill_request(struct request *req, struct request_queue *q)
|
|||
spin_unlock(shost->host_lock);
|
||||
spin_lock(sdev->request_queue->queue_lock);
|
||||
|
||||
__scsi_done(cmd);
|
||||
blk_complete_request(req);
|
||||
}
|
||||
|
||||
static void scsi_softirq_done(struct request *rq)
|
||||
{
|
||||
struct scsi_cmnd *cmd = rq->completion_data;
|
||||
unsigned long wait_for = (cmd->allowed + 1) * cmd->timeout_per_command;
|
||||
struct scsi_cmnd *cmd = rq->special;
|
||||
unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
|
||||
int disposition;
|
||||
|
||||
INIT_LIST_HEAD(&cmd->eh_entry);
|
||||
|
||||
/*
|
||||
* Set the serial numbers back to zero
|
||||
*/
|
||||
cmd->serial_number = 0;
|
||||
|
||||
atomic_inc(&cmd->device->iodone_cnt);
|
||||
if (cmd->result)
|
||||
atomic_inc(&cmd->device->ioerr_cnt);
|
||||
|
||||
disposition = scsi_decide_disposition(cmd);
|
||||
if (disposition != SUCCESS &&
|
||||
time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
|
||||
|
|
@ -1675,6 +1683,7 @@ struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)
|
|||
|
||||
blk_queue_prep_rq(q, scsi_prep_fn);
|
||||
blk_queue_softirq_done(q, scsi_softirq_done);
|
||||
blk_queue_rq_timed_out(q, scsi_times_out);
|
||||
return q;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
#include <linux/device.h>
|
||||
|
||||
struct request_queue;
|
||||
struct request;
|
||||
struct scsi_cmnd;
|
||||
struct scsi_device;
|
||||
struct scsi_host_template;
|
||||
|
|
@ -27,7 +28,6 @@ extern void scsi_exit_hosts(void);
|
|||
extern int scsi_dispatch_cmd(struct scsi_cmnd *cmd);
|
||||
extern int scsi_setup_command_freelist(struct Scsi_Host *shost);
|
||||
extern void scsi_destroy_command_freelist(struct Scsi_Host *shost);
|
||||
extern void __scsi_done(struct scsi_cmnd *cmd);
|
||||
#ifdef CONFIG_SCSI_LOGGING
|
||||
void scsi_log_send(struct scsi_cmnd *cmd);
|
||||
void scsi_log_completion(struct scsi_cmnd *cmd, int disposition);
|
||||
|
|
@ -49,10 +49,7 @@ extern int __init scsi_init_devinfo(void);
|
|||
extern void scsi_exit_devinfo(void);
|
||||
|
||||
/* scsi_error.c */
|
||||
extern void scsi_add_timer(struct scsi_cmnd *, int,
|
||||
void (*)(struct scsi_cmnd *));
|
||||
extern int scsi_delete_timer(struct scsi_cmnd *);
|
||||
extern void scsi_times_out(struct scsi_cmnd *cmd);
|
||||
extern enum blk_eh_timer_return scsi_times_out(struct request *req);
|
||||
extern int scsi_error_handler(void *host);
|
||||
extern int scsi_decide_disposition(struct scsi_cmnd *cmd);
|
||||
extern void scsi_eh_wakeup(struct Scsi_Host *shost);
|
||||
|
|
|
|||
|
|
@ -560,12 +560,15 @@ sdev_rd_attr (vendor, "%.8s\n");
|
|||
sdev_rd_attr (model, "%.16s\n");
|
||||
sdev_rd_attr (rev, "%.4s\n");
|
||||
|
||||
/*
|
||||
* TODO: can we make these symlinks to the block layer ones?
|
||||
*/
|
||||
static ssize_t
|
||||
sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct scsi_device *sdev;
|
||||
sdev = to_scsi_device(dev);
|
||||
return snprintf (buf, 20, "%d\n", sdev->timeout / HZ);
|
||||
return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
|
|
@ -576,7 +579,7 @@ sdev_store_timeout (struct device *dev, struct device_attribute *attr,
|
|||
int timeout;
|
||||
sdev = to_scsi_device(dev);
|
||||
sscanf (buf, "%d\n", &timeout);
|
||||
sdev->timeout = timeout * HZ;
|
||||
blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
|
||||
return count;
|
||||
}
|
||||
static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
|
||||
|
|
|
|||
|
|
@ -1950,15 +1950,15 @@ static int fc_vport_match(struct attribute_container *cont,
|
|||
* Notes:
|
||||
* This routine assumes no locks are held on entry.
|
||||
*/
|
||||
static enum scsi_eh_timer_return
|
||||
static enum blk_eh_timer_return
|
||||
fc_timed_out(struct scsi_cmnd *scmd)
|
||||
{
|
||||
struct fc_rport *rport = starget_to_rport(scsi_target(scmd->device));
|
||||
|
||||
if (rport->port_state == FC_PORTSTATE_BLOCKED)
|
||||
return EH_RESET_TIMER;
|
||||
return BLK_EH_RESET_TIMER;
|
||||
|
||||
return EH_NOT_HANDLED;
|
||||
return BLK_EH_NOT_HANDLED;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -383,7 +383,6 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
sector_t block = rq->sector;
|
||||
sector_t threshold;
|
||||
unsigned int this_count = rq->nr_sectors;
|
||||
unsigned int timeout = sdp->timeout;
|
||||
int ret;
|
||||
|
||||
if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
|
||||
|
|
@ -584,7 +583,6 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
SCpnt->transfersize = sdp->sector_size;
|
||||
SCpnt->underflow = this_count << 9;
|
||||
SCpnt->allowed = SD_MAX_RETRIES;
|
||||
SCpnt->timeout_per_command = timeout;
|
||||
|
||||
/*
|
||||
* This indicates that the command is ready from our end to be
|
||||
|
|
@ -1878,11 +1876,12 @@ static int sd_probe(struct device *dev)
|
|||
sdkp->openers = 0;
|
||||
sdkp->previous_state = 1;
|
||||
|
||||
if (!sdp->timeout) {
|
||||
if (!sdp->request_queue->rq_timeout) {
|
||||
if (sdp->type != TYPE_MOD)
|
||||
sdp->timeout = SD_TIMEOUT;
|
||||
blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
|
||||
else
|
||||
sdp->timeout = SD_MOD_TIMEOUT;
|
||||
blk_queue_rq_timeout(sdp->request_queue,
|
||||
SD_MOD_TIMEOUT);
|
||||
}
|
||||
|
||||
device_initialize(&sdkp->dev);
|
||||
|
|
|
|||
|
|
@ -331,7 +331,7 @@ static int sr_done(struct scsi_cmnd *SCpnt)
|
|||
|
||||
static int sr_prep_fn(struct request_queue *q, struct request *rq)
|
||||
{
|
||||
int block=0, this_count, s_size, timeout = SR_TIMEOUT;
|
||||
int block = 0, this_count, s_size;
|
||||
struct scsi_cd *cd;
|
||||
struct scsi_cmnd *SCpnt;
|
||||
struct scsi_device *sdp = q->queuedata;
|
||||
|
|
@ -461,7 +461,6 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
|
|||
SCpnt->transfersize = cd->device->sector_size;
|
||||
SCpnt->underflow = this_count << 9;
|
||||
SCpnt->allowed = MAX_RETRIES;
|
||||
SCpnt->timeout_per_command = timeout;
|
||||
|
||||
/*
|
||||
* This indicates that the command is ready from our end to be
|
||||
|
|
@ -620,6 +619,8 @@ static int sr_probe(struct device *dev)
|
|||
disk->fops = &sr_bdops;
|
||||
disk->flags = GENHD_FL_CD;
|
||||
|
||||
blk_queue_rq_timeout(sdev->request_queue, SR_TIMEOUT);
|
||||
|
||||
cd->device = sdev;
|
||||
cd->disk = disk;
|
||||
cd->driver = &sr_template;
|
||||
|
|
|
|||
|
|
@ -519,8 +519,8 @@ static int sym53c8xx_queue_command(struct scsi_cmnd *cmd,
|
|||
* Shorten our settle_time if needed for
|
||||
* this command not to time out.
|
||||
*/
|
||||
if (np->s.settle_time_valid && cmd->timeout_per_command) {
|
||||
unsigned long tlimit = jiffies + cmd->timeout_per_command;
|
||||
if (np->s.settle_time_valid && cmd->request->timeout) {
|
||||
unsigned long tlimit = jiffies + cmd->request->timeout;
|
||||
tlimit -= SYM_CONF_TIMER_INTERVAL*2;
|
||||
if (time_after(np->s.settle_time, tlimit)) {
|
||||
np->s.settle_time = tlimit;
|
||||
|
|
|
|||
Loading…
Reference in a new issue