Import 2.3.18pre1

[davej-history.git] / drivers / scsi / scsi_queue.c

/*
 * scsi_queue.c Copyright (C) 1997 Eric Youngdale
 *
 * generic mid-level SCSI queueing.
 *
 * The point of this is that we need to track when hosts are unable to
 * accept a command because they are busy. In addition, we track devices
 * that cannot accept a command because of a QUEUE_FULL condition. In both
 * of these cases, we enter the command in the queue. At some later point,
 * we attempt to remove commands from the queue and retry them.
 */

#define __NO_VERSION__
#include <linux/module.h>

#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/malloc.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/stat.h>
#include <linux/blk.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/smp_lock.h>

#define __KERNEL_SYSCALLS__

#include <linux/unistd.h>

#include <asm/system.h>
#include <asm/irq.h>
#include <asm/dma.h>

#include"scsi.h"
#include"hosts.h"
#include"constants.h"

/*
 * TODO:
 * 1) Prevent multiple traversals of list to look for commands to
 * queue.
 * 2) Protect against multiple insertions of list at the same time.
 * DONE:
 * 1) Set state of scsi command to a new state value for ml queue.
 * 2) Insert into queue when host rejects command.
 * 3) Make sure status code is properly passed from low-level queue func
 * so that internal_cmnd properly returns the right value.
 * 4) Insert into queue when QUEUE_FULL.
 * 5) Cull queue in bottom half handler.
 * 6) Check usage count prior to queue insertion. Requeue if usage
 * count is 0.
 * 7) Don't send down any more commands if the host/device is busy.
 */

static const char RCSid[] ="$Header: /mnt/ide/home/eric/CVSROOT/linux/drivers/scsi/scsi_queue.c,v 1.1 1997/10/21 11:16:38 eric Exp $";

/*
 * Lock used to prevent more than one process from frobbing the list at the
 * same time. FIXME(eric) - there should be separate spinlocks for each host.
 * This will reduce contention.
 */

spinlock_t scsi_mlqueue_lock = SPIN_LOCK_UNLOCKED;
spinlock_t scsi_mlqueue_remove_lock = SPIN_LOCK_UNLOCKED;

/*
 * Function: scsi_mlqueue_insert()
 *
 * Purpose: Insert a command in the midlevel queue.
 *
 * Arguments: cmd - command that we are adding to queue.
 * reason - why we are inserting command to queue.
 *
 * Returns: Nothing.
 *
 * Notes: We do this for one of two cases. Either the host is busy
 * and it cannot accept any more commands for the time being,
 * or the device returned QUEUE_FULL and can accept no more
 * commands.
 * Notes: This could be called either from an interrupt context or a
 * normal process context.
 */
intscsi_mlqueue_insert(Scsi_Cmnd * cmd,int reason)
{
 Scsi_Cmnd *cpnt;
unsigned long flags;
struct Scsi_Host *host;

SCSI_LOG_MLQUEUE(1,printk("Inserting command %p into mlqueue\n", cmd));

/*
 * We are inserting the command into the ml queue. First, we
 * cancel the timer, so it doesn't time out.
 */
scsi_delete_timer(cmd);

 host = cmd->host;

/*
 * Next, set the appropriate busy bit for the device/host.
 */
if(reason == SCSI_MLQUEUE_HOST_BUSY) {
/*
 * Protect against race conditions. If the host isn't busy,
 * assume that something actually completed, and that we should
 * be able to queue a command now. Note that there is an implicit
 * assumption that every host can always queue at least one command.
 * If a host is inactive and cannot queue any commands, I don't see
 * how things could possibly work anyways.
 */
if(host->host_busy ==0) {
if(scsi_retry_command(cmd) ==0) {
return0;
}
}
 host->host_blocked = TRUE;
 cmd->host_wait = TRUE;
}else{
/*
 * Protect against race conditions. If the device isn't busy,
 * assume that something actually completed, and that we should
 * be able to queue a command now. Note that there is an implicit
 * assumption that every host can always queue at least one command.
 * If a host is inactive and cannot queue any commands, I don't see
 * how things could possibly work anyways.
 */
if(cmd->device->device_busy ==0) {
if(scsi_retry_command(cmd) ==0) {
return0;
}
}
 cmd->device->device_busy = TRUE;
 cmd->device_wait = TRUE;
}

/*
 * Register the fact that we own the thing for now.
 */
 cmd->state = SCSI_STATE_MLQUEUE;
 cmd->owner = SCSI_OWNER_MIDLEVEL;
 cmd->bh_next = NULL;

/*
 * As a performance enhancement, look to see whether the list is
 * empty. If it is, then we can just atomicly insert the command
 * in the list and return without locking.
 */
if(host->pending_commands == NULL) {
 cpnt =xchg(&host->pending_commands, cmd);
if(cpnt == NULL) {
return0;
}
/*
 * Rats. Something slipped in while we were exchanging.
 * Swap it back and fall through to do it the hard way.
 */
 cmd =xchg(&host->pending_commands, cpnt);

}
/*
 * Next append the command to the list of pending commands.
 */
spin_lock_irqsave(&scsi_mlqueue_lock, flags);
for(cpnt = host->pending_commands; cpnt && cpnt->bh_next;
 cpnt = cpnt->bh_next) {
continue;
}
if(cpnt != NULL) {
 cpnt->bh_next = cmd;
}else{
 host->pending_commands = cmd;
}

spin_unlock_irqrestore(&scsi_mlqueue_lock, flags);
return0;
}

/*
 * Function: scsi_mlqueue_finish()
 *
 * Purpose: Try and queue commands from the midlevel queue.
 *
 * Arguments: host - host that just finished a command.
 * device - device that just finished a command.
 *
 * Returns: Nothing.
 *
 * Notes: This could be called either from an interrupt context or a
 * normal process context.
 */
intscsi_mlqueue_finish(struct Scsi_Host *host, Scsi_Device * device)
{
 Scsi_Cmnd *cpnt;
unsigned long flags;
 Scsi_Cmnd *next;
 Scsi_Cmnd *prev;
int reason =0;
int rtn;

SCSI_LOG_MLQUEUE(2,printk("scsi_mlqueue_finish starting\n"));
/*
 * First, clear the flag for the host/device. We will then start
 * pushing commands through until either something else blocks, or
 * the queue is empty.
 */
if(host->host_blocked) {
 reason = SCSI_MLQUEUE_HOST_BUSY;
 host->host_blocked = FALSE;
}
if(device->device_busy) {
 reason = SCSI_MLQUEUE_DEVICE_BUSY;
 device->device_busy = FALSE;
}
/*
 * Walk the list of commands to see if there is anything we can
 * queue. This probably needs to be optimized for performance at
 * some point.
 */
 prev = NULL;
spin_lock_irqsave(&scsi_mlqueue_remove_lock, flags);
for(cpnt = host->pending_commands; cpnt; cpnt = next) {
 next = cpnt->bh_next;
/*
 * First, see if this command is suitable for being retried now.
 */
if(reason == SCSI_MLQUEUE_HOST_BUSY) {
/*
 * The host was busy, but isn't any more. Thus we may be
 * able to queue the command now, but we were waiting for
 * the device, then we should keep waiting. Similarily, if
 * the device is now busy, we should also keep waiting.
 */
if((cpnt->host_wait == FALSE)
|| (device->device_busy == TRUE)) {
 prev = cpnt;
continue;
}
}
if(reason == SCSI_MLQUEUE_DEVICE_BUSY) {
/*
 * The device was busy, but isn't any more. Thus we may be
 * able to queue the command now, but we were waiting for
 * the host, then we should keep waiting. Similarily, if
 * the host is now busy, we should also keep waiting.
 */
if((cpnt->device_wait == FALSE)
|| (host->host_blocked == TRUE)) {
 prev = cpnt;
continue;
}
}
/*
 * First, remove the command from the list.
 */
if(prev == NULL) {
 host->pending_commands = next;
}else{
 prev->bh_next = next;
}
 cpnt->bh_next = NULL;

 rtn =scsi_retry_command(cpnt);

/*
 * If we got a non-zero return value, it means that the host rejected
 * the command. The internal_cmnd function will have added the
 * command back to the end of the list, so we don't have anything
 * more to do here except return.
 */
if(rtn) {
spin_unlock_irqrestore(&scsi_mlqueue_remove_lock, flags);
SCSI_LOG_MLQUEUE(1,printk("Unable to remove command %p from mlqueue\n", cpnt));
goto finish;
}
SCSI_LOG_MLQUEUE(1,printk("Removed command %p from mlqueue\n", cpnt));
}

spin_unlock_irqrestore(&scsi_mlqueue_remove_lock, flags);
finish:
SCSI_LOG_MLQUEUE(2,printk("scsi_mlqueue_finish returning\n"));
return0;
}