hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[SCSI] allow sleeping in ->eh_device_reset_handler() 

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
This commit is contained in:
Jeff Garzik 2005-05-28 07:55:48 -04:00
parent 8fa728a268
commit 94d0e7b805
17 changed files with 98 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Documentation/scsi/scsi_mid_low_api.txt
View File

@ -973,8 +973,7 @@ Details:
*
* Returns SUCCESS if command aborted else FAILED
*
* Locks: struct Scsi_Host::host_lock held (with irqsave) on entry
* and assumed to be held on return.
* Locks: None held
*
* Calling context: kernel thread
*

14
drivers/ieee1394/sbp2.c
View File

@ -2615,7 +2615,7 @@ static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
/*
* Called by scsi stack when something has really gone wrong.
*/
static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
static int __sbp2scsi_reset(struct scsi_cmnd *SCpnt)
{
struct scsi_id_instance_data *scsi_id =
(struct scsi_id_instance_data *)SCpnt->device->host->hostdata[0];
@ -2630,6 +2630,18 @@ static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
return(SUCCESS);
}
static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
{
unsigned long flags;
int rc;
spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
rc = __sbp2scsi_reset(SCpnt);
spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
return rc;
}
static const char *sbp2scsi_info (struct Scsi_Host *host)
{
return "SCSI emulation for IEEE-1394 SBP-2 Devices";

6
drivers/message/fusion/mptscsih.c
View File

@ -1801,7 +1801,6 @@ int
mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
{
MPT_SCSI_HOST *hd;
spinlock_t *host_lock = SCpnt->device->host->host_lock;
/* If we can't locate our host adapter structure, return FAILED status.
*/
@ -1818,7 +1817,6 @@ mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
printk(KERN_WARNING MYNAM ": %s: >> Attempting target reset! (sc=%p)\n",
hd->ioc->name, SCpnt);
spin_unlock_irq(host_lock);
if (mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
SCpnt->device->channel, SCpnt->device->id,
0, 0, 5 /* 5 second timeout */)
@ -1830,12 +1828,10 @@ mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
hd->ioc->name, SCpnt);
hd->tmPending = 0;
hd->tmState = TM_STATE_NONE;
spin_lock_irq(host_lock);
return FAILED;
}
spin_lock_irq(host_lock);
return SUCCESS;
return SUCCESS;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

3
drivers/s390/scsi/zfcp_scsi.c
View File

@ -636,8 +636,6 @@ zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
struct zfcp_unit *unit = (struct zfcp_unit *) scpnt->device->hostdata;
struct Scsi_Host *scsi_host = scpnt->device->host;
spin_unlock_irq(scsi_host->host_lock);
if (!unit) {
ZFCP_LOG_NORMAL("bug: Tried reset for nonexistent unit\n");
retval = SUCCESS;
@ -680,7 +678,6 @@ zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
retval = SUCCESS;
}
out:
spin_lock_irq(scsi_host->host_lock);
return retval;
}

2
drivers/scsi/aha152x.c
View File

@ -1225,8 +1225,6 @@ static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
}
DO_UNLOCK(flags);
spin_lock_irq(shpnt->host_lock);
return ret;
}

8
drivers/scsi/aic7xxx/aic79xx_osm.c
View File

@ -1511,17 +1511,17 @@ ahd_linux_dev_reset(Scsi_Cmnd *cmd)
ahd_name(ahd), cmd->device->channel, cmd->device->id,
cmd->device->lun, cmd);
#endif
ahd_midlayer_entrypoint_lock(ahd, &s);
ahd_lock(ahd, &s);
dev = ahd_linux_get_device(ahd, cmd->device->channel, cmd->device->id,
cmd->device->lun, /*alloc*/FALSE);
if (dev == NULL) {
ahd_midlayer_entrypoint_unlock(ahd, &s);
ahd_unlock(ahd, &s);
kfree(recovery_cmd);
return (FAILED);
}
if ((scb = ahd_get_scb(ahd, AHD_NEVER_COL_IDX)) == NULL) {
ahd_midlayer_entrypoint_unlock(ahd, &s);
ahd_unlock(ahd, &s);
kfree(recovery_cmd);
return (FAILED);
}
@ -1570,7 +1570,7 @@ ahd_linux_dev_reset(Scsi_Cmnd *cmd)
spin_lock_irq(&ahd->platform_data->spin_lock);
ahd_schedule_runq(ahd);
ahd_linux_run_complete_queue(ahd);
ahd_midlayer_entrypoint_unlock(ahd, &s);
ahd_unlock(ahd, &s);
printf("%s: Device reset returning 0x%x\n", ahd_name(ahd), retval);
return (retval);
}

14
drivers/scsi/aic7xxx_old.c
View File

@ -10358,7 +10358,7 @@ aic7xxx_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
* Returns an enumerated type that indicates the status of the operation.
*-F*************************************************************************/
static int
aic7xxx_bus_device_reset(Scsi_Cmnd *cmd)
__aic7xxx_bus_device_reset(Scsi_Cmnd *cmd)
{
struct aic7xxx_host *p;
struct aic7xxx_scb *scb;
@ -10551,6 +10551,18 @@ aic7xxx_bus_device_reset(Scsi_Cmnd *cmd)
return SUCCESS;
}
static int
aic7xxx_bus_device_reset(Scsi_Cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = __aic7xxx_bus_device_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/*+F*************************************************************************
* Function:

2
drivers/scsi/ibmvscsi/ibmvscsi.c
View File

@ -976,9 +976,7 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
return FAILED;
}
spin_unlock_irq(hostdata->host->host_lock);
wait_for_completion(&evt->comp);
spin_lock_irq(hostdata->host->host_lock);
/* make sure we got a good response */
if (unlikely(srp_rsp.srp.generic.type != SRP_RSP_TYPE)) {

13
drivers/scsi/ipr.c
View File

@ -2916,7 +2916,7 @@ static int ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
* Return value:
* SUCCESS / FAILED
**/
static int ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
{
struct ipr_cmnd *ipr_cmd;
struct ipr_ioa_cfg *ioa_cfg;
@ -2970,6 +2970,17 @@ static int ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
}
static int ipr_eh_dev_reset(struct scsi_cmnd * cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = __ipr_eh_dev_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/**
* ipr_bus_reset_done - Op done function for bus reset.
* @ipr_cmd: ipr command struct

12
drivers/scsi/lpfc/lpfc_scsi.c
View File

@ -928,7 +928,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
}
static int
lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
__lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
{
struct Scsi_Host *shost = cmnd->device->host;
struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0];
@ -1040,6 +1040,16 @@ out:
return ret;
}
static int
lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
{
int rc;
spin_lock_irq(cmnd->device->host->host_lock);
rc = __lpfc_reset_lun_handler(cmnd);
spin_unlock_irq(cmnd->device->host->host_lock);
return rc;
}
/*
* Note: midlayer calls this function with the host_lock held
*/

14
drivers/scsi/megaraid.c
View File

@ -1938,7 +1938,7 @@ megaraid_abort(Scsi_Cmnd *cmd)
static int
megaraid_reset(Scsi_Cmnd *cmd)
__megaraid_reset(Scsi_Cmnd *cmd)
{
adapter_t *adapter;
megacmd_t mc;
@ -1972,6 +1972,18 @@ megaraid_reset(Scsi_Cmnd *cmd)
return rval;
}
static int
megaraid_reset(Scsi_Cmnd *cmd)
{
adapter = (adapter_t *)cmd->device->host->hostdata;
int rc;
spin_lock_irq(&adapter->lock);
rc = __megaraid_reset(cmd);
spin_unlock_irq(&adapter->lock);
return rc;
}
/**

14
drivers/scsi/megaraid/megaraid_mbox.c
View File

@ -2726,7 +2726,7 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
* host
**/
static int
megaraid_reset_handler(struct scsi_cmnd *scp)
__megaraid_reset_handler(struct scsi_cmnd *scp)
{
adapter_t *adapter;
scb_t *scb;
@ -2847,6 +2847,18 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
return rval;
}
static int
megaraid_reset_handler(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = __megaraid_reset_handler(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/*
* START: internal commands library

8
drivers/scsi/qla1280.c
View File

@ -1114,7 +1114,13 @@ qla1280_eh_abort(struct scsi_cmnd * cmd)
static int
qla1280_eh_device_reset(struct scsi_cmnd *cmd)
{
return qla1280_error_action(cmd, DEVICE_RESET);
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, DEVICE_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/**************************************************************************

8
drivers/scsi/qla2xxx/qla_os.c
View File

@ -613,12 +613,8 @@ qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, id, lun);
spin_unlock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
spin_lock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
goto eh_dev_reset_done;
}
if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
if (qla2x00_device_reset(ha, fcport) == 0)
@ -669,8 +665,6 @@ qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
"scsi(%ld:%d:%d): DEVICE RESET SUCCEEDED.\n", ha->host_no, id, lun);
eh_dev_reset_done:
spin_lock_irq(ha->host->host_lock);
return ret;
}

7
drivers/scsi/scsi_error.c
View File

@ -857,17 +857,14 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
**/
static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
{
unsigned long flags;
int rtn = FAILED;
int rtn;
if (!scmd->device->host->hostt->eh_device_reset_handler)
return rtn;
return FAILED;
scmd->owner = SCSI_OWNER_LOWLEVEL;
spin_lock_irqsave(scmd->device->host->host_lock, flags);
rtn = scmd->device->host->hostt->eh_device_reset_handler(scmd);
spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
if (rtn == SUCCESS) {
scmd->device->was_reset = 1;

8
drivers/scsi/sym53c8xx_2/sym_glue.c
View File

@ -867,7 +867,13 @@ static int sym53c8xx_eh_abort_handler(struct scsi_cmnd *cmd)
static int sym53c8xx_eh_device_reset_handler(struct scsi_cmnd *cmd)
{
return sym_eh_handler(SYM_EH_DEVICE_RESET, "DEVICE RESET", cmd);
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = sym_eh_handler(SYM_EH_DEVICE_RESET, "DEVICE RESET", cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd *cmd)

4
drivers/usb/storage/scsiglue.c
View File

@ -253,8 +253,6 @@ static int device_reset(struct scsi_cmnd *srb)
US_DEBUGP("%s called\n", __FUNCTION__);
scsi_unlock(us_to_host(us));
/* lock the device pointers and do the reset */
down(&(us->dev_semaphore));
if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
@ -264,8 +262,6 @@ static int device_reset(struct scsi_cmnd *srb)
result = us->transport_reset(us);
up(&(us->dev_semaphore));
/* lock the host for the return */
scsi_lock(us_to_host(us));
return result;
}