Commit 16b29e75 authored by Finn Thain's avatar Finn Thain Committed by Christoph Hellwig

atari_scsi: Fix atari_scsi deadlocks on Falcon

Don't disable irqs when waiting for the ST DMA "lock"; its release may
require an interrupt.

Introduce stdma_try_lock() for use in soft irq context. atari_scsi now tells
the SCSI mid-layer to defer queueing a command if the ST DMA lock is not
available, as per Michael's patch:
http://marc.info/?l=linux-m68k&m=139095335824863&w=2

The falcon_got_lock variable is race prone: we can't disable IRQs while
waiting to acquire the lock, so after acquiring it there must be some
interval during which falcon_got_lock remains false. Introduce
stdma_is_locked_by() to replace falcon_got_lock.

The falcon_got_lock tests in the EH handlers are incorrect these days. It
can happen that an EH handler is called after a command completes normally.
Remove these checks along with falcon_got_lock.

Also remove the complicated and racy fairness wait queues. If fairness is an
issue (when SCSI competes with IDE for the ST DMA interrupt), the solution
is likely to be a lower value for host->can_queue.
Signed-off-by: default avatarFinn Thain <fthain@telegraphics.com.au>
Reviewed-by: default avatarHannes Reinecke <hare@suse.de>
Tested-by: default avatarMichael Schmitz <schmitzmic@gmail.com>
Acked-by: default avatarGeert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
parent cbad48de
...@@ -59,6 +59,31 @@ static irqreturn_t stdma_int (int irq, void *dummy); ...@@ -59,6 +59,31 @@ static irqreturn_t stdma_int (int irq, void *dummy);
/************************* End of Prototypes **************************/ /************************* End of Prototypes **************************/
/**
* stdma_try_lock - attempt to acquire ST DMA interrupt "lock"
* @handler: interrupt handler to use after acquisition
*
* Returns !0 if lock was acquired; otherwise 0.
*/
int stdma_try_lock(irq_handler_t handler, void *data)
{
unsigned long flags;
local_irq_save(flags);
if (stdma_locked) {
local_irq_restore(flags);
return 0;
}
stdma_locked = 1;
stdma_isr = handler;
stdma_isr_data = data;
local_irq_restore(flags);
return 1;
}
EXPORT_SYMBOL(stdma_try_lock);
/* /*
* Function: void stdma_lock( isrfunc isr, void *data ) * Function: void stdma_lock( isrfunc isr, void *data )
...@@ -78,19 +103,10 @@ static irqreturn_t stdma_int (int irq, void *dummy); ...@@ -78,19 +103,10 @@ static irqreturn_t stdma_int (int irq, void *dummy);
void stdma_lock(irq_handler_t handler, void *data) void stdma_lock(irq_handler_t handler, void *data)
{ {
unsigned long flags;
local_irq_save(flags); /* protect lock */
/* Since the DMA is used for file system purposes, we /* Since the DMA is used for file system purposes, we
have to sleep uninterruptible (there may be locked have to sleep uninterruptible (there may be locked
buffers) */ buffers) */
wait_event(stdma_wait, !stdma_locked); wait_event(stdma_wait, stdma_try_lock(handler, data));
stdma_locked = 1;
stdma_isr = handler;
stdma_isr_data = data;
local_irq_restore(flags);
} }
EXPORT_SYMBOL(stdma_lock); EXPORT_SYMBOL(stdma_lock);
...@@ -122,22 +138,25 @@ void stdma_release(void) ...@@ -122,22 +138,25 @@ void stdma_release(void)
EXPORT_SYMBOL(stdma_release); EXPORT_SYMBOL(stdma_release);
/* /**
* Function: int stdma_others_waiting( void ) * stdma_is_locked_by - allow lock holder to check whether it needs to release.
* * @handler: interrupt handler previously used to acquire lock.
* Purpose: Check if someone waits for the ST-DMA lock.
*
* Inputs: none
*
* Returns: 0 if no one is waiting, != 0 otherwise
* *
* Returns !0 if locked for the given handler; 0 otherwise.
*/ */
int stdma_others_waiting(void) int stdma_is_locked_by(irq_handler_t handler)
{ {
return waitqueue_active(&stdma_wait); unsigned long flags;
int result;
local_irq_save(flags);
result = stdma_locked && (stdma_isr == handler);
local_irq_restore(flags);
return result;
} }
EXPORT_SYMBOL(stdma_others_waiting); EXPORT_SYMBOL(stdma_is_locked_by);
/* /*
......
...@@ -8,11 +8,11 @@ ...@@ -8,11 +8,11 @@
/***************************** Prototypes *****************************/ /***************************** Prototypes *****************************/
int stdma_try_lock(irq_handler_t, void *);
void stdma_lock(irq_handler_t handler, void *data); void stdma_lock(irq_handler_t handler, void *data);
void stdma_release( void ); void stdma_release( void );
int stdma_others_waiting( void );
int stdma_islocked( void ); int stdma_islocked( void );
void *stdma_locked_by( void ); int stdma_is_locked_by(irq_handler_t);
void stdma_init( void ); void stdma_init( void );
/************************* End of Prototypes **************************/ /************************* End of Prototypes **************************/
......
...@@ -879,10 +879,10 @@ static void NCR5380_exit(struct Scsi_Host *instance) ...@@ -879,10 +879,10 @@ static void NCR5380_exit(struct Scsi_Host *instance)
* *
*/ */
static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, static int NCR5380_queue_command(struct Scsi_Host *instance,
void (*done)(struct scsi_cmnd *)) struct scsi_cmnd *cmd)
{ {
SETUP_HOSTDATA(cmd->device->host); struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct scsi_cmnd *tmp; struct scsi_cmnd *tmp;
unsigned long flags; unsigned long flags;
...@@ -893,7 +893,7 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, ...@@ -893,7 +893,7 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n", printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
H_NO(cmd)); H_NO(cmd));
cmd->result = (DID_ERROR << 16); cmd->result = (DID_ERROR << 16);
done(cmd); cmd->scsi_done(cmd);
return 0; return 0;
} }
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */ #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
...@@ -904,8 +904,6 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, ...@@ -904,8 +904,6 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
*/ */
SET_NEXT(cmd, NULL); SET_NEXT(cmd, NULL);
cmd->scsi_done = done;
cmd->result = 0; cmd->result = 0;
/* /*
...@@ -915,7 +913,6 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, ...@@ -915,7 +913,6 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
* sense data is only guaranteed to be valid while the condition exists. * sense data is only guaranteed to be valid while the condition exists.
*/ */
local_irq_save(flags);
/* ++guenther: now that the issue queue is being set up, we can lock ST-DMA. /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
* Otherwise a running NCR5380_main may steal the lock. * Otherwise a running NCR5380_main may steal the lock.
* Lock before actually inserting due to fairness reasons explained in * Lock before actually inserting due to fairness reasons explained in
...@@ -928,11 +925,11 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, ...@@ -928,11 +925,11 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
* because also a timer int can trigger an abort or reset, which would * because also a timer int can trigger an abort or reset, which would
* alter queues and touch the lock. * alter queues and touch the lock.
*/ */
if (!IS_A_TT()) { if (!falcon_get_lock())
/* perhaps stop command timer here */ return SCSI_MLQUEUE_HOST_BUSY;
falcon_get_lock();
/* perhaps restart command timer here */ local_irq_save(flags);
}
if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
LIST(cmd, hostdata->issue_queue); LIST(cmd, hostdata->issue_queue);
SET_NEXT(cmd, hostdata->issue_queue); SET_NEXT(cmd, hostdata->issue_queue);
...@@ -956,15 +953,13 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, ...@@ -956,15 +953,13 @@ static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
* If we're not in an interrupt, we can call NCR5380_main() * If we're not in an interrupt, we can call NCR5380_main()
* unconditionally, because it cannot be already running. * unconditionally, because it cannot be already running.
*/ */
if (in_interrupt() || ((flags >> 8) & 7) >= 6) if (in_interrupt() || irqs_disabled())
queue_main(); queue_main();
else else
NCR5380_main(NULL); NCR5380_main(NULL);
return 0; return 0;
} }
static DEF_SCSI_QCMD(NCR5380_queue_command)
/* /*
* Function : NCR5380_main (void) * Function : NCR5380_main (void)
* *
...@@ -2554,10 +2549,6 @@ int NCR5380_abort(struct scsi_cmnd *cmd) ...@@ -2554,10 +2549,6 @@ int NCR5380_abort(struct scsi_cmnd *cmd)
local_irq_save(flags); local_irq_save(flags);
if (!IS_A_TT() && !falcon_got_lock)
printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_abort\n",
HOSTNO);
dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO, dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(BUS_AND_STATUS_REG),
NCR5380_read(STATUS_REG)); NCR5380_read(STATUS_REG));
...@@ -2756,10 +2747,6 @@ static int NCR5380_bus_reset(struct scsi_cmnd *cmd) ...@@ -2756,10 +2747,6 @@ static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
struct scsi_cmnd *connected, *disconnected_queue; struct scsi_cmnd *connected, *disconnected_queue;
#endif #endif
if (!IS_A_TT() && !falcon_got_lock)
printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_reset\n",
H_NO(cmd));
NCR5380_print_status(cmd->device->host); NCR5380_print_status(cmd->device->host);
/* get in phase */ /* get in phase */
......
...@@ -184,7 +184,7 @@ static void atari_scsi_fetch_restbytes(void); ...@@ -184,7 +184,7 @@ static void atari_scsi_fetch_restbytes(void);
static irqreturn_t scsi_tt_intr(int irq, void *dummy); static irqreturn_t scsi_tt_intr(int irq, void *dummy);
static irqreturn_t scsi_falcon_intr(int irq, void *dummy); static irqreturn_t scsi_falcon_intr(int irq, void *dummy);
static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata); static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata);
static void falcon_get_lock(void); static int falcon_get_lock(void);
#ifdef CONFIG_ATARI_SCSI_RESET_BOOT #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
static void atari_scsi_reset_boot(void); static void atari_scsi_reset_boot(void);
#endif #endif
...@@ -473,17 +473,10 @@ static void atari_scsi_fetch_restbytes(void) ...@@ -473,17 +473,10 @@ static void atari_scsi_fetch_restbytes(void)
#endif /* REAL_DMA */ #endif /* REAL_DMA */
static int falcon_got_lock = 0;
static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait);
static int falcon_trying_lock = 0;
static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait);
static int falcon_dont_release = 0; static int falcon_dont_release = 0;
/* This function releases the lock on the DMA chip if there is no /* This function releases the lock on the DMA chip if there is no
* connected command and the disconnected queue is empty. On * connected command and the disconnected queue is empty.
* releasing, instances of falcon_get_lock are awoken, that put
* themselves to sleep for fairness. They can now try to get the lock
* again (but others waiting longer more probably will win).
*/ */
static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata) static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
...@@ -495,20 +488,12 @@ static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata) ...@@ -495,20 +488,12 @@ static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
local_irq_save(flags); local_irq_save(flags);
if (falcon_got_lock && !hostdata->disconnected_queue && if (!hostdata->disconnected_queue &&
!hostdata->issue_queue && !hostdata->connected) { !hostdata->issue_queue &&
!hostdata->connected &&
if (falcon_dont_release) { !falcon_dont_release &&
#if 0 stdma_is_locked_by(scsi_falcon_intr))
printk("WARNING: Lock release not allowed. Ignored\n");
#endif
local_irq_restore(flags);
return;
}
falcon_got_lock = 0;
stdma_release(); stdma_release();
wake_up(&falcon_fairness_wait);
}
local_irq_restore(flags); local_irq_restore(flags);
} }
...@@ -517,51 +502,19 @@ static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata) ...@@ -517,51 +502,19 @@ static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
* If the DMA isn't locked already for SCSI, it tries to lock it by * If the DMA isn't locked already for SCSI, it tries to lock it by
* calling stdma_lock(). But if the DMA is locked by the SCSI code and * calling stdma_lock(). But if the DMA is locked by the SCSI code and
* there are other drivers waiting for the chip, we do not issue the * there are other drivers waiting for the chip, we do not issue the
* command immediately but wait on 'falcon_fairness_queue'. We will be * command immediately but tell the SCSI mid-layer to defer.
* waked up when the DMA is unlocked by some SCSI interrupt. After that
* we try to get the lock again.
* But we must be prepared that more than one instance of
* falcon_get_lock() is waiting on the fairness queue. They should not
* try all at once to call stdma_lock(), one is enough! For that, the
* first one sets 'falcon_trying_lock', others that see that variable
* set wait on the queue 'falcon_try_wait'.
* Complicated, complicated.... Sigh...
*/ */
static void falcon_get_lock(void) static int falcon_get_lock(void)
{ {
unsigned long flags;
if (IS_A_TT()) if (IS_A_TT())
return; return 1;
local_irq_save(flags);
wait_event_cmd(falcon_fairness_wait, if (in_interrupt())
in_interrupt() || !falcon_got_lock || !stdma_others_waiting(), return stdma_try_lock(scsi_falcon_intr, NULL);
local_irq_restore(flags),
local_irq_save(flags));
while (!falcon_got_lock) {
if (in_irq())
panic("Falcon SCSI hasn't ST-DMA lock in interrupt");
if (!falcon_trying_lock) {
falcon_trying_lock = 1;
stdma_lock(scsi_falcon_intr, NULL); stdma_lock(scsi_falcon_intr, NULL);
falcon_got_lock = 1; return 1;
falcon_trying_lock = 0;
wake_up(&falcon_try_wait);
} else {
wait_event_cmd(falcon_try_wait,
falcon_got_lock && !falcon_trying_lock,
local_irq_restore(flags),
local_irq_save(flags));
}
}
local_irq_restore(flags);
if (!falcon_got_lock)
panic("Falcon SCSI: someone stole the lock :-(\n");
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment