ocs_session.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

/**
 * @file
 * OCS iSCSI session managment functions.
 */
/*!
@defgroup sess_mgnt iSCSI session management
*/

#include "ocs.h"
#include "ocs_iscsi.h"
#include "ocs_iscsi_spec.h"
#include "ocs_common.h"
#include "ocs_hal.h"
#include "ocs_iscsi_api.h"
#include "ocs_cxn.h"
#include "ocs_login.h"
#include "ocs_session.h"

#define CMD_Q_TIMER_MS 30 /* 30 milliseconds */

/* declare local functions */
static void ocs_session_check_queued_commands(ocs_session_t *session);
static void ocs_session_cmd_q_timeout(void *arg);


/**
 * @ingroup sess_mgnt
 * @brief Initialize the session management by allocating objects for sessions.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_session_initialize(ocs_iscsi_t *iscsi)
{
    uint32_t i,j;

    ocs_lock_init(iscsi->os, &iscsi->sess_queue_lock, "session_mem_lock[%d]", ocs_instance(iscsi->os));

    /* Allocate the session objects and put them on the free list. */
    ocs_list_init(&iscsi->sess_free, ocs_session_t, link);
    ocs_list_init(&iscsi->sess_busy, ocs_session_t, link);

    iscsi->sess_mem = ocs_malloc(iscsi->os, sizeof(ocs_session_t) *
                    iscsi->num_cxns,
                    OCS_M_ZERO | OCS_M_NOWAIT);
    if (iscsi->sess_mem == NULL) {
        ocs_log_err(iscsi->os, "Failed to allocate sessions, num_cxns is %d\n",
                iscsi->num_cxns);
        ocs_log_err(iscsi->os, "sizeof(ocs_session_t) is %ld, total alloc is %ld\n", sizeof(ocs_session_t), sizeof(ocs_session_t) * iscsi->num_cxns);
        return -ENOMEM;
    }

    for (i = 0; i < iscsi->num_cxns; i++) {
        ocs_session_t *session = &iscsi->sess_mem[i];

        /* Allocate memory for the command queue */
        session->cmd_q = ocs_malloc(iscsi->os, sizeof(ocs_session_q_unsol_t) *
                    OCS_ISCSI_MAX_QUEUED_CMDSN,
                    OCS_M_ZERO | OCS_M_NOWAIT);

        if (session->cmd_q == NULL) {
            ocs_log_err(iscsi->os, "Failed to allocate memory for cmd queue\n");
            return -ENOMEM;
        }

        ocs_lock_init(iscsi->os, &session->cmd_q_lock, "cmd_q lock[%d]", i);
        ocs_list_init(&session->cxn_list, ocs_cxn_t, sess_link);
        session->ocs = iscsi->os;
        session->iscsi = iscsi;
        session->instance_index = i;
        ocs_list_init(&session->cmd_q_waiting, ocs_session_q_unsol_t, link);
        ocs_list_init(&session->cmd_q_free, ocs_session_q_unsol_t, link);
        for (j = 0; j < OCS_ISCSI_MAX_QUEUED_CMDSN; j++) {
            ocs_list_add_tail(&session->cmd_q_free, &session->cmd_q[j]);
        }
        ocs_list_add_tail(&iscsi->sess_free, session);
    }

    return 0;
}

/**
 * @ingroup sess_mgnt
 * @brief Releases the session objects used within the login module.
 *
 * @param iscsi Pointer to the iSCSI object.
 */
void
ocs_session_teardown(ocs_iscsi_t *iscsi)
{
    ocs_session_t *session;
    uint32_t i;

    /* Empty the lists */
    ocs_lock(&iscsi->sess_queue_lock);
    session = ocs_list_get_head(&iscsi->sess_free);
    while (NULL != session) {
        ocs_list_remove_head(&iscsi->sess_free);
        session = ocs_list_get_head(&iscsi->sess_free);
    }

    session = ocs_list_get_head(&iscsi->sess_busy);
    while (NULL != session) {
        ocs_list_remove_head(&iscsi->sess_busy);

        /* Need to release this lock prior to calling ocs_session_close() */
        ocs_unlock(&iscsi->sess_queue_lock);
        ocs_session_close(session, TRUE);
        ocs_lock(&iscsi->sess_queue_lock);

        session = ocs_list_get_head(&iscsi->sess_busy);
    }
    ocs_unlock(&iscsi->sess_queue_lock);

    if (iscsi->sess_mem != NULL) {
        for (i = 0; i < iscsi->num_cxns; i++) {
            ocs_session_t *session = &iscsi->sess_mem[i];

            if (session->cmd_q != NULL) {
                ocs_free(iscsi->os, session->cmd_q,
                     sizeof(ocs_session_q_unsol_t) *
                     OCS_ISCSI_MAX_QUEUED_CMDSN);
                session->cmd_q = NULL;
            }
            ocs_lock_free(&session->cmd_q_lock);
        }
        ocs_free(iscsi->os, iscsi->sess_mem, sizeof(ocs_session_t) * iscsi->num_cxns);
        iscsi->sess_mem = NULL;
    }

    ocs_lock_free(&iscsi->sess_queue_lock);
}

/**
 * @ingroup sess_mgnt
 * @brief Find an existing session or create a new one based on the login parameters.
 *
 * @param cxn Pointer to the connection object.
 * @param tgt_name Pointer to the target name.
 * @param ini_name Pointer to the initiator name.
 * @param isid The iSCSI initiator session ID from the login PDU.
 * @param tsih The iSCSI target session handle from the login PDU.
 * @param cid The iSCSI connection ID from the login PDU.
 * @param cmd_sn The iSCSI command SN from the login PDU.
 *
 * @return 
 * - 0 - success.
 * - 1 - session does not exist.
 * - 2 - exceeds Max Cxn.
 * - 3 - no resources.
 */
int32_t
ocs_session_cxn_new(ocs_cxn_t *cxn,
            char *tgt_name,
            char *ini_name,
            uint64_t isid,
            uint16_t tsih,
            uint16_t cid,
            uint32_t cmd_sn)
{
    ocs_t *ocs = cxn->ocs;
    ocs_iscsi_t *iscsi = cxn->iscsi;
    ocs_session_t *session;
    ocs_cxn_t *cxn_tmp;
    uint8_t isid_found = FALSE;
    uint8_t cxn_found  = FALSE;
    uint8_t create_new_session = FALSE;
    uint8_t add_cxn = FALSE;
    uint32_t cxn_cnt = 0;
    int32_t rc = 0;

    /*
     * See section 3.5.1 of the iSCSI spec, either find the session,
     * create a new one or reject the login.
     */

    /* Find the iSID in the existing sessions */
    ocs_lock(&iscsi->sess_queue_lock);
    ocs_list_foreach(&iscsi->sess_busy, session) {
        if (isid == session->isid &&
            !session->is_removed &&
            ocs_strcmp(tgt_name, session->tgt_name) == 0 &&
            ocs_strcmp(ini_name, session->ini_name) == 0) {
            isid_found = TRUE;
            break;
        }
    }
    ocs_unlock(&iscsi->sess_queue_lock);

    if (isid_found) {
        /* Find the connection and also count the connections*/
        ocs_lock(&iscsi->sess_queue_lock);
        ocs_list_foreach(&session->cxn_list, cxn_tmp) {
            cxn_cnt++;
            if (cid == cxn_tmp->cid) {
                cxn_found = TRUE;
            }
        }
        ocs_unlock(&iscsi->sess_queue_lock);

        if (tsih == 0) {
            /* Perform session reinstatement */
            ocs_log_debug(ocs, "Session reinstatement for isid 0x%" PRIx64 ", tsih = 0x%x\n",
                      session->isid, session->tsih);
            ocs_session_close(session, TRUE);
            create_new_session = TRUE;
            cxn_cnt = 0;
        } else if (tsih != session->tsih) {
            /* Session does not exist */
            rc = 1;
        } else {
            if (cxn_found) {
                /* Perform connection reinstatement */
                (void)ocs_cxn_close(cxn_tmp, TRUE);
                add_cxn = TRUE;
            } else {
                /* Make sure we have not exceeded max connections */
                if (cxn_cnt >= session->login_options.max_connections) {
                    rc = 2;
                } else {
                    add_cxn = TRUE;
                }
            }
        }
    } else {
        /* no session found */
        if (tsih == 0) {
            /* Create a new session */
            create_new_session = TRUE;
        } else {
            /* Fail the login - session does not exist */
            rc = 1;
        }
    }

    if (rc == 0 && create_new_session) {
        /* Allocate one from the free list */
        ocs_lock(&iscsi->sess_queue_lock);
        session = ocs_list_get_head(&iscsi->sess_free);
        if (NULL != session) {
            ocs_list_remove_head(&iscsi->sess_free);
            ocs_list_add_tail(&iscsi->sess_busy, session);

            session->isid = isid;
            /* tsih cannot be 0 */
            if (ocs_strlen(tgt_name) < OCS_MAX_ISCSI_NAME) {
                ocs_strcpy(session->tgt_name, tgt_name);
            } else {
                ocs_strncpy(session->tgt_name, tgt_name, OCS_MAX_ISCSI_NAME);
                ocs_log_test(ocs, "Tgt name of len %d exceeds max of %d chars\n",
                         (int)ocs_strlen(tgt_name), OCS_MAX_ISCSI_NAME);
            }
            if (ocs_strlen(ini_name) < OCS_MAX_ISCSI_NAME) {
                ocs_strcpy(session->ini_name, ini_name);
            } else {
                ocs_strncpy(session->ini_name, ini_name, OCS_MAX_ISCSI_NAME);
                ocs_log_test(ocs, "Ini name of len %d exceeds max of %d chars\n",
                         (int)ocs_strlen(ini_name), OCS_MAX_ISCSI_NAME);
            }
            session->tsih = session->instance_index + 1;
            session->login_options.initial_r2t = 1;
            session->login_options.immediate_data = (ocs->enable_immediate_data ? 1 : 0);;
            session->login_options.data_pdu_in_order = 1;
            session->login_options.data_sequence_in_order = 1;
            session->login_options.error_recovery_level = 0;
            session->login_options.first_burst = OCS_HAL_RQ_SIZE_DATA;
            session->login_options.max_burst = OCS_ISCSI_LOGIN_MAX_BURST_LEN;
            session->login_options.max_connections = ocs_iscsi_get_max_cxns(ocs, tgt_name, ini_name);
            session->login_options.max_r2t = 1;
            session->login_options.def_time_to_wait = OCS_ISCSI_LOGIN_DEFAULT_TIME_2_WAIT;
            session->login_options.def_time_to_retain = OCS_ISCSI_LOGIN_DEFAULT_TIME_2_RETAIN;

            session->cmd_sn = cmd_sn;
            session->is_discovery_session = FALSE;
            session->is_removed = FALSE;
            session->cmd_q_num_queued = 0;
            add_cxn = TRUE;

            ocs_log_debug(ocs, "Session created for isid 0x%" PRIx64 ", tsih = 0x%x\n",
                      session->isid, session->tsih);
        } else {
            rc = 3;
        }
        ocs_unlock(&iscsi->sess_queue_lock);
    }

    if (rc == 0 && add_cxn) {
        ocs_lock(&iscsi->sess_queue_lock);
        ocs_list_add_tail(&session->cxn_list, cxn);
        ocs_unlock(&iscsi->sess_queue_lock);

        cxn->session = session;
        cxn->is_leading_login = (cxn_cnt == 0);
        ocs_log_debug(ocs, "Added connection 0x%x to isid 0x%" PRIx64 ", tsih = 0x%x, is leading login = %d\n",
                  cxn->cid, session->isid, session->tsih,
                  cxn->is_leading_login);
    }

    return rc;
}

/**
 * @ingroup sess_mgnt
 * @brief Removes a connection from its session.
 *
 * @param cxn Pointer to the connection object.
 */
int32_t
ocs_session_cxn_del(ocs_cxn_t *cxn)
{
    ocs_iscsi_t *iscsi = cxn->iscsi;
    ocs_session_t *session = cxn->session;

    if (session) {
        ocs_lock(&iscsi->sess_queue_lock);
        ocs_list_remove(&session->cxn_list, cxn);
        cxn->session = NULL;

        ocs_log_debug(iscsi->os, "removed connection 0x%x to isid 0x%" PRIx64 ", tsih = 0x%x\n",
                  cxn->cid, session->isid, session->tsih);

        /* If all the connections are removed, then free the session */
        cxn = ocs_list_get_head(&session->cxn_list);
        if (cxn == NULL) {
            ocs_list_remove(&iscsi->sess_busy, session);
            ocs_list_add_tail(&iscsi->sess_free, session);

            ocs_log_debug(iscsi->os, "Session deleted for isid 0x%" PRIx64 " , tsih = 0x%x\n",
                      session->isid, session->tsih);
        }
        ocs_unlock(&iscsi->sess_queue_lock);
    }
    return 0;
}

/**
 * @ingroup sess_mgnt
 * @brief Locate a connection within a session based on the cid.
 *
 * @param session Pointer to the session object.
 * @param cid The iSCSI connection ID to find.
 *
 * @return Pointer to the connection, or NULL if not found.
 */
ocs_cxn_t *ocs_session_cxn_find(ocs_session_t *session,
                uint16_t cid)
{
    ocs_iscsi_t *iscsi = session->iscsi;
    ocs_cxn_t *cxn;
    ocs_cxn_t *rc = NULL;

    ocs_lock(&iscsi->sess_queue_lock);
    ocs_list_foreach(&session->cxn_list, cxn) {
        if (cxn->cid == cid) {
            rc = cxn;
            break;
        }
    }
    ocs_unlock(&iscsi->sess_queue_lock);
    return rc;
}

/**
 * @ingroup sess_mgnt
 * @brief Closes all connections on a session.
 *
 * @param session Pointer to the session object.
 * @param reset A non-zero value causes a connection reset to be issued.
 */
void
ocs_session_close(ocs_session_t *session, uint8_t reset)
{
    ocs_iscsi_t *iscsi = session->iscsi;
    ocs_cxn_t *cxn;
    ocs_session_q_unsol_t *cmd;

    session->is_removed = TRUE;
    /* release any buffers held by queued commands */
    ocs_lock(&session->cmd_q_lock);
    cmd = ocs_list_get_head(&session->cmd_q_waiting);
    if (NULL != cmd) {
        ocs_list_remove_head(&session->cmd_q_waiting);
        /* Don't post the buffers if the queues are not setup */
        if (iscsi->is_hal_initialized == TRUE) {
            ocs_iscsi_rx_buffers_free(iscsi, cmd->hdr, cmd->data);
        }
        ocs_list_add_tail(&session->cmd_q_free, cmd);
        session->cmd_q_num_queued--;

        cmd = ocs_list_get_head(&session->cmd_q_waiting);
    }
    ocs_unlock(&session->cmd_q_lock);

    /* Kill the cmd_q timer if it is active */
    if (ocs_timer_pending(&session->cmd_q_timer)) {
        ocs_del_timer(&session->cmd_q_timer);
    }

    ocs_lock(&iscsi->sess_queue_lock);
    ocs_list_foreach(&session->cxn_list, cxn) {
        cxn->cxn_state = CONN_STATE_LOGOUT_REQUESTED;
        (void)ocs_cxn_close(cxn, reset);
    }
    ocs_unlock(&iscsi->sess_queue_lock);
}


/**
 * @ingroup sess_mgnt
 * @brief Updates the max_cmd_sn based on the number IOs available.
 *
 * @param session Pointer to the session object.
 */
void
ocs_session_max_cmd_sn_upd(ocs_session_t *session)
{
    uint32_t window_size;
    uint32_t max_cmd_sn;

    window_size = OCS_ISCSI_MAX_QUEUED_CMDSN - session->cmd_q_num_queued;

    /*
     * Subtract 2 commands to allow for a single immediate command and a
     * task management command.
     */
    if (window_size > 2) {
        window_size -=2;
    }

    /*
     * One last trick, the max_cmd_sn cannot move backwards or it will be
     * discarded by the initiator. We also want to allow the max_cmd_sn to
     * be equal to 1 less than the exp_cmd_sn (closed window) to prevent more
     * commands from comming.
     */
    max_cmd_sn = (session->exp_cmd_sn + window_size) - 1;
    if (GT_WRAPPED(max_cmd_sn, session->max_cmd_sn)) {
        /* New number wrapped and therefore it is bigger => update */
        session->max_cmd_sn = max_cmd_sn;
    } else if (max_cmd_sn > session->max_cmd_sn) {
        /* not wrapped, but bigger => update */
        session->max_cmd_sn = max_cmd_sn;
    }

}

/**
 * @brief This function is called to process commands on a session command queue.
 *
 * @param arg Pointer to the session object.
 */
static void
ocs_session_cmd_q_timeout(void *arg)
{
    ocs_session_t *session = arg;

    ocs_session_check_queued_commands(session);
}

/**
 * @ingroup sess_mgnt
 * @brief Checks the queued command to see if any can start.
 *
 * @param session Pointer to the session object.
 */
static void
ocs_session_check_queued_commands(ocs_session_t *session)
{
    ocs_iscsi_t *iscsi = session->iscsi;
    ocs_t *ocs = session->ocs;
    ocs_session_q_unsol_t *cmd_q;
    ocs_session_q_unsol_t *cmd_q_next;
    uint8_t cmd_processed = TRUE;
    uint8_t set_timer = FALSE;
    uint8_t release_entry;
    uint8_t free_rx_buffer;
    uint8_t decr_cmd_sn;
    ocs_pdu_process_rtn_e pdu_status;
    uint8_t reject_reason;
    int32_t rc;

    ocs_lock(&session->cmd_q_lock);
    while (cmd_processed) {
        cmd_processed = FALSE;

        ocs_list_foreach_safe(&session->cmd_q_waiting, cmd_q, cmd_q_next) {
            iscsi_login_cmd_hdr_t *bhs = cmd_q->hdr->dma.virt;

            release_entry = FALSE;
            free_rx_buffer = FALSE;
            decr_cmd_sn = FALSE;
            if (unlikely(before(cmd_q->cmd_sn, session->exp_cmd_sn))) {
                /* Discard */
                release_entry = TRUE;
                free_rx_buffer = TRUE;
                ocs_log_test(ocs, "Dropping cmd_sn 0x%x, exp_cmd_sn 0x%x for session instance %d\n",
                         cmd_q->cmd_sn,
                         session->exp_cmd_sn,
                         session->instance_index);
            } else if (cmd_q->cmd_sn == session->exp_cmd_sn) {
                if (cmd_q->aborted) {
                    ocs_iscsi_rx_buffers_free(iscsi, cmd_q->hdr, cmd_q->data);
                    pdu_status = OCS_PDU_RTN_PROCESSED;
                } else {
                    /*
                     * Increment the cmdSN so that any
                     * response will carry the new values,
                     * in the case of a reject, then we will
                     * have to back it back out.
                     */
                    if (bhs->immediate == 0) {
                        session->exp_cmd_sn++;
                    }
                    pdu_status = ocs_iscsi_tgt_process_cmd_sn
                        (iscsi,
                         cmd_q->cxn,
                         cmd_q->hdr,
                         cmd_q->hdr_len,
                         cmd_q->data,
                         cmd_q->data_len,
                         cmd_q->code,
                         &reject_reason);
                }

                switch(pdu_status) {
                case OCS_PDU_RTN_PROCESSED:
                    release_entry = TRUE;
                    free_rx_buffer = TRUE;
                    cmd_processed = TRUE;
                    break;
                case OCS_PDU_RTN_CBIT_QUEUED:
                    release_entry = TRUE;
                    break;

                case OCS_PDU_RTN_NO_RESOURCES:
                    decr_cmd_sn = TRUE;
                    /* Leave in queue, set timer */
                    set_timer = TRUE;
                    break;
                case OCS_PDU_RTN_SEND_REJECT:
                    ocs_log_test(ocs, "PDU handler returned reject\n");

                    /* Do not increment cmdSN on reject */
                    decr_cmd_sn = TRUE;
                    rc = ocs_iscsi_send_reject(cmd_q->cxn,
                                   cmd_q->hdr->dma.virt,
                                   cmd_q->hdr_len,
                                   reject_reason);
                    if (rc == 0 ||
                        rc == OCS_LOGIN_REQUEST_QUEUED) {
                        release_entry = TRUE;
                        free_rx_buffer = TRUE;
                    } else {
                        /* Leave in queue, set timer */
                        set_timer = TRUE;
                    }
                    break;

                case OCS_PDU_RTN_GENERAL_ERROR:
                    ocs_log_test(ocs, "general error on cmdsn %d", cmd_q->cmd_sn);
                    decr_cmd_sn = TRUE;
                    release_entry = TRUE;
                    free_rx_buffer = TRUE;
                    cmd_processed = TRUE;
                    break;
                }
            }
            if (release_entry) {
                ocs_list_remove(&session->cmd_q_waiting, cmd_q);
                if (free_rx_buffer) {
                    ocs_iscsi_rx_buffers_free(iscsi, cmd_q->hdr, cmd_q->data);
                }
                ocs_list_add_tail(&session->cmd_q_free, cmd_q);
                session->cmd_q_num_queued--;
            }
            if (decr_cmd_sn && bhs->immediate == 0) {
                session->exp_cmd_sn--;
            }
        }
    }
    ocs_unlock(&session->cmd_q_lock);

    if (set_timer) {
        if (!ocs_timer_pending(&session->cmd_q_timer)) {
            ocs_setup_timer(ocs, &session->cmd_q_timer,
                    ocs_session_cmd_q_timeout,
                    session,
                    CMD_Q_TIMER_MS, false);
        }
    }
}

/**
 * @ingroup sess_mgnt
 * @brief Adds a command to the command queue.
 *
 * @param cxn Pointer to the connection object.
 * @param hdr DMA memory information for the header.
 * @param hdr_len Length of the header received.
 * @param data DMA memory information for the data.
 * @param data_len Length of the data received.
 * @param code Type of callback received from the chip
 *    (i.e. SLI_STATUS_UNSOL_DATA_DIGEST_ERROR).
 * @param cmd_sn The iSCSI command sequence number.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_session_queue_command(ocs_cxn_t *cxn,
              ocs_hal_rq_buffer_t *hdr,
              uint32_t   hdr_len,
              ocs_hal_rq_buffer_t *data,
              uint32_t   data_len,
              uint8_t    code,
              uint32_t   cmd_sn)
{
    ocs_iscsi_t *iscsi = cxn->iscsi;
    ocs_session_t *session = cxn->session;
    ocs_session_q_unsol_t *cmd_q;
    int32_t rc = 0;

    /* make sure the session is not null */
    if (session == NULL) {
        rc = -1;
    } else {
        ocs_lock(&session->cmd_q_lock);
        cmd_q = ocs_list_get_head(&session->cmd_q_free);
        if (NULL != cmd_q) {
            ocs_list_remove_head(&session->cmd_q_free);
            cmd_q->cxn      = cxn;
            cmd_q->cmd_sn   = cmd_sn;
            cmd_q->hdr      = hdr;
            cmd_q->hdr_len  = hdr_len;
            cmd_q->data     = data;
            cmd_q->data_len = data_len;
            cmd_q->code     = code;
            cmd_q->aborted  = FALSE;
            ocs_list_add_tail(&session->cmd_q_waiting, cmd_q);
            session->cmd_q_num_queued++;
        } else {
            ocs_log_test(iscsi->os, "no room on command queue");
            rc = -1;
        }
        ocs_unlock(&session->cmd_q_lock);
    }
    return rc;
}


/**
 * @ingroup sess_mgnt
 * @brief Function to handle unsolicited PDUs on a target.
 *
 * @param cxn Pointer to the connection object.
 * @param hdr DMA memory information for the header.
 * @param hdr_len Length of the header received.
 * @param data DMA memory information for the data.
 * @param data_len Length of the data received.
 * @param code Type of callback received from the chip 
 *   (i.e. SLI_STATUS_UNSOL_DATA_DIGEST_ERROR)
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_session_tgt_unsol_pdu_recv(ocs_cxn_t *cxn,
                   ocs_hal_rq_buffer_t *hdr,
                   uint32_t   hdr_len,
                   ocs_hal_rq_buffer_t *data,
                   uint32_t   data_len,
                   uint8_t    code)
{
    ocs_iscsi_t *iscsi = cxn->iscsi;
    ocs_session_t *session = cxn->session;
    iscsi_login_cmd_hdr_t *bhs = hdr->dma.virt;
    uint32_t cmd_sn = ocs_be32toh(bhs->cmd_sn);
    ocs_pdu_process_rtn_e pdu_status;
    uint8_t decr_cmd_sn = FALSE;
    uint8_t reject_reason;
    int32_t rc = 0;

    /*
     * If the header length is zero, then this is a frame freed as part of
     * a connection cleanup, just free the buffer.
     */
    if (hdr_len == 0 ||
        (session != NULL && session->is_removed)) {
        return -1;
    }

    /*
     * A target receiving any PDU except a Login request before the Login
     * phase is started MUST immediately terminate the connection on which
     * the PDU was received.
     */
    if (cxn->cxn_state == CONN_STATE_NEW_CONN &&
        bhs->opcode != ISCSI_CMD_LOGIN) {
        /*
         * It's possible to get an unsolicited PDU before we've associated
         * the connection with an iscsi structure.
         */
        if (iscsi) {
            ocs_log_test(iscsi->os, "startup connection rcvd opcode 0x%x instead of logi PDU",
                     bhs->opcode);
        }
        ocs_cxn_close(cxn, TRUE);
        return -1;
    /*
     * Once the Login phase has started, if the target receives any PDU
     * except a Login request, it MUST send a Login reject (with Status
     * "invalid during login") and then disconnect.  If the initiator
     * receives any PDU except a Login response, it MUST immediately
     * terminate the connection.
     */
    } else if (cxn->cxn_state == CONN_STATE_LOGIN_PROGRESS &&
           bhs->opcode != ISCSI_CMD_LOGIN) {
        ocs_log_test(iscsi->os, "connection rcvd opcode 0x%x during login",
                 bhs->opcode);
        rc = ocs_iscsi_send_login_rsp_invalid_during_login
            (cxn, ocs_be32toh(bhs->itt));
        if (rc != 0 &&
            rc != OCS_LOGIN_REQUEST_QUEUED) {
            ocs_log_test(iscsi->os, "Failed sending Invalid login response");
        }
        ocs_cxn_close(cxn, FALSE);
        return 0;
    } else if (cxn->cxn_state == CONN_STATE_LOGOUT_REQUESTED &&
           bhs->opcode != ISCSI_CMD_LOGOUT) {
        /* Reject any PDUs received after requesting logout */
        ocs_log_test(iscsi->os, "%s Non-logout PDU after logout request - reject\n",
                 cxn->display_name);
        return ocs_iscsi_send_reject(cxn, hdr->dma.virt, hdr_len,
                         ISCSI_REJECT_REASON_WAITING_FOR_LOGOUT);
    } else if (cxn->cxn_state == CONN_STATE_FULL_FEATURE &&
           bhs->opcode == ISCSI_CMD_LOGIN) {
        /* Reject any PDUs received after requesting logout */
        ocs_log_test(iscsi->os, "%s Login PDU after login complete - reject\n",
                 cxn->display_name);
        return ocs_iscsi_send_reject(cxn, hdr->dma.virt, hdr_len,
                         ISCSI_REJECT_REASON_PROTOCOL_ERR);
    } else if (cxn->cxn_state == CONN_STATE_FULL_FEATURE &&
           session != NULL &&
           session->is_discovery_session) {
        uint8_t reason = ((iscsi_logout_cmd_hdr_t*)bhs)->reason_code;

        /*
         * For discovery sessions, The target MUST ONLY accept text
         * requests with the SendTargets key and a logout request with
         * the reason "close the session".  All other requests MUST be
         * rejected.
         */
        if (bhs->opcode != ISCSI_CMD_TEXT &&
            bhs->opcode != ISCSI_CMD_LOGOUT) {
            ocs_log_test(iscsi->os, "%s Only Text and logout allowed on discovery sessions\n",
                     cxn->display_name);
            ocs_cxn_close(cxn, FALSE);
            return 0;
        } else if (bhs->opcode == ISCSI_CMD_LOGOUT &&
               reason != LOGOUT_REASON_CLOSE_CONN_FOR_RECOVERY &&
               reason != LOGOUT_REASON_CLOSE_SESS) {
            ocs_log_test(iscsi->os, "%s Discovery logout with bad reason %d\n",
                     cxn->display_name, reason);
            ocs_cxn_close(cxn, FALSE);
            return 0;
        }
    }

    /* Clear the idle count */
    cxn->idle_count = 0;

    /*
     * If we get a data digest error on the PDU, then we reject it here and
     * no acknowledge the cmd_sn as it will have to be re-transmitted.
     */
    if (code == SLI_STATUS_UNSOL_DATA_DIGEST_ERROR) {
        ocs_log_test(iscsi->os, "Received data digest error");
        if (ocs_iscsi_send_reject(cxn, hdr->dma.virt, hdr_len,
                      ISCSI_REJECT_REASON_DATA_DIGEST_ERR)) {
            ocs_log_test(iscsi->os, "error sending reject for data digest error");
            ocs_cxn_close(cxn, FALSE);
        }
        return 0;
    }

    /*
     * Verify the cmdSN and then update the expected/max cmdSN fields.
     *
     * Immediate commands may be outside the command window (No checks)
     * Non-immediate commands must be within the range.
     * Multiple connections are not currently supported, so everything should be
     * in order.
     */
    if (bhs->immediate ||
        (session != NULL && cmd_sn == session->exp_cmd_sn)) {
        /*
         * Increment the cmdSN so that any response will carry the new
         * values, in the case of a reject, then we will have to back
         * it back out.
         */
        if (session != NULL &&
            bhs->immediate == 0) {
            session->exp_cmd_sn++;
        }

        pdu_status = ocs_iscsi_tgt_process_cmd_sn(iscsi,
                              cxn,
                              hdr,
                              hdr_len,
                              data,
                              data_len,
                              code,
                              &reject_reason);
        switch(pdu_status) {
        case OCS_PDU_RTN_PROCESSED:
            break;
        case OCS_PDU_RTN_CBIT_QUEUED:
            rc = OCS_LOGIN_REQUEST_QUEUED;
            break;
        case OCS_PDU_RTN_NO_RESOURCES:
            decr_cmd_sn = TRUE;
            rc = ocs_session_queue_command(cxn,
                               hdr,
                               hdr_len,
                               data,
                               data_len,
                               code,
                               cmd_sn);
            break;
        case OCS_PDU_RTN_SEND_REJECT:
            ocs_log_test(iscsi->os, "%s PDU handler returned reject\n",
                     cxn->display_name);
            /* Do not increment cmdSN on reject */
            decr_cmd_sn = TRUE;
            rc = ocs_iscsi_send_reject(cxn, hdr->dma.virt, hdr_len,
                           reject_reason);
            if (rc != 0 &&
                rc != OCS_LOGIN_REQUEST_QUEUED) {
                rc = ocs_session_queue_command(cxn,
                                   hdr,
                                   hdr_len,
                                   data,
                                   data_len,
                                   code,
                                   cmd_sn);
            }
            break;
        case OCS_PDU_RTN_GENERAL_ERROR:
            decr_cmd_sn = TRUE;
            ocs_log_test(iscsi->os, "%s general error on cmdsn %d",
                     cxn->display_name, cmd_sn);
            rc = -1;
            break;
        }

        /* Backup the cmdSN if required */
        if (decr_cmd_sn &&
            session != NULL &&
            bhs->immediate == 0) {
            session->exp_cmd_sn--;
        }

        if (session != NULL && session->cmd_q_num_queued > 0) {
            ocs_session_check_queued_commands(session);
        }

        if (session != NULL) {
            ocs_session_max_cmd_sn_upd(session);
        }
    } else if (session != NULL && after(cmd_sn, session->exp_cmd_sn)) {
        rc = ocs_session_queue_command(cxn,
                           hdr,
                           hdr_len,
                           data,
                           data_len,
                           code,
                           cmd_sn);
    } else {
        /*
         * An old command SN was received, this may be due to an
         * attempt to plug a perceived cmdsn hole. Silently discard
         * the PDU.
         */
        rc = 0;
    }

    return rc;
}


/**
 * @brief Abort a specific IO based on the ITT.
 *
 * @param session Pointer to the session object.
 * @param itt Initiator task tag to abort.
 *
 * @return Returns 0 if the IO was found.
 */
int32_t
ocs_session_abort_itt(ocs_session_t *session,
              uint32_t   itt)
{
    ocs_t *ocs = session->ocs;
    ocs_session_q_unsol_t *cmd_q;
    int32_t rc = -1;

    ocs_lock(&session->cmd_q_lock);
    ocs_list_foreach(&session->cmd_q_waiting, cmd_q) {
        iscsi_login_cmd_hdr_t *bhs = cmd_q->hdr->dma.virt;
        uint32_t cmd_itt = ocs_be32toh(bhs->itt);
        if (cmd_itt == itt) {
            cmd_q->aborted  = TRUE;
            rc = 0;
        }
    }
    ocs_unlock(&session->cmd_q_lock);

    ocs_log_debug(ocs, "ITT 0x%x aborted = %s for session instance %d\n",
              itt,
              (rc == 0 ? "Yes" : "No"),
              session->instance_index);
    return rc;
}


/**
 * @brief Abort a specific IO based on the cmdSN of the abort request
 *
 * @param session Pointer to the session object.
 * @param cmdsn Any commands preceding this cmdSN are aborted.
 */
void
ocs_session_abort_cmdsn(ocs_session_t *session,
            uint32_t       cmdsn)
{
    ocs_t *ocs = session->ocs;
    ocs_session_q_unsol_t *cmd_q;
    int32_t rc = -1;

    ocs_lock(&session->cmd_q_lock);
    ocs_list_foreach(&session->cmd_q_waiting, cmd_q) {
        if (cmd_q->cmd_sn <= cmdsn) {
            cmd_q->aborted  = TRUE;
            rc = 0;
        }
    }
    ocs_unlock(&session->cmd_q_lock);

    ocs_log_debug(ocs, "cmd_sn 0x%x aborted = %s for session instance %d\n",
              cmdsn,
              (rc == 0 ? "Yes" : "No"),
              session->instance_index);
}

/**
 * @brief Abort a specific IO based on the cmdSN of the abort request.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param cmdsn Any commands preceding this cmdSN are aborted.
 */
void
ocs_session_all_abort_cmdsn(ocs_iscsi_t *iscsi,
            uint32_t     cmdsn)
{
    ocs_session_t *session;

    ocs_lock(&iscsi->sess_queue_lock);
    ocs_list_foreach(&iscsi->sess_busy, session) {
        ocs_session_abort_cmdsn(session, cmdsn);
    }
    ocs_unlock(&iscsi->sess_queue_lock);
}


/**
 * @brief Generate node ddump data.
 *
 * @par Description
 * Generates the node ddump data.
 *
 * @param textbuf Pointer to text buffer.
 * @param cmd_q This queue contains the out-of-order commands for a session.
 *
 * @return None.
 */
static void
ocs_ddump_cmd_q(ocs_textbuf_t *textbuf, ocs_session_q_unsol_t *cmd_q)
{
    ocs_ddump_section(textbuf, "cmd_q", 0);

    ocs_ddump_value(textbuf, "cmd_sn", "0x%x", cmd_q->cmd_sn);
    ocs_ddump_value(textbuf, "code", "0x%x", cmd_q->code);
    ocs_ddump_value(textbuf, "aborted", "%d", cmd_q->aborted);

    ocs_ddump_endsection(textbuf, "cmd_q", 0);
}

/**
 * @brief Generate node ddump data.
 *
 * @par Description
 * Generates the node ddump data.
 *
 * @param textbuf Pointer to text buffer.
 * @param session Pointer to session.
 *
 * @return None.
 */
static void
ocs_ddump_session(ocs_textbuf_t *textbuf, ocs_session_t *session)
{
    ocs_session_q_unsol_t *cmd_q;

    ocs_ddump_section(textbuf, "session", session->instance_index);

    ocs_ddump_value(textbuf, "tgt_name", "%s", session->tgt_name);
    ocs_ddump_value(textbuf, "ini_name", "%s", session->ini_name);
    ocs_ddump_value(textbuf, "isid", "0x%" PRIx64 , session->isid);
    ocs_ddump_value(textbuf, "tsih", "0x%x", session->tsih);
    ocs_ddump_value(textbuf, "cmd_sn", "0x%x", session->cmd_sn);
    ocs_ddump_value(textbuf, "cmd_window", "0x%x", session->cmd_window);
    ocs_ddump_value(textbuf, "exp_cmd_sn", "0x%x", session->exp_cmd_sn);
    ocs_ddump_value(textbuf, "max_cmd_sn", "0x%x", session->max_cmd_sn);
    ocs_ddump_value(textbuf, "is_discovery_session", "%d", session->is_discovery_session);
    ocs_ddump_value(textbuf, "is_removed", "%d", session->is_removed);

    /* Session options */
    ocs_ddump_value(textbuf, "initial_r2t", "%d", session->login_options.initial_r2t);
    ocs_ddump_value(textbuf, "immediate_data", "%d", session->login_options.immediate_data);
    ocs_ddump_value(textbuf, "data_pdu_in_order", "%d", session->login_options.data_pdu_in_order);
    ocs_ddump_value(textbuf, "data_sequence_in_order", "%d", session->login_options.data_sequence_in_order);
    ocs_ddump_value(textbuf, "error_recovery_level", "%d", session->login_options.error_recovery_level);
    ocs_ddump_value(textbuf, "first_burst", "%d", session->login_options.first_burst);
    ocs_ddump_value(textbuf, "max_burst", "%d", session->login_options.max_burst);
    ocs_ddump_value(textbuf, "max_connections", "%d", session->login_options.max_connections);
    ocs_ddump_value(textbuf, "max_r2t", "%d", session->login_options.max_r2t);
    ocs_ddump_value(textbuf, "def_time_to_wait", "%d", session->login_options.def_time_to_wait);
    ocs_ddump_value(textbuf, "def_time_to_retain", "%d", session->login_options.def_time_to_retain);

    /* Print any queued commands */
    ocs_lock(&session->cmd_q_lock);
    ocs_ddump_value(textbuf, "cmd_q_num_queued", "%d", session->cmd_q_num_queued);
    ocs_list_foreach(&session->cmd_q_waiting, cmd_q) {
        ocs_ddump_cmd_q(textbuf, cmd_q);
    }
    ocs_unlock(&session->cmd_q_lock);

    ocs_ddump_endsection(textbuf, "session", session->instance_index);
}

/**
 * @brief Generate node ddump data.
 *
 * @par Description
 * Generates the node ddump data.
 *
 * @param textbuf Pointer to text buffer.
 * @param iscsi Pointer to the iscsi object.
 *
 * @return None.
 */
void
ocs_ddump_sessions(ocs_textbuf_t *textbuf, ocs_iscsi_t *iscsi)
{
    ocs_session_t *session;

    ocs_ddump_section(textbuf, "active_sessions", 0);

    ocs_lock(&iscsi->sess_queue_lock);
    ocs_list_foreach(&iscsi->sess_busy, session) {
        ocs_ddump_session(textbuf, session);
    }
    ocs_unlock(&iscsi->sess_queue_lock);

    ocs_ddump_endsection(textbuf, "active_sessions", 0);
}