adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-30 12:46:17 +00:00
Code Issues Projects Releases Packages Wiki Activity

[SCSI] allow sleeping in ->eh_host_reset_handler()

Browse source 
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
This commit is contained in:
Jeff Garzik 2005-05-28 07:57:14 -04:00
parent 68b3aa7c98
commit df0ae2497d
38 changed files with 177 additions and 44 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

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

19
drivers/fc4/fc.c
View file

@ -1005,13 +1005,7 @@ int fcp_scsi_dev_reset(Scsi_Cmnd *SCpnt)
return SUCCESS; return SUCCESS;
} }
int fcp_scsi_bus_reset(Scsi_Cmnd *SCpnt) static int __fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
{
printk ("FC: bus reset!\n");
return FAILED;
}
int fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
{ {
fc_channel *fc = FC_SCMND(SCpnt); fc_channel *fc = FC_SCMND(SCpnt);
fcp_cmnd *fcmd = FCP_CMND(SCpnt); fcp_cmnd *fcmd = FCP_CMND(SCpnt);
@ -1032,6 +1026,17 @@ int fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
else return FAILED; else return FAILED;
} }
int fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
{
int rc;
spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
rc = __fcp_scsi_host_reset(SCpnt);
spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
return rc;
}
static int fcp_els_queue_it(fc_channel *fc, fcp_cmnd *fcmd) static int fcp_els_queue_it(fc_channel *fc, fcp_cmnd *fcmd)
{ {
long i; long i;

1
drivers/fc4/fc_syms.c
View file

@ -27,7 +27,6 @@ EXPORT_SYMBOL(fc_do_prli);
EXPORT_SYMBOL(fcp_scsi_queuecommand); EXPORT_SYMBOL(fcp_scsi_queuecommand);
EXPORT_SYMBOL(fcp_scsi_abort); EXPORT_SYMBOL(fcp_scsi_abort);
EXPORT_SYMBOL(fcp_scsi_dev_reset); EXPORT_SYMBOL(fcp_scsi_dev_reset);
EXPORT_SYMBOL(fcp_scsi_bus_reset);
EXPORT_SYMBOL(fcp_scsi_host_reset); EXPORT_SYMBOL(fcp_scsi_host_reset);
#endif /* CONFIG_MODULES */ #endif /* CONFIG_MODULES */

1
drivers/fc4/fcp_impl.h
View file

@ -158,7 +158,6 @@ int fc_do_prli(fc_channel *, unsigned char);
int fcp_scsi_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *)); int fcp_scsi_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int fcp_scsi_abort(Scsi_Cmnd *); int fcp_scsi_abort(Scsi_Cmnd *);
int fcp_scsi_dev_reset(Scsi_Cmnd *); int fcp_scsi_dev_reset(Scsi_Cmnd *);
int fcp_scsi_bus_reset(Scsi_Cmnd *);
int fcp_scsi_host_reset(Scsi_Cmnd *); int fcp_scsi_host_reset(Scsi_Cmnd *);
#endif /* !(_FCP_SCSI_H) */ #endif /* !(_FCP_SCSI_H) */

4
drivers/message/fusion/mptscsih.c
View file

@ -1899,7 +1899,6 @@ mptscsih_host_reset(struct scsi_cmnd *SCpnt)
{ {
MPT_SCSI_HOST * hd; MPT_SCSI_HOST * hd;
int status = SUCCESS; int status = SUCCESS;
spinlock_t *host_lock = SCpnt->device->host->host_lock;
/* If we can't locate the host to reset, then we failed. */ /* If we can't locate the host to reset, then we failed. */
if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){ if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
@ -1915,7 +1914,6 @@ mptscsih_host_reset(struct scsi_cmnd *SCpnt)
/* If our attempts to reset the host failed, then return a failed /* If our attempts to reset the host failed, then return a failed
* status. The host will be taken off line by the SCSI mid-layer. * status. The host will be taken off line by the SCSI mid-layer.
*/ */
spin_unlock_irq(host_lock);
if (mpt_HardResetHandler(hd->ioc, CAN_SLEEP) < 0){ if (mpt_HardResetHandler(hd->ioc, CAN_SLEEP) < 0){
status = FAILED; status = FAILED;
} else { } else {
@ -1925,8 +1923,6 @@ mptscsih_host_reset(struct scsi_cmnd *SCpnt)
hd->tmPending = 0; hd->tmPending = 0;
hd->tmState = TM_STATE_NONE; hd->tmState = TM_STATE_NONE;
} }
spin_lock_irq(host_lock);
dtmprintk( ( KERN_WARNING MYNAM ": mptscsih_host_reset: " dtmprintk( ( KERN_WARNING MYNAM ": mptscsih_host_reset: "
"Status = %s\n", "Status = %s\n",

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

@ -755,8 +755,6 @@ zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
struct zfcp_unit *unit; struct zfcp_unit *unit;
struct Scsi_Host *scsi_host = scpnt->device->host; struct Scsi_Host *scsi_host = scpnt->device->host;
spin_unlock_irq(scsi_host->host_lock);
unit = (struct zfcp_unit *) scpnt->device->hostdata; unit = (struct zfcp_unit *) scpnt->device->hostdata;
ZFCP_LOG_NORMAL("host reset because of problems with " ZFCP_LOG_NORMAL("host reset because of problems with "
"unit 0x%016Lx\n", unit->fcp_lun); "unit 0x%016Lx\n", unit->fcp_lun);
@ -764,7 +762,6 @@ zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
zfcp_erp_wait(unit->port->adapter); zfcp_erp_wait(unit->port->adapter);
retval = SUCCESS; retval = SUCCESS;
spin_lock_irq(scsi_host->host_lock);
return retval; return retval;
} }

3
drivers/scsi/3w-9xxx.c
View file

@ -1695,8 +1695,6 @@ static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
spin_unlock_irq(tw_dev->host->host_lock);
tw_dev->num_resets++; tw_dev->num_resets++;
printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, TW_DRIVER, 0x2c, SCpnt->device->id, SCpnt->cmnd[0]); printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, TW_DRIVER, 0x2c, SCpnt->device->id, SCpnt->cmnd[0]);
@ -1709,7 +1707,6 @@ static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
retval = SUCCESS; retval = SUCCESS;
out: out:
spin_lock_irq(tw_dev->host->host_lock);
return retval; return retval;
} /* End twa_scsi_eh_reset() */ } /* End twa_scsi_eh_reset() */

3
drivers/scsi/3w-xxxx.c
View file

@ -1430,8 +1430,6 @@ static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt)
tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
spin_unlock_irq(tw_dev->host->host_lock);
tw_dev->num_resets++; tw_dev->num_resets++;
printk(KERN_WARNING "3w-xxxx: scsi%d: WARNING: Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, SCpnt->device->id, SCpnt->cmnd[0]); printk(KERN_WARNING "3w-xxxx: scsi%d: WARNING: Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, SCpnt->device->id, SCpnt->cmnd[0]);
@ -1444,7 +1442,6 @@ static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt)
retval = SUCCESS; retval = SUCCESS;
out: out:
spin_lock_irq(tw_dev->host->host_lock);
return retval; return retval;
} /* End tw_scsi_eh_reset() */ } /* End tw_scsi_eh_reset() */

5
drivers/scsi/53c700.c
View file

@ -1991,8 +1991,13 @@ NCR_700_host_reset(struct scsi_cmnd * SCp)
SCp->device->host->host_no, SCp->device->id, SCp->device->lun); SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
scsi_print_command(SCp); scsi_print_command(SCp);
spin_lock_irq(SCp->device->host->host_lock);
NCR_700_internal_bus_reset(SCp->device->host); NCR_700_internal_bus_reset(SCp->device->host);
NCR_700_chip_reset(SCp->device->host); NCR_700_chip_reset(SCp->device->host);
spin_unlock_irq(SCp->device->host->host_lock);
return SUCCESS; return SUCCESS;
} }

8
drivers/scsi/BusLogic.c
View file

@ -2746,9 +2746,15 @@ static int BusLogic_host_reset(struct scsi_cmnd * SCpnt)
unsigned int id = SCpnt->device->id; unsigned int id = SCpnt->device->id;
struct BusLogic_TargetStatistics *stats = &HostAdapter->TargetStatistics[id]; struct BusLogic_TargetStatistics *stats = &HostAdapter->TargetStatistics[id];
int rc;
spin_lock_irq(SCpnt->device->host->host_lock);
BusLogic_IncrementErrorCounter(&stats->HostAdapterResetsRequested); BusLogic_IncrementErrorCounter(&stats->HostAdapterResetsRequested);
return BusLogic_ResetHostAdapter(HostAdapter, false); rc = BusLogic_ResetHostAdapter(HostAdapter, false);
spin_unlock_irq(SCpnt->device->host->host_lock);
return rc;
} }
/* /*

6
drivers/scsi/NCR53c406a.c
View file

@ -725,6 +725,9 @@ static int NCR53c406a_queue(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
static int NCR53c406a_host_reset(Scsi_Cmnd * SCpnt) static int NCR53c406a_host_reset(Scsi_Cmnd * SCpnt)
{ {
DEB(printk("NCR53c406a_reset called\n")); DEB(printk("NCR53c406a_reset called\n"));
spin_lock_irq(SCpnt->device->host->host_lock);
outb(C4_IMG, CONFIG4); /* Select reg set 0 */ outb(C4_IMG, CONFIG4); /* Select reg set 0 */
outb(CHIP_RESET, CMD_REG); outb(CHIP_RESET, CMD_REG);
outb(SCSI_NOP, CMD_REG); /* required after reset */ outb(SCSI_NOP, CMD_REG); /* required after reset */
@ -732,6 +735,9 @@ static int NCR53c406a_host_reset(Scsi_Cmnd * SCpnt)
chip_init(); chip_init();
rtrc(2); rtrc(2);
spin_unlock_irq(SCpnt->device->host->host_lock);
return SUCCESS; return SUCCESS;
} }

3
drivers/scsi/a2091.c
View file

@ -222,6 +222,9 @@ static int a2091_bus_reset(Scsi_Cmnd *cmd)
{ {
/* FIXME perform bus-specific reset */ /* FIXME perform bus-specific reset */
/* FIXME 2: kill this function, and let midlayer fall back
to the same action, calling wd33c93_host_reset() */
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
wd33c93_host_reset(cmd); wd33c93_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);

3
drivers/scsi/a3000.c
View file

@ -209,6 +209,9 @@ static int a3000_bus_reset(Scsi_Cmnd *cmd)
{ {
/* FIXME perform bus-specific reset */ /* FIXME perform bus-specific reset */
/* FIXME 2: kill this entire function, which should
cause mid-layer to call wd33c93_host_reset anyway? */
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
wd33c93_host_reset(cmd); wd33c93_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);

4
drivers/scsi/aacraid/linit.c
View file

@ -384,10 +384,13 @@ static int aac_eh_reset(struct scsi_cmnd* cmd)
AAC_DRIVERNAME); AAC_DRIVERNAME);
spin_lock_irq(host->host_lock);
aac = (struct aac_dev *)host->hostdata; aac = (struct aac_dev *)host->hostdata;
if (aac_adapter_check_health(aac)) { if (aac_adapter_check_health(aac)) {
printk(KERN_ERR "%s: Host adapter appears dead\n", printk(KERN_ERR "%s: Host adapter appears dead\n",
AAC_DRIVERNAME); AAC_DRIVERNAME);
spin_unlock_irq(host->host_lock);
return -ENODEV; return -ENODEV;
} }
/* /*
@ -418,6 +421,7 @@ static int aac_eh_reset(struct scsi_cmnd* cmd)
ssleep(1); ssleep(1);
spin_lock_irq(host->host_lock); spin_lock_irq(host->host_lock);
} }
spin_unlock_irq(host->host_lock);
printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME); printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME);
return -ETIMEDOUT; return -ETIMEDOUT;
} }

3
drivers/scsi/aha1542.c
View file

@ -1530,7 +1530,6 @@ static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
* check for timeout, and if we are doing something like this * check for timeout, and if we are doing something like this
* we are pretty desperate anyways. * we are pretty desperate anyways.
*/ */
spin_unlock_irq(SCpnt->device->host->host_lock);
ssleep(4); ssleep(4);
spin_lock_irq(SCpnt->device->host->host_lock); spin_lock_irq(SCpnt->device->host->host_lock);
@ -1574,9 +1573,11 @@ static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
} }
} }
spin_unlock_irq(SCpnt->device->host->host_lock);
return SUCCESS; return SUCCESS;
fail: fail:
spin_unlock_irq(SCpnt->device->host->host_lock);
return FAILED; return FAILED;
} }

4
drivers/scsi/aic7xxx_old.c
View file

@ -10845,6 +10845,8 @@ aic7xxx_reset(Scsi_Cmnd *cmd)
struct aic_dev_data *aic_dev; struct aic_dev_data *aic_dev;
p = (struct aic7xxx_host *) cmd->device->host->hostdata; p = (struct aic7xxx_host *) cmd->device->host->hostdata;
spin_lock_irq(p->host->host_lock);
aic_dev = AIC_DEV(cmd); aic_dev = AIC_DEV(cmd);
if(aic7xxx_position(cmd) < p->scb_data->numscbs) if(aic7xxx_position(cmd) < p->scb_data->numscbs)
{ {
@ -10884,6 +10886,7 @@ aic7xxx_reset(Scsi_Cmnd *cmd)
* longer have it. * longer have it.
*/ */
unpause_sequencer(p, FALSE); unpause_sequencer(p, FALSE);
spin_unlock_irq(p->host->host_lock);
return SUCCESS; return SUCCESS;
} }
@ -10907,7 +10910,6 @@ aic7xxx_reset(Scsi_Cmnd *cmd)
unpause_sequencer(p, FALSE); unpause_sequencer(p, FALSE);
spin_unlock_irq(p->host->host_lock); spin_unlock_irq(p->host->host_lock);
ssleep(2); ssleep(2);
spin_lock_irq(p->host->host_lock);
return SUCCESS; return SUCCESS;
} }

3
drivers/scsi/arm/fas216.c
View file

@ -2659,6 +2659,8 @@ int fas216_eh_host_reset(Scsi_Cmnd *SCpnt)
{ {
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata; FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;
spin_lock_irq(info->host->host_lock);
fas216_checkmagic(info); fas216_checkmagic(info);
printk("scsi%d.%c: %s: resetting host\n", printk("scsi%d.%c: %s: resetting host\n",
@ -2686,6 +2688,7 @@ int fas216_eh_host_reset(Scsi_Cmnd *SCpnt)
fas216_init_chip(info); fas216_init_chip(info);
spin_unlock_irq(info->host->host_lock);
return SUCCESS; return SUCCESS;
} }

13
drivers/scsi/dpt_i2o.c
View file

@ -746,7 +746,7 @@ static int adpt_bus_reset(struct scsi_cmnd* cmd)
} }
// This version of reset is called by the eh_error_handler // This version of reset is called by the eh_error_handler
static int adpt_reset(struct scsi_cmnd* cmd) static int __adpt_reset(struct scsi_cmnd* cmd)
{ {
adpt_hba* pHba; adpt_hba* pHba;
int rcode; int rcode;
@ -762,6 +762,17 @@ static int adpt_reset(struct scsi_cmnd* cmd)
} }
} }
static int adpt_reset(struct scsi_cmnd* cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = __adpt_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
// This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset // This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset
static int adpt_hba_reset(adpt_hba* pHba) static int adpt_hba_reset(adpt_hba* pHba)
{ {

9
drivers/scsi/eata.c
View file

@ -1948,16 +1948,20 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
ha->board_name, SCarg->device->channel, SCarg->device->id, ha->board_name, SCarg->device->channel, SCarg->device->id,
SCarg->device->lun, SCarg->pid); SCarg->device->lun, SCarg->pid);
spin_lock_irq(shost->host_lock);
if (SCarg->host_scribble == NULL) if (SCarg->host_scribble == NULL)
printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid); printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);
if (ha->in_reset) { if (ha->in_reset) {
printk("%s: reset, exit, already in reset.\n", ha->board_name); printk("%s: reset, exit, already in reset.\n", ha->board_name);
spin_unlock_irq(shost->host_lock);
return FAILED; return FAILED;
} }
if (wait_on_busy(shost->io_port, MAXLOOP)) { if (wait_on_busy(shost->io_port, MAXLOOP)) {
printk("%s: reset, exit, timeout error.\n", ha->board_name); printk("%s: reset, exit, timeout error.\n", ha->board_name);
spin_unlock_irq(shost->host_lock);
return FAILED; return FAILED;
} }
@ -2012,6 +2016,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
if (do_dma(shost->io_port, 0, RESET_PIO)) { if (do_dma(shost->io_port, 0, RESET_PIO)) {
printk("%s: reset, cannot reset, timeout error.\n", ha->board_name); printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
spin_unlock_irq(shost->host_lock);
return FAILED; return FAILED;
} }
@ -2024,9 +2029,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
ha->in_reset = 1; ha->in_reset = 1;
spin_unlock_irq(shost->host_lock); spin_unlock_irq(shost->host_lock);
/* FIXME: use a sleep instead */
time = jiffies; time = jiffies;
while ((jiffies - time) < (10 * HZ) && limit++ < 200000) while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
udelay(100L); udelay(100L);
spin_lock_irq(shost->host_lock); spin_lock_irq(shost->host_lock);
printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit); printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
@ -2076,6 +2084,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
else else
printk("%s: reset, exit.\n", ha->board_name); printk("%s: reset, exit.\n", ha->board_name);
spin_unlock_irq(shost->host_lock);
return SUCCESS; return SUCCESS;
} }

5
drivers/scsi/eata_pio.c
View file

@ -486,8 +486,11 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
DBG(DBG_ABNORM, printk(KERN_WARNING "eata_pio_reset called pid:%ld target:" " %x lun: %x reason %x\n", cmd->pid, cmd->device->id, cmd->device->lun, cmd->abort_reason)); DBG(DBG_ABNORM, printk(KERN_WARNING "eata_pio_reset called pid:%ld target:" " %x lun: %x reason %x\n", cmd->pid, cmd->device->id, cmd->device->lun, cmd->abort_reason));
spin_lock_irq(host->host_lock);
if (HD(cmd)->state == RESET) { if (HD(cmd)->state == RESET) {
printk(KERN_WARNING "eata_pio_reset: exit, already in reset.\n"); printk(KERN_WARNING "eata_pio_reset: exit, already in reset.\n");
spin_unlock_irq(host->host_lock);
return FAILED; return FAILED;
} }
@ -536,6 +539,8 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
HD(cmd)->state = 0; HD(cmd)->state = 0;
spin_unlock_irq(host->host_lock);
if (success) { /* hmmm... */ if (success) { /* hmmm... */
DBG(DBG_ABNORM, printk(KERN_WARNING "eata_pio_reset: exit, success.\n")); DBG(DBG_ABNORM, printk(KERN_WARNING "eata_pio_reset: exit, success.\n"));
return SUCCESS; return SUCCESS;

4
drivers/scsi/gvp11.c
View file

@ -346,6 +346,10 @@ static int gvp11_bus_reset(Scsi_Cmnd *cmd)
{ {
/* FIXME perform bus-specific reset */ /* FIXME perform bus-specific reset */
/* FIXME 2: shouldn't we no-op this function (return
FAILED), and fall back to host reset function,
wd33c93_host_reset ? */
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
wd33c93_host_reset(cmd); wd33c93_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);

14
drivers/scsi/ibmmca.c
View file

@ -2237,7 +2237,7 @@ static int ibmmca_abort(Scsi_Cmnd * cmd)
return rc; return rc;
} }
static int ibmmca_host_reset(Scsi_Cmnd * cmd) static int __ibmmca_host_reset(Scsi_Cmnd * cmd)
{ {
struct Scsi_Host *shpnt; struct Scsi_Host *shpnt;
Scsi_Cmnd *cmd_aid; Scsi_Cmnd *cmd_aid;
@ -2324,6 +2324,18 @@ static int ibmmca_host_reset(Scsi_Cmnd * cmd)
return SUCCESS; return SUCCESS;
} }
static int ibmmca_host_reset(Scsi_Cmnd * cmd)
{
struct Scsi_Host *shpnt = cmd->device->host;
int rc;
spin_lock_irq(shpnt->host_lock);
rc = __ibmmca_host_reset(cmd);
spin_unlock_irq(shpnt->host_lock);
return rc;
}
static int ibmmca_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *info) static int ibmmca_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *info)
{ {
int size = capacity; int size = capacity;

11
drivers/scsi/ide-scsi.c
View file

@ -46,6 +46,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/ide.h> #include <linux/ide.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/delay.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/bitops.h> #include <asm/bitops.h>
@ -1026,11 +1027,13 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
return FAILED; return FAILED;
} }
spin_lock_irq(&ide_lock); spin_lock_irq(cmd->device->host->host_lock);
spin_lock(&ide_lock);
if (!scsi->pc || (req = scsi->pc->rq) != HWGROUP(drive)->rq || !HWGROUP(drive)->handler) { if (!scsi->pc || (req = scsi->pc->rq) != HWGROUP(drive)->rq || !HWGROUP(drive)->handler) {
printk (KERN_WARNING "ide-scsi: No active request in idescsi_eh_reset\n"); printk (KERN_WARNING "ide-scsi: No active request in idescsi_eh_reset\n");
spin_unlock(&ide_lock); spin_unlock(&ide_lock);
spin_unlock_irq(cmd->device->host->host_lock);
return FAILED; return FAILED;
} }
@ -1052,16 +1055,15 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
HWGROUP(drive)->rq = NULL; HWGROUP(drive)->rq = NULL;
HWGROUP(drive)->handler = NULL; HWGROUP(drive)->handler = NULL;
HWGROUP(drive)->busy = 1; /* will set this to zero when ide reset finished */ HWGROUP(drive)->busy = 1; /* will set this to zero when ide reset finished */
spin_unlock_irq(&ide_lock); spin_unlock(&ide_lock);
ide_do_reset(drive); ide_do_reset(drive);
/* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */ /* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */
do { do {
set_current_state(TASK_UNINTERRUPTIBLE);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);
schedule_timeout(HZ/20); msleep(50);
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
} while ( HWGROUP(drive)->handler ); } while ( HWGROUP(drive)->handler );
@ -1072,6 +1074,7 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
ret = FAILED; ret = FAILED;
} }
spin_unlock_irq(cmd->device->host->host_lock);
return ret; return ret;
} }

13
drivers/scsi/ipr.c
View file

@ -2885,7 +2885,7 @@ static int ipr_slave_alloc(struct scsi_device *sdev)
* Return value: * Return value:
* SUCCESS / FAILED * SUCCESS / FAILED
**/ **/
static int ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd) static int __ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
{ {
struct ipr_ioa_cfg *ioa_cfg; struct ipr_ioa_cfg *ioa_cfg;
int rc; int rc;
@ -2905,6 +2905,17 @@ static int ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
return rc; return rc;
} }
static int ipr_eh_host_reset(struct scsi_cmnd * cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = __ipr_eh_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/** /**
* ipr_eh_dev_reset - Reset the device * ipr_eh_dev_reset - Reset the device
* @scsi_cmd: scsi command struct * @scsi_cmd: scsi command struct

14
drivers/scsi/ips.c
View file

@ -873,7 +873,7 @@ ips_eh_abort(Scsi_Cmnd * SC)
/* */ /* */
/****************************************************************************/ /****************************************************************************/
static int static int
ips_eh_reset(Scsi_Cmnd * SC) __ips_eh_reset(Scsi_Cmnd * SC)
{ {
int ret; int ret;
int i; int i;
@ -1060,6 +1060,18 @@ ips_eh_reset(Scsi_Cmnd * SC)
} }
static int
ips_eh_reset(Scsi_Cmnd * SC)
{
int rc;
spin_lock_irq(SC->device->host->host_lock);
rc = __ips_eh_reset(SC);
spin_unlock_irq(SC->device->host->host_lock);
return rc;
}
/****************************************************************************/ /****************************************************************************/
/* */ /* */
/* Routine Name: ips_queue */ /* Routine Name: ips_queue */

5
drivers/scsi/mac53c94.c
View file

@ -103,6 +103,9 @@ static int mac53c94_host_reset(struct scsi_cmnd *cmd)
struct fsc_state *state = (struct fsc_state *) cmd->device->host->hostdata; struct fsc_state *state = (struct fsc_state *) cmd->device->host->hostdata;
struct mac53c94_regs __iomem *regs = state->regs; struct mac53c94_regs __iomem *regs = state->regs;
struct dbdma_regs __iomem *dma = state->dma; struct dbdma_regs __iomem *dma = state->dma;
unsigned long flags;
spin_lock_irqsave(cmd->device->host->host_lock, flags);
writel((RUN|PAUSE|FLUSH|WAKE) << 16, &dma->control); writel((RUN|PAUSE|FLUSH|WAKE) << 16, &dma->control);
writeb(CMD_SCSI_RESET, &regs->command); /* assert RST */ writeb(CMD_SCSI_RESET, &regs->command); /* assert RST */
@ -111,6 +114,8 @@ static int mac53c94_host_reset(struct scsi_cmnd *cmd)
udelay(20); udelay(20);
mac53c94_init(state); mac53c94_init(state);
writeb(CMD_NOP, &regs->command); writeb(CMD_NOP, &regs->command);
spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
return SUCCESS; return SUCCESS;
} }

4
drivers/scsi/mesh.c
View file

@ -1715,9 +1715,12 @@ static int mesh_host_reset(struct scsi_cmnd *cmd)
struct mesh_state *ms = (struct mesh_state *) cmd->device->host->hostdata; struct mesh_state *ms = (struct mesh_state *) cmd->device->host->hostdata;
volatile struct mesh_regs __iomem *mr = ms->mesh; volatile struct mesh_regs __iomem *mr = ms->mesh;
volatile struct dbdma_regs __iomem *md = ms->dma; volatile struct dbdma_regs __iomem *md = ms->dma;
unsigned long flags;
printk(KERN_DEBUG "mesh_host_reset\n"); printk(KERN_DEBUG "mesh_host_reset\n");
spin_lock_irqsave(ms->host->host_lock, flags);
/* Reset the controller & dbdma channel */ /* Reset the controller & dbdma channel */
out_le32(&md->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* stop dma */ out_le32(&md->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* stop dma */
out_8(&mr->exception, 0xff); /* clear all exception bits */ out_8(&mr->exception, 0xff); /* clear all exception bits */
@ -1739,6 +1742,7 @@ static int mesh_host_reset(struct scsi_cmnd *cmd)
/* Complete pending commands */ /* Complete pending commands */
handle_reset(ms); handle_reset(ms);
spin_unlock_irqrestore(ms->host->host_lock, flags);
return SUCCESS; return SUCCESS;
} }

3
drivers/scsi/mvme147.c
View file

@ -117,6 +117,9 @@ static int mvme147_bus_reset(Scsi_Cmnd *cmd)
{ {
/* FIXME perform bus-specific reset */ /* FIXME perform bus-specific reset */
/* FIXME 2: kill this function, and let midlayer fallback to
the same result, calling wd33c93_host_reset() */
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
wd33c93_host_reset(cmd); wd33c93_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);

3
drivers/scsi/nsp32.c
View file

@ -3051,11 +3051,14 @@ static int nsp32_eh_host_reset(struct scsi_cmnd *SCpnt)
nsp32_msg(KERN_INFO, "Host Reset"); nsp32_msg(KERN_INFO, "Host Reset");
nsp32_dbg(NSP32_DEBUG_BUSRESET, "SCpnt=0x%x", SCpnt); nsp32_dbg(NSP32_DEBUG_BUSRESET, "SCpnt=0x%x", SCpnt);
spin_lock_irq(SCpnt->device->host->host_lock);
nsp32hw_init(data); nsp32hw_init(data);
nsp32_write2(base, IRQ_CONTROL, IRQ_CONTROL_ALL_IRQ_MASK); nsp32_write2(base, IRQ_CONTROL, IRQ_CONTROL_ALL_IRQ_MASK);
nsp32_do_bus_reset(data); nsp32_do_bus_reset(data);
nsp32_write2(base, IRQ_CONTROL, 0); nsp32_write2(base, IRQ_CONTROL, 0);
spin_unlock_irq(SCpnt->device->host->host_lock);
return SUCCESS; /* Host reset is succeeded at any time. */ return SUCCESS; /* Host reset is succeeded at any time. */
} }

2
drivers/scsi/pcmcia/sym53c500_cs.c
View file

@ -627,7 +627,9 @@ SYM53C500_host_reset(struct scsi_cmnd *SCpnt)
int port_base = SCpnt->device->host->io_port; int port_base = SCpnt->device->host->io_port;
DEB(printk("SYM53C500_host_reset called\n")); DEB(printk("SYM53C500_host_reset called\n"));
spin_lock_irq(SCpnt->device->host->host_lock);
SYM53C500_int_host_reset(port_base); SYM53C500_int_host_reset(port_base);
spin_unlock_irq(SCpnt->device->host->host_lock);
return SUCCESS; return SUCCESS;
} }

8
drivers/scsi/qla1280.c
View file

@ -1146,7 +1146,13 @@ qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
static int static int
qla1280_eh_adapter_reset(struct scsi_cmnd *cmd) qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
{ {
return qla1280_error_action(cmd, ADAPTER_RESET); int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, ADAPTER_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
} }
static int static int

4
drivers/scsi/qla2xxx/qla_os.c
View file

@ -815,8 +815,6 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
qla_printk(KERN_INFO, ha, qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun); "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun);
spin_unlock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
goto eh_host_reset_lock; goto eh_host_reset_lock;
@ -845,8 +843,6 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
ret = SUCCESS; ret = SUCCESS;
eh_host_reset_lock: eh_host_reset_lock:
spin_lock_irq(ha->host->host_lock);
qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__, qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
(ret == FAILED) ? "failed" : "succeded"); (ret == FAILED) ? "failed" : "succeded");

2
drivers/scsi/scsi_error.c
View file

@ -1082,9 +1082,7 @@ static int scsi_try_host_reset(struct scsi_cmnd *scmd)
if (!scmd->device->host->hostt->eh_host_reset_handler) if (!scmd->device->host->hostt->eh_host_reset_handler)
return FAILED; return FAILED;
spin_lock_irqsave(scmd->device->host->host_lock, flags);
rtn = scmd->device->host->hostt->eh_host_reset_handler(scmd); rtn = scmd->device->host->hostt->eh_host_reset_handler(scmd);
spin_unlock_irqrestore(scmd->device->host->host_lock, flags);
if (rtn == SUCCESS) { if (rtn == SUCCESS) {
if (!scmd->device->host->hostt->skip_settle_delay) if (!scmd->device->host->hostt->skip_settle_delay)

3
drivers/scsi/sgiwd93.c
View file

@ -311,6 +311,9 @@ static int sgiwd93_bus_reset(Scsi_Cmnd *cmd)
{ {
/* FIXME perform bus-specific reset */ /* FIXME perform bus-specific reset */
/* FIXME 2: kill this function, and let midlayer fallback
to the same result, calling wd33c93_host_reset() */
spin_lock_irq(cmd->device->host->host_lock); spin_lock_irq(cmd->device->host->host_lock);
wd33c93_host_reset(cmd); wd33c93_host_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock); spin_unlock_irq(cmd->device->host->host_lock);

5
drivers/scsi/sym53c416.c
View file

@ -790,6 +790,9 @@ static int sym53c416_host_reset(Scsi_Cmnd *SCpnt)
int base; int base;
int scsi_id = -1; int scsi_id = -1;
int i; int i;
unsigned long flags;
spin_lock_irqsave(&sym53c416_lock, flags);
/* printk("sym53c416_reset\n"); */ /* printk("sym53c416_reset\n"); */
base = SCpnt->device->host->io_port; base = SCpnt->device->host->io_port;
@ -801,6 +804,8 @@ static int sym53c416_host_reset(Scsi_Cmnd *SCpnt)
outb(NOOP | PIO_MODE, base + COMMAND_REG); outb(NOOP | PIO_MODE, base + COMMAND_REG);
outb(RESET_SCSI_BUS, base + COMMAND_REG); outb(RESET_SCSI_BUS, base + COMMAND_REG);
sym53c416_init(base, scsi_id); sym53c416_init(base, scsi_id);
spin_unlock_irqrestore(&sym53c416_lock, flags);
return SUCCESS; return SUCCESS;
} }

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

@ -889,7 +889,13 @@ static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd *cmd)
static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd *cmd) static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd *cmd)
{ {
return sym_eh_handler(SYM_EH_HOST_RESET, "HOST RESET", cmd); int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = sym_eh_handler(SYM_EH_HOST_RESET, "HOST RESET", cmd);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
} }
/* /*

6
drivers/scsi/u14-34f.c
View file

@ -1417,16 +1417,20 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n", printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid); BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid);
spin_lock_irq(sh[j]->host_lock);
if (SCarg->host_scribble == NULL) if (SCarg->host_scribble == NULL)
printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid); printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid);
if (HD(j)->in_reset) { if (HD(j)->in_reset) {
printk("%s: reset, exit, already in reset.\n", BN(j)); printk("%s: reset, exit, already in reset.\n", BN(j));
spin_unlock_irq(sh[j]->host_lock);
return FAILED; return FAILED;
} }
if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
printk("%s: reset, exit, timeout error.\n", BN(j)); printk("%s: reset, exit, timeout error.\n", BN(j));
spin_unlock_irq(sh[j]->host_lock);
return FAILED; return FAILED;
} }
@ -1477,6 +1481,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
printk("%s: reset, cannot reset, timeout error.\n", BN(j)); printk("%s: reset, cannot reset, timeout error.\n", BN(j));
spin_unlock_irq(sh[j]->host_lock);
return FAILED; return FAILED;
} }
@ -1538,6 +1543,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid); if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid);
else printk("%s: reset, exit.\n", BN(j)); else printk("%s: reset, exit.\n", BN(j));
spin_unlock_irq(sh[j]->host_lock);
return SUCCESS; return SUCCESS;
} }

9
drivers/scsi/wd7000.c
View file

@ -1586,9 +1586,16 @@ static int wd7000_host_reset(struct scsi_cmnd *SCpnt)
{ {
Adapter *host = (Adapter *) SCpnt->device->host->hostdata; Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
if (wd7000_adapter_reset(host) < 0) spin_unlock_irq(SCpnt->device->host->host_lock);
if (wd7000_adapter_reset(host) < 0) {
spin_unlock_irq(SCpnt->device->host->host_lock);
return FAILED; return FAILED;
}
wd7000_enable_intr(host); wd7000_enable_intr(host);
spin_unlock_irq(SCpnt->device->host->host_lock);
return SUCCESS; return SUCCESS;
} }