adapters/iscsi/iscsi_queue.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2000 by Cisco Systems, Inc.  All rights reserved.
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * iSCSI Software Initiator
 */

#include "iscsi.h"      /* main header */

static void iscsi_enqueue_cmd_tail(iscsi_cmd_t **head, iscsi_cmd_t **tail,
    iscsi_cmd_t *icmdp);


/*
 * +--------------------------------------------------------------------+
 * | public queue functions                     |
 * +--------------------------------------------------------------------+
 *
 * Public queue locking rules.  When acquiring multiple queue locks
 * they MUST always be acquired in a forward order.  If a lock is
 * aquire in a reverese order it could lead to a deadlock panic.
 * The forward order of locking is described as shown below.
 *
 *       pending -> cmdsn -> active -> completion
 *
 * If a cmd_mutex is held, it is either held after the pending queue
 * mutex or after the active queue mutex.
 */

/*
 * iscsi_init_queue - used to initialize iscsi queue
 */
void
iscsi_init_queue(iscsi_queue_t *queue)
{
    ASSERT(queue != NULL);

    queue->head = NULL;
    queue->tail = NULL;
    queue->count = 0;
    mutex_init(&queue->mutex, NULL, MUTEX_DRIVER, NULL);
}

/*
 * iscsi_destroy_queue - used to terminate iscsi queue
 */
void
iscsi_destroy_queue(iscsi_queue_t *queue)
{
    ASSERT(queue != NULL);
    ASSERT(queue->count == 0);

    mutex_destroy(&queue->mutex);
}

/*
 * iscsi_enqueue_pending_cmd - used to add a command in a pending queue
 */
void
iscsi_enqueue_pending_cmd(iscsi_sess_t *isp, iscsi_cmd_t *icmdp)
{
    ASSERT(isp != NULL);
    ASSERT(icmdp != NULL);
    ASSERT(mutex_owned(&isp->sess_queue_pending.mutex));

    icmdp->cmd_state = ISCSI_CMD_STATE_PENDING;
    if (icmdp->cmd_type == ISCSI_CMD_TYPE_SCSI) {
        iscsi_enqueue_cmd_tail(&isp->sess_queue_pending.head,
            &isp->sess_queue_pending.tail, icmdp);
        isp->sess_queue_pending.count++;
        KSTAT_WAITQ_ENTER(isp);
    } else {
        iscsi_enqueue_cmd_head(&isp->sess_queue_pending.head,
            &isp->sess_queue_pending.tail, icmdp);
        isp->sess_queue_pending.count++;
        KSTAT_WAITQ_ENTER(isp);
    }
    iscsi_sess_redrive_io(isp);
}


/*
 * iscsi_dequeue_pending_cmd - used to remove a command from a pending queue
 */
void
iscsi_dequeue_pending_cmd(iscsi_sess_t *isp, iscsi_cmd_t *icmdp)
{
    iscsi_status_t rval = ISCSI_STATUS_SUCCESS;

    ASSERT(isp != NULL);
    ASSERT(icmdp != NULL);
    ASSERT(mutex_owned(&isp->sess_queue_pending.mutex));

    rval = iscsi_dequeue_cmd(&isp->sess_queue_pending.head,
        &isp->sess_queue_pending.tail, icmdp);
    if (ISCSI_SUCCESS(rval)) {
        isp->sess_queue_pending.count--;
        if (((kstat_io_t *)(&isp->stats.ks_io_data))->wcnt) {
            KSTAT_WAITQ_EXIT(isp);
        } else {
            cmn_err(CE_WARN,
                "kstat wcnt == 0 when exiting waitq,"
                " please check\n");
        }
    } else {
        ASSERT(FALSE);
    }
}

/*
 * iscsi_enqueue_active_cmd - used to add a command in a active queue
 *
 * This interface attempts to keep newer items are on the tail,
 * older items are on the head.  But, Do not assume that the list
 * is completely sorted.  If someone attempts to enqueue an item
 * that already has cmd_lbolt_active assigned and is older than
 * the current head, otherwise add to the tail.
 */
void
iscsi_enqueue_active_cmd(iscsi_conn_t *icp, iscsi_cmd_t *icmdp)
{
    iscsi_sess_t        *isp    = NULL;

    ASSERT(icp != NULL);
    ASSERT(icmdp != NULL);
    isp = icp->conn_sess;
    ASSERT(isp != NULL);

    /*
     * When receiving data associated to a command it
     * is temporarily removed from the active queue.
     * Then once the data receive is completed it may
     * be returned to the active queue.  If this was
     * an aborting command we need to preserve its
     * state.
     */
    if (icmdp->cmd_state != ISCSI_CMD_STATE_ABORTING) {
        icmdp->cmd_state = ISCSI_CMD_STATE_ACTIVE;
    }

    /*
     * It's possible that this is not a newly issued icmdp - we may
     * have tried to abort it but the abort failed or was rejected
     * and we are putting it back on the active list. So if it is older
     * than the head of the active queue, put it at the head to keep
     * the CommandTimeout valid.
     */
    if (icmdp->cmd_lbolt_active == 0) {
        icmdp->cmd_lbolt_active = ddi_get_lbolt();
        iscsi_enqueue_cmd_tail(&icp->conn_queue_active.head,
            &icp->conn_queue_active.tail, icmdp);
    } else if ((icp->conn_queue_active.head != NULL) &&
        (icmdp->cmd_lbolt_active <
        icp->conn_queue_active.head->cmd_lbolt_active)) {
        iscsi_enqueue_cmd_head(&icp->conn_queue_active.head,
            &icp->conn_queue_active.tail, icmdp);
    } else {
        iscsi_enqueue_cmd_tail(&icp->conn_queue_active.head,
            &icp->conn_queue_active.tail, icmdp);
    }
    icp->conn_queue_active.count++;

    if (icmdp->cmd_type == ISCSI_CMD_TYPE_SCSI) {
        KSTAT_RUNQ_ENTER(isp);
    }
}

/*
 * iscsi_dequeue_active_cmd - used to remove a command from a active queue
 */
void
iscsi_dequeue_active_cmd(iscsi_conn_t *icp, iscsi_cmd_t *icmdp)
{
    iscsi_status_t  rval    = ISCSI_STATUS_SUCCESS;
    iscsi_sess_t    *isp    = NULL;

    ASSERT(icp != NULL);
    ASSERT(icmdp != NULL);
    isp = icp->conn_sess;
    ASSERT(isp != NULL);
    ASSERT(mutex_owned(&icp->conn_queue_active.mutex));

    rval = iscsi_dequeue_cmd(&icp->conn_queue_active.head,
        &icp->conn_queue_active.tail, icmdp);

    if (ISCSI_SUCCESS(rval)) {
        icp->conn_queue_active.count--;

        if (icmdp->cmd_type == ISCSI_CMD_TYPE_SCSI) {
            if (((kstat_io_t *)(&isp->stats.ks_io_data))->rcnt) {
                KSTAT_RUNQ_EXIT(isp);
            } else {
                cmn_err(CE_WARN,
                    "kstat rcnt == 0 when exiting runq,"
                    " please check\n");
            }
        }
    } else {
        ASSERT(FALSE);
    }
}

/*
 * iscsi_enqueue_idm_aborting_cmd - used to add a command to the queue
 * representing command waiting for a callback from IDM for aborting
 *
 * Not sorted
 */
void
iscsi_enqueue_idm_aborting_cmd(iscsi_conn_t *icp, iscsi_cmd_t *icmdp)
{
    iscsi_sess_t        *isp    = NULL;

    ASSERT(icp != NULL);
    ASSERT(icmdp != NULL);
    isp = icp->conn_sess;
    ASSERT(isp != NULL);
    ASSERT(icmdp->cmd_type == ISCSI_CMD_TYPE_SCSI);
    ASSERT(mutex_owned(&icp->conn_queue_idm_aborting.mutex));

    icmdp->cmd_state = ISCSI_CMD_STATE_IDM_ABORTING;
    icmdp->cmd_lbolt_idm_aborting = ddi_get_lbolt();
    iscsi_enqueue_cmd_tail(&icp->conn_queue_idm_aborting.head,
        &icp->conn_queue_idm_aborting.tail, icmdp);
    icp->conn_queue_idm_aborting.count++;
}

/*
 * iscsi_dequeue_idm_aborting_cmd - used to remove a command from the queue
 * representing commands waiting for a callback from IDM for aborting.
 */
void
iscsi_dequeue_idm_aborting_cmd(iscsi_conn_t *icp, iscsi_cmd_t *icmdp)
{
    iscsi_sess_t    *isp    = NULL;

    ASSERT(icp != NULL);
    ASSERT(icmdp != NULL);
    isp = icp->conn_sess;
    ASSERT(isp != NULL);
    ASSERT(mutex_owned(&icp->conn_queue_idm_aborting.mutex));

    (void) iscsi_dequeue_cmd(&icp->conn_queue_idm_aborting.head,
        &icp->conn_queue_idm_aborting.tail, icmdp);
    icp->conn_queue_idm_aborting.count--;
}

/*
 * iscsi_enqueue_completed_cmd - used to add a command in completion queue
 */
void
iscsi_enqueue_completed_cmd(iscsi_sess_t *isp, iscsi_cmd_t *icmdp)
{
    ASSERT(isp != NULL);
    ASSERT(icmdp != NULL);

    mutex_enter(&isp->sess_queue_completion.mutex);
    if (icmdp->cmd_state != ISCSI_CMD_STATE_COMPLETED) {
        icmdp->cmd_state = ISCSI_CMD_STATE_COMPLETED;
    } else {
        /*
         * This command has already been completed, probably
         * through the abort code path. It should  be in
         * the process of being returned to to the upper
         * layers, so do nothing.
         */
        mutex_exit(&isp->sess_queue_completion.mutex);
        return;
    }
    iscsi_enqueue_cmd_tail(&isp->sess_queue_completion.head,
        &isp->sess_queue_completion.tail, icmdp);
    ++isp->sess_queue_completion.count;
    mutex_exit(&isp->sess_queue_completion.mutex);

    (void) iscsi_thread_send_wakeup(isp->sess_ic_thread);
}

/*
 * iscsi_move_queue - used to move the whole contents of a queue
 *
 *   The source queue has to be initialized.  Its mutex is entered before
 * doing the actual move.  The destination queue should be initialized.
 * This function is intended to move a queue located in a shared location
 * into local space.  No mutex is needed for the destination queue.
 */
void
iscsi_move_queue(
    iscsi_queue_t   *src_queue,
    iscsi_queue_t   *dst_queue
)
{
    ASSERT(src_queue != NULL);
    ASSERT(dst_queue != NULL);
    mutex_enter(&src_queue->mutex);
    dst_queue->count = src_queue->count;
    dst_queue->head  = src_queue->head;
    dst_queue->tail  = src_queue->tail;
    src_queue->count = 0;
    src_queue->head  = NULL;
    src_queue->tail  = NULL;
    mutex_exit(&src_queue->mutex);
}

/*
 * +--------------------------------------------------------------------+
 * | private functions                          |
 * +--------------------------------------------------------------------+
 */

/*
 * iscsi_dequeue_cmd - used to remove a command from a queue
 */
iscsi_status_t
iscsi_dequeue_cmd(iscsi_cmd_t **head, iscsi_cmd_t **tail, iscsi_cmd_t *icmdp)
{
#ifdef DEBUG
    iscsi_cmd_t *tp = NULL;
#endif

    ASSERT(head != NULL);
    ASSERT(tail != NULL);
    ASSERT(icmdp != NULL);

    if (*head == NULL) {
        /* empty queue, error */
        return (ISCSI_STATUS_INTERNAL_ERROR);
    } else if (*head == *tail) {
        /* one element queue */
        if (*head == icmdp) {
            *head = NULL;
            *tail = NULL;
        } else {
            return (ISCSI_STATUS_INTERNAL_ERROR);
        }
    } else {
        /* multi-element queue */
        if (*head == icmdp) {
            /* at the head */
            *head = icmdp->cmd_next;
            (*head)->cmd_prev = NULL;
        } else if (*tail == icmdp) {
            *tail = icmdp->cmd_prev;
            (*tail)->cmd_next = NULL;
        } else {
#ifdef DEBUG
            /* in the middle? */
            for (tp = (*head)->cmd_next; (tp != NULL) &&
                (tp != icmdp); tp = tp->cmd_next)
                ;
            if (tp == NULL) {
                /* not found */
                return (ISCSI_STATUS_INTERNAL_ERROR);
            }
#endif
            if (icmdp->cmd_prev == NULL) {
                return (ISCSI_STATUS_INTERNAL_ERROR);
            }
            icmdp->cmd_prev->cmd_next = icmdp->cmd_next;
            if (icmdp->cmd_next == NULL) {
                return (ISCSI_STATUS_INTERNAL_ERROR);
            }
            icmdp->cmd_next->cmd_prev = icmdp->cmd_prev;
        }
    }

    /* icmdp no longer in the queue */
    icmdp->cmd_prev = NULL;
    icmdp->cmd_next = NULL;
    return (ISCSI_STATUS_SUCCESS);
}

/*
 * iscsi_enqueue_cmd_head - used to add a command to the head of a queue
 */
void
iscsi_enqueue_cmd_head(iscsi_cmd_t **head, iscsi_cmd_t **tail,
    iscsi_cmd_t *icmdp)
{
    ASSERT(icmdp != NULL);
    ASSERT(icmdp->cmd_next == NULL);
    ASSERT(icmdp->cmd_prev == NULL);
    ASSERT(icmdp != *head);
    ASSERT(icmdp != *tail);

    if (*head == NULL) {
        /* empty queue */
        *head = *tail = icmdp;
        icmdp->cmd_prev = NULL;
        icmdp->cmd_next = NULL;
    } else {
        /* non-empty queue */
        icmdp->cmd_next = *head;
        icmdp->cmd_prev = NULL;
        (*head)->cmd_prev = icmdp;
        *head = icmdp;
    }
}

/*
 * iscsi_enqueue_cmd_tail - used to add a command to the tail of a queue
 */
static void
iscsi_enqueue_cmd_tail(iscsi_cmd_t **head, iscsi_cmd_t **tail,
    iscsi_cmd_t *icmdp)
{
    ASSERT(icmdp != NULL);
    ASSERT(icmdp->cmd_next == NULL);
    ASSERT(icmdp->cmd_prev == NULL);
    ASSERT(icmdp != *head);
    ASSERT(icmdp != *tail);

    if (*head == NULL) {
        /* empty queue */
        *head = *tail = icmdp;
        icmdp->cmd_prev = NULL;
        icmdp->cmd_next = NULL;
    } else {
        /* non-empty queue */
        icmdp->cmd_next = NULL;
        icmdp->cmd_prev = *tail;
        (*tail)->cmd_next = icmdp;
        *tail = icmdp;
    }
}