ocs_iscsi.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
 * Implements the iSCSI interface functions.
 */

/**
 * @defgroup iscsi_main iSCSI API
 */

/**
 * @page iscsi_transport_api_overview Transport APIs and State Machine Functions
 * - @ref scsi_api_base
 * - @ref iscsi_main
 * - @ref cxn_mgnt
 * - @ref cxn_sm
 *
 * <div class="overview">
 * <img src="elx_iscsi_trans.jpg" alt="iSCSI Transport" title="iSCSI Transport" align="right"/>
 *
 * <h2>iSCSI Transport</h2>
 * Provides an abstracted SCSI interface to a back-end target and/or initiator.
 * This allows access to the functionality of the HAL while using a
 * transport agnostic API.
 * The iSCSI transport module interfaces with the iHAL and takes all
 * link/connection and unsolicited frame callbacks. It handles:
 *
 * <ul><li>TCP connections for both initiator and target functionality.</li>
 * <li>Discovery and operational logins to remote target nodes.</li>
 * <li>Accepts logins from remote initiators.</li></ul>
 *
 * The transport also performs the following:
 *
 * <ul><li>Exports target and initiator functions through the SCSI API.</li>
 * <li>Performs iSCSI logins with remote nodes.</li>
 * <li>Performs registration of the SLI Port with the HAL.</li>
 * <li>Processes text PDU negotiation for SendTargets.</li>
 * <li>Handles domain event callback notifications from the HAL.</li></ul>
 *
 * The iSCSI transport consists of the SCSI API, iSCSI API, link status handler components
 * connection (node) state machine, and unsolicited PDU handler.
 *
 * <h3>SCSI API</h3>
 * To enable the development of a SCSI initiator or target at a higher level than the
 * SLI-4 and HAL, entry points have been defined and implemented in an API that uses
 * SCSI semantics and concepts. For details on the SCSI API, see chapter 4, SCSI API, in the
 * <i><a href="../../../../../doc/ocs_reference_driver_manual.pdf" target="_blank">OneCore Storage Reference Driver Manual</a></i>.
 *
 * <h3>Link Status Handler</h3>
 * The link status handler provides the interface to the transport from the HAL's link
 * events. The only functionality in this handler is to begin the TCP/IP configuration once
 * the link is established. Nothing is done when the link is lost because the transport relies
 * on the TCP time-outs before tearing down any connections.
 *
 * <h3>Connection (Node) State Machine</h3>
 * The connection state machine implements the functions required to establish and maintain
 * connections with remote nodes. Each node object has its own fully independent state
 * machine instance. There are two node types that are created during the connection state
 * machine operation:
 *
 * <ul><li>Remote SCSI initiator nodes</li>
 * <li>Remote SCSI target nodes</li></ul>
 *
 * The general flow of a node in the connection state machine:
 *
 * <ol><li>The node is created and may transition to an initial state, depending on the type of
 * node.</li>
 * <li>Events are posted to the node state machine instance. For example, connection
 * events received.</li>
 * <li>The back-end components are notified of creation and deletion of nodes through
 * the domain portion of the SCSI API.</li></ol>
 *
 * <h3>Connection Event Handler</h3>
 * The connection handler provides the interface to the transport from the HAL's
 * connection events. These include:
 *
 * <ul><li>New target connection notifications</li>
 * <li>Connection Invalidation notifications</li>
 * <li>Target data digest notifications</li></ul>
 * On receipt of the connection event, it calls the appropriate handler function.
 *
 * <h3>Unsolicited PDU Handler</h3>
 * Unsolicited iSCSI PDUs are received, and passed up to a target-server using the SCSI API.
 * The unsolicited PDU handler provides the interface to the transport from the HAL's
 * unsolicited iSCSI PDU events. These include:
 *
 * <ul><li>iSCSI login PDUs</li>
 * <li>iSCSI text PDUs</li>
 * <li>iSCSI command PDUs</li>
 * <li>iSCSI task management PDUs</li>
 * <li>iSCSI NOP PDUs</li>
 * <li>iSCSI logout PDUs</li>
 * <li>iSCSI reject PDUs</li></ul>
 * On receipt of an Unsolicited PDU, the unsolicited PDU handler uses the TCP
 * connection to find a corresponding node object instance. Based on the type of PDU
 * received, the unsolicited PDU handler calls the appropriate handler function. In
 * general, the unsolicited PDU handler rarely makes any function or protocol decisions,
 * but merely dispatches PDUs to their respective handlers.
 *
 * <br><br>
 * </div><!-- overview -->
 */

#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_isns.h"
#include "ocs_login.h"
#include "ocs_session.h"
#include "ocs_cxn.h"
#include "sli4_iscsi.h"

#define IDLE_TIMER_MS (30 * 1000) /* 30 seconds */

static int32_t ocs_iscsi_hal_configure(ocs_iscsi_t *iscsi);
static int32_t ocs_iscsi_link_event_cb(void *arg, uint8_t isLinkUp);
static int32_t ocs_iscsi_cxn_event_cb(void *arg, ocs_hal_cxn_event_t *);
static int32_t ocs_iscsi_unsolicited_event_cb(void  *arg,
                          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);
#if defined(OCS_INCLUDE_DEBUG)
static void ocs_iscsi_dump_active_ios(ocs_iscsi_t *iscsi, ocs_cxn_t *cxn);
#endif


/**
 * @brief Allocates an iSCSI API context that provides a synchronous API
 *        when using a asynchronous mailbox command.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param index Index of the context to allocate.
 *
 * @return Returns pointer to the context if available, or NULL if it is in use.
 */
static ocs_config_ctx_t*
ocs_iscsi_ctx_alloc(ocs_iscsi_t *iscsi, ocs_config_ctx_e index)
{
    int value;
    ocs_config_ctx_t* rc = NULL;

    value = ocs_atomic_add_return(&iscsi->ctx[index].in_use, 1);
    if (value == 0) {
        rc = &iscsi->ctx[index];
    } else {
        (void)ocs_atomic_sub_return(&iscsi->ctx[index].in_use, 1);
    }
    return rc;
}

/**
 * @brief Waits on an iSCSI API context until the command completes or the
 *        timeout occurs.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param index Index of the context to free.
 * @param timeout_usec Timeout in microseconds.
 *
 * @return Returns 0 for success, or a negative value if the semaphore was not acquired.
 */
static int32_t
ocs_iscsi_ctx_wait(ocs_iscsi_t *iscsi, ocs_config_ctx_e index, int timeout_usec)
{
    int32_t rc = -1;
    int delay;

    if (iscsi->shutting_down) {
        /*
         * During shutdown, we have to assume that we are no longer
         * receiving interrupts, so call the HAL process function to
         * see if the command completes.
         */
        while (timeout_usec > 0) {
            ocs_hal_process(iscsi->hal,
                    0,
                    OCS_OS_MAX_ISR_TIME_MSEC);

            delay = MIN(timeout_usec, 1000);
            rc = ocs_sem_p(&iscsi->ctx[index].sem, delay);

            /* Exit if the command is complete */
            if (rc == 0) {
                break;
            }
            timeout_usec -= delay;
        }
    } else {
        rc = ocs_sem_p(&iscsi->ctx[index].sem, timeout_usec);
    }
    return rc;
}

/**
 * @brief Frees an iSCSI API context that provides a synchronous API
 *        when using a asynchronous mailbox command.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param index Index of the context to free.
 */
static void
ocs_iscsi_ctx_free(ocs_iscsi_t *iscsi, ocs_config_ctx_e index)
{
    (void)ocs_atomic_sub_return(&iscsi->ctx[index].in_use, 1);
}

/**
 * @brief Updates the status fields and post to the semaphore if it is still in use.
 *
 * @param ctx Pointer to the command context.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 */
static void
ocs_iscsi_ctx_post(ocs_config_ctx_t *ctx,
           int32_t status,
           uint32_t ext_status)
{
    int in_use = ocs_atomic_read(&ctx->in_use);

    if (in_use) {
        ctx->status = status;
        ctx->ext_status = ext_status;
        ocs_sem_v(&ctx->sem);
    }
}

/**
 * @brief Completes any active iSCSI API context when the device is being
 *        shut down.
 *
 * @param iscsi Pointer to the iSCSI object.
 *
 * @return Returns the pointer to the context if available, or NULL if it is in use.
 */
static void
ocs_iscsi_ctx_teardown(ocs_iscsi_t *iscsi)
{
    ocs_config_ctx_t *ctx;
    ocs_config_ctx_e index;
    int in_use;

    for (index = 0; index < OCS_CNFG_CTX_MAX; index++) {
        ctx = &iscsi->ctx[index];
        in_use = ocs_atomic_read(&ctx->in_use);
        if (in_use) {
            ocs_iscsi_ctx_post(ctx, -1, -1);
        }
    }
}

/**
 * @brief Convert an iSCSI IP type to the HAL value.
 *
 * @param ip_type iSCSI IP type to convert.
 *
 * @return Returns the HAL IP type or OCS_HAL_IP_TYPE_V4 if an invalid value is passed.
 */
ocs_hal_ip_type_e
ocs_iscsi_convert_to_hal_ip_type(ocs_ip_type_e ip_type)
{
    ocs_hal_ip_type_e rc = OCS_HAL_IP_TYPE_V4;

    switch (ip_type) {
    case OCS_IP_TYPE_V4:
        rc = OCS_HAL_IP_TYPE_V4;
        break;
    case OCS_IP_TYPE_DHCP_V4:
        rc = OCS_HAL_IP_TYPE_DHCP_V4;
        break;
    case OCS_IP_TYPE_V6:
        rc = OCS_HAL_IP_TYPE_V6;
        break;
    case OCS_IP_TYPE_AUTO_V6:
        rc = OCS_HAL_IP_TYPE_AUTO_V6;
        break;
    default:
        break;
    }
    return rc;
}

/**
 * @brief Convert an HAL IP type to the iSCSI API value.
 *
 * @param ip_type HAL IP type to convert.
 *
 * @return Returns the iSCSI IP type or OCS_IP_TYPE_V4 if an invalid value is passed.
 */
ocs_ip_type_e
ocs_iscsi_convert_to_ip_type(ocs_hal_ip_type_e ip_type)
{
    ocs_ip_type_e rc = OCS_IP_TYPE_V4;

    switch (ip_type) {
    case OCS_HAL_IP_TYPE_V4:
        rc = OCS_IP_TYPE_V4;
        break;
    case OCS_HAL_IP_TYPE_DHCP_V4:
        rc = OCS_IP_TYPE_DHCP_V4;
        break;
    case OCS_HAL_IP_TYPE_V6:
        rc = OCS_IP_TYPE_V6;
        break;
    case OCS_HAL_IP_TYPE_AUTO_V6:
    case OCS_HAL_IP_TYPE_ROUTABLE_V6:
    case OCS_HAL_IP_TYPE_LINK_LOCAL_V6:
        rc = OCS_IP_TYPE_AUTO_V6;
        break;
    default:
        break;
    }
    return rc;
}

/**
 * @brief Convert an iSCSI IP address to the HAL IP address
 *
 * @param ip Pointer to the iSCSI IP address.
 * @param hal_ip Pointer to the HAL IP address.
 */
void
ocs_iscsi_convert_to_hal_ip(ocs_ip_address_t *ip, ocs_hal_ip_address_t *hal_ip)
{
    hal_ip->ip_type = ocs_iscsi_convert_to_hal_ip_type(ip->ip_type);
    ocs_memcpy(hal_ip->ip_address, ip->ip_address, 16);
}

/**
 * @brief Convert an iSCSI IP address to the HAL IP address.
 *
 * @param ip Pointer to the iSCSI IP address.
 * @param hal_ip Pointer to the HAL IP address.
 */
void
ocs_iscsi_convert_to_ip(ocs_ip_address_t *ip, ocs_hal_ip_address_t *hal_ip)
{
    ip->ip_type = ocs_iscsi_convert_to_ip_type(hal_ip->ip_type);
    ocs_memcpy(ip->ip_address, hal_ip->ip_address, 16);
}

/**
 * @brief Convert an iSCSI IP address to the HAL IP address.
 *
 * @param ip Pointer to the iSCSI IP address.
 * @param hal_ip Pointer to the HAL IP address.
 */
static void
ocs_iscsi_convert_to_hal_ipsub(ocs_ip_address_subnet_t *ip, ocs_hal_ip_address_subnet_t *hal_ip)
{
    hal_ip->ip_type = ocs_iscsi_convert_to_hal_ip_type(ip->ip_type);
    ocs_memcpy(hal_ip->ip_address, ip->ip_address, 16);
    ocs_memcpy(hal_ip->subnet, ip->subnet, 16);
}

/**
 * @brief Convert an iSCSI IP address to the HAL IP address.
 *
 * @param ip Pointer to the iSCSI IP address.
 * @param hal_ip Pointer to the HAL IP address.
 */
static void
ocs_iscsi_convert_to_ipsub(ocs_ip_address_subnet_t *ip, ocs_hal_ip_address_subnet_t *hal_ip)
{
    ip->ip_type = ocs_iscsi_convert_to_ip_type(hal_ip->ip_type);
    ocs_memcpy(ip->ip_address, hal_ip->ip_address, 16);
    ocs_memcpy(ip->subnet, hal_ip->subnet, 16);
}

/**
 * @brief Combines an iSCSI IP address and subnet into the combined structure.
 *
 * @param ipsub Pointer to the combined iSCSI IP/subnet address.
 * @param ip Pointer to the IP address.
 * @param subnet Pointer to the IP subnet address.
 */
void
ocs_iscsi_ipsub_combine(ocs_ip_address_subnet_t *ipsub,
            ocs_ip_address_t *ip,
            ocs_ip_address_t *subnet)
{
    ipsub->ip_type = ip->ip_type;
    ocs_memcpy(ipsub->ip_address, ip->ip_address, ARRAY_SIZE(ipsub->ip_address));
    ocs_memcpy(ipsub->subnet, subnet->ip_address, ARRAY_SIZE(ipsub->subnet));
}

/**
 * @brief Splits an iSCSI IP address and subnet from the combined structure.
 *
 * @param ipsub Pointer to the combined iSCSI IP/subnet address.
 * @param ip Pointer to the IP address.
 * @param subnet Pointer to the IP subnet address.
 */
void
ocs_iscsi_ipsub_split(ocs_ip_address_subnet_t *ipsub,
              ocs_ip_address_t *ip,
              ocs_ip_address_t *subnet)
{
    ip->ip_type = ipsub->ip_type;
    ocs_memcpy(ip->ip_address, ipsub->ip_address, ARRAY_SIZE(ip->ip_address));

    subnet->ip_type = ip->ip_type;
    ocs_memcpy(subnet->ip_address, ipsub->subnet, ARRAY_SIZE(subnet->ip_address));
}

/**
 * @brief  Format an IP address into a string
 *
 * @par Description
 * Given a pointer to an IP address and a buffer, this function
 * writes the IP address into the buffer in human readable form.
 *
 * @param ip_type Enumerated type indicating the type of IP
 *      address (IPV4, IPV6, etc).
 * @param address Pointer to an array containing the IP address
 *      to be formatted. 4 bytes for IPV4, 16 bytes
 *      for IPV6.
 * @param buffer Pointer to the buffer into which the result
 *      will be placed.
 * @param size Size of the output buffer in bytes.
 *
 * @return None.
 */
void format_ip_address(ocs_ip_type_e ip_type, uint8_t *address, char* buffer, int size)
{
    uint32_t i;
    int pos = 0;

    if (ip_type == OCS_IP_TYPE_V4 ||
        ip_type == OCS_IP_TYPE_DHCP_V4) {
        /* Print the IP address in IPV4 format */
        ocs_snprintf(buffer, size, "%d.%d.%d.%d",
             address[0],
             address[1],
             address[2],
             address[3]);
    } else {
        /*
         * Print the IP address in IPV6 format.
         *
         * If the two byte piece is zero, then only print a single zero
         */
        for (i = 0; i < 15; i += 2) {
            if (address[i] != 0 || address[i + 1] != 0) {
                ocs_snprintf(&buffer[pos],
                         size - pos,
                         "%02x%02x",
                         address[i], address[i + 1]);
                pos += 4;
            } else {
                buffer[pos] = '0';
                pos++;
            }
            /* Print the colon if we are not at the end */
            if (i < 14) {
                buffer[pos] = ':';
                pos++;
            }
        }
        /*
         * The buffer may not be null terminated due to adding
         * characters (0 and :) so just terminate it now.
         */
        buffer[pos] = '\0';
    }
}

/**
 * @brief Converts an IPv4 address from a string to the IP structure.
 *
 * @param src Pointer to the ASCII IP address.
 * @param ip Pointer to a IP address structure.
 *
 * @return Returns 0 for a valid IP address.
 */
int32_t
ocs_iscsi_inet_pton4(const char * src, ocs_ip_address_t *ip)
{
    bool     have_digits   = FALSE;
    uint32_t src_index   = 0;
    uint32_t dest_index  = 0;
    uint32_t num_groups = 0;
    char     ch;

    ocs_memset(ip, 0, sizeof(ocs_ip_address_t));
    ip->ip_type = OCS_IP_TYPE_V4;

    while ((ch = src[src_index]) != '\0')
    {
        if (ch >= '0' && ch <= '9')
        {
            uint32_t new_val  = ((ip->ip_address[dest_index] * 10) +
                         (ch - '0'));

            if (have_digits && new_val == 0) {
                return -1;
            }
            if (new_val > 255) {
                return -1;
            }
            ip->ip_address[dest_index] = (uint8_t)new_val;
            if (!have_digits)
            {
                if (++num_groups > 4) {
                    return -1;
                }
                have_digits = TRUE;
            }
        }
        else if (ch == '.' && have_digits)
        {
            if (num_groups == 4) {
                return -1;
            }
            dest_index++;
            have_digits = FALSE;
        } else {
            return -1;
        }
        src_index++;
    }
    if (num_groups < 4) {
        return -1;
    }

    return 0;
}

/**
 * @brief Converts an IPv6 address from a string to the IP structure.
 *
 * @param src Pointer to the ASCII IP address.
 * @param ip Pointer to an IP address structure.
 *
 * @return Returns 0 for a valid IP address.
 */
int32_t
ocs_iscsi_inet_pton6(const char *src, ocs_ip_address_t *ip)
{
    uint32_t src_index   = 0;
    uint32_t dest_index  = 0;
    bool     have_digits = FALSE;
    const char *curtok;
    uint8_t    *colonp;
    char ch;
    uint32_t val;
    ocs_ip_address_t ipv4;

    ocs_memset(ip, 0, sizeof(ocs_ip_address_t));
    ip->ip_type = OCS_IP_TYPE_V6;
    colonp = NULL;

    /* Leading :: requires some special handling. */
    if (src[src_index] == ':') {
        src_index++;
        if (src[src_index] != ':') {
            return -1;
        }
    }

    curtok = &src[src_index];
    have_digits = FALSE;
    val = 0;
    while ((ch = src[src_index]) != '\0')
    {
        int32_t digit = -1;

        src_index++;
        if (ch >= '0' && ch <= '9'){
            digit = (ch - '0');
        } else if (ch >= 'A' && ch <= 'F') {
            digit = 10 + (ch - 'A');
        } else if (ch >= 'a' && ch <= 'f') {
            digit = 10 + (ch - 'a');
        }
        if (digit != -1)
        {
            val <<= 4;
            val |= digit;
            if (val > 0xffff) {
                return -1;
            }
            have_digits = TRUE;
            continue;
        }

        if (ch == ':') {
            curtok = &src[src_index];
            if (!have_digits) {
                if (colonp) {
                    return -1;
                }
                colonp = &ip->ip_address[dest_index];
                continue;
            }
            else if (src[src_index] == '\0') {
                return -1;
            }

            if (dest_index > 16) {
                return -1;
            }
            ip->ip_address[dest_index++] = (val >> 8) & 0xff;
            ip->ip_address[dest_index++] = val & 0xff;
            have_digits = FALSE;
            val = 0;
            continue;
        }

        if (ch == '.' && ((dest_index  + 4) <= 16) &&
            ocs_iscsi_inet_pton4(curtok, &ipv4) == 0)
        {
            ocs_memcpy(&ip->ip_address[dest_index], ipv4.ip_address, 4);
            dest_index += 4;
            have_digits = FALSE;
            break;        /* '\0' was seen by inet_pton4(). */
        }
        return -1;
    }

    if (have_digits) {
        if (dest_index + 2 > 16) {
            return -1;
        }
        ip->ip_address[dest_index++] = (val >> 8) & 0xff;
        ip->ip_address[dest_index++] = val & 0xff;
    }

    if (colonp != NULL)
    {
        /*
         * Since some memmove()'s erroneously fail to handle
         * overlapping regions, we'll do the shift by hand.
         */
        uint32_t n = (uint32_t)(&ip->ip_address[dest_index] - colonp);
        uint32_t i;

        if (dest_index == 16) {
            return -1;
        }

        for (i = 1; i <= n; i++)
        {
            ip->ip_address[16 - i] = colonp[n - i];
            colonp[n - i] = '\0';
        }
        dest_index = 16;
    }
    if (dest_index != 16) {
        return -1;
    }

    return 0;
}

/**
 * @brief  Format a MAC address into a string.
 *
 * @par Description
 * Given a pointer to a MAC address and a buffer, this function
 * writes the MAC address into the buffer in human readable
 * form.
 * @n @n
 * @b Note: To avoid truncation, the output buffer must be at
 * least 18 bytes long.
 *
 * @param address Pointer to an array of 6 bytes containing the
 *            MAC address.
 * @param buffer Pointer to the buffer into which the result
 *           will be placed.
 * @param size Size of the output buffer in bytes.
 *
 * @return None.
 */
void format_mac_address(uint8_t *address, char* buffer, int size)
{
    ocs_snprintf(buffer, size, "%02x:%02x:%02x:%02x:%02x:%02x",
             address[0], address[1],
             address[2], address[3],
             address[4], address[5]);
}

/**
 * @brief  Parse a string into a MAC address.
 *
 * @par Description
 * This function parses a human readable MAC address into an
 * array of 6 bytes.
 * @n @n
 * The input should be a string of six two-digit hex numbers,
 * optionally separated by - or :. If the input string is not
 * in one of these formats the results are undefined.
 *
 * @param src Pointer to the input string.
 * @param dest Pointer to an array of at least 6 bytes in
 *             which the MAC address will be stored.
 *
 * @return Returns 0 on success; or -1 if the string does not
 *         represent a valid MAC address.
 */
int32_t parse_mac_address(const char *src, uint8_t *dest)
{
    char src_byte[3];
    const char *src_p;
    uint8_t *dest_p;
    unsigned long value;
    int byte;

    /*
     * Validate the size of the input string.  It should be exactly 12
     * bytes if there are no separators between the bytes or 17 bytes if
     * there are separators.
     */

    if ((ocs_strlen(src) != 12) && (ocs_strlen(src) != 17)) {
        return -1;
    }

    src_p = src;
    dest_p = dest;
    for (byte=0; byte<6; byte++) {
        src_byte[0] = *src_p++;
        src_byte[1] = *src_p++;
        src_byte[2] = '\0';
        value = ocs_strtoul(src_byte, NULL, 16);
        *dest_p++ = (uint8_t)value;
        if ((*src_p == ':') || (*src_p == '-')) {
            ++src_p;
        }
    }

    return 0;

}


/**
 * @brief Attempts to send an asynchronous message to request the initiator
 *        to logout.
 *
 * @param cxn Pointer to the connection object.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_cxn_request_logout(ocs_cxn_t *cxn)
{
    ocs_t  *ocs = cxn->ocs;
    ocs_session_t  *session = cxn->session;
    int32_t rc = 0;

    if (cxn->cxn_state == CONN_STATE_FULL_FEATURE) {
        if (session != NULL && session->is_discovery_session) {
            /* just close the connection for discovery */
            ocs_log_test(ocs, "Error on discovery connection %s, closing\n",
                     cxn->display_name);
            ocs_cxn_close(cxn, FALSE);
        } else {
            ocs_log_debug(ocs, "Request logout for %s\n", cxn->display_name);

            rc = ocs_iscsi_send_async(cxn, NULL, 0, ASYNC_EVENT_CONN_CLOSE,
                          0, cxn->cid, OCS_ISCSI_LOGIN_DEFAULT_TIME_2_WAIT,
                          OCS_ISCSI_LOGIN_DEFAULT_TIME_2_RETAIN);
            if (rc == 0) {
                cxn->cxn_state = CONN_STATE_LOGOUT_REQUESTED;
            }
        }
    } else {
        ocs_log_debug(ocs, "state %d do not request logout for %s\n",
                  cxn->cxn_state, cxn->display_name);
    }

    return rc;
}

/**
 * @brief This function is called to check for idle connections.
 *
 * @param arg Pointer to the iscsi object.
 */
static void
ocs_iscsi_idle_timeout(void *arg)
{
    ocs_iscsi_t *iscsi = arg;
    ocs_t       *ocs   = iscsi->os;
    ocs_cxn_t   *cxn, *cxn_next;
    uint32_t     uerr_lo;
    uint32_t     uerr_hi;
    uint32_t     uerr_mask_lo;
    uint32_t     uerr_mask_hi;
    ocs_sli_port_t *sport;

    /*
     * Use this thread to monitor the error status registers. if a UE is
     * detected, then dump all the IOs.
     */
    uerr_lo = sli_reg_read(&iscsi->hal->sli, SLI4_REG_UERR_STATUS_LO);
    uerr_hi = sli_reg_read(&iscsi->hal->sli, SLI4_REG_UERR_STATUS_HI);
    uerr_mask_lo = sli_reg_read(&iscsi->hal->sli, SLI4_REG_UERR_MASK_LO);
    uerr_mask_hi = sli_reg_read(&iscsi->hal->sli, SLI4_REG_UERR_MASK_HI);
    if (!iscsi->has_ue_occurred &&
        (((uerr_lo & ~uerr_mask_lo) != 0) || ((uerr_hi & ~uerr_mask_hi) != 0))) {
        iscsi->has_ue_occurred = TRUE;
        ocs_log_crit(iscsi->os, "Error: uerr_hi: 0x%08x (0x%08x) uerr_lo: 0x%08x (0x%08x)\n",
                 uerr_hi, uerr_mask_hi, uerr_lo, uerr_mask_lo);
#if defined(OCS_INCLUDE_DEBUG)
        ocs_domain_lock(ocs->hal.domain);
        ocs_list_foreach(&ocs->hal.domain->sport_list, sport) {
            ocs_sport_lock(sport);
            ocs_list_foreach(&sport->node_list, cxn) {
                ocs_iscsi_dump_active_ios(iscsi, cxn);
            }
            ocs_sport_unlock(sport);
        }
        ocs_domain_unlock(ocs->hal.domain);
#endif
    }



    if (!iscsi->shutting_down) {
        ocs_domain_lock(ocs->hal.domain);
        ocs_list_foreach(&ocs->hal.domain->sport_list, sport) {
            ocs_sport_lock(sport);
            ocs_list_foreach_safe(&sport->node_list, cxn, cxn_next) {
                if (cxn->no_idle_timer) {
                    continue;
                }
                cxn->idle_count++;
                if (cxn->idle_count > 4 &&
                    cxn->cxn_state != CONN_STATE_CLEANUP &&
                    cxn->cxn_state != CONN_STATE_FREE) {
                    ocs_log_debug(iscsi->os, "killing idle connection%s\n", cxn->display_name);
                    ocs_cxn_close(cxn, TRUE);
                } else if (cxn->cxn_state == CONN_STATE_FULL_FEATURE) {
                    /*
                     * For initiators, wait for 1 1/2 minutes before
                     * sending a nop (3 timer pops).
                     *
                     * For targets, wait 2 minutes, 4 pops.
                     */
                    if (cxn->is_ini_cxn) {
                        if (cxn->idle_count == 3) {
                            /* Send a nop-out (initiator) */
                            if (ocs_iscsi_send_nop_out(cxn,
                                    ocs_be64toh(0),
                                    0,
                                    0xffffffff,
                                    NULL,
                                    0)) {
                                ocs_log_test(iscsi->os, "sending nop-out failed\n");
                            } else {
                                cxn->idle_count--;
                            }
                        }
                        /* Only target connections */
                    } else if (cxn->idle_count == 4) {
                        /* Send a nop-in (target) */
                        if (ocs_iscsi_send_nop_in(cxn,
                                      ocs_be64toh(0),
                                      0xffffffff,
                                      (1 << 31) | cxn->wq_index,
                                      NULL,
                                      0)) {
                            ocs_log_test(iscsi->os, "sending nop-in failed\n");
                        } else {
                            cxn->idle_count--;
                        }
                    }
                }
            }
            ocs_sport_unlock(sport);
        }
        ocs_domain_unlock(ocs->hal.domain);

        ocs_setup_timer(ocs, &iscsi->idle_timer,
                ocs_iscsi_idle_timeout,
                iscsi,
                IDLE_TIMER_MS, false);
    }
}

/**
 * @brief This function is the callback a general API context command.
 *
 * @param ul_arg Pointer to the iscsi object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params Points to the command parameters.
 */
static void ocs_iscsi_ctx_general_cb(void *ul_arg,
                     int32_t status,
                     uint32_t ext_status,
                     void      * params)
{
    ocs_config_ctx_t *ctx = ul_arg;

    ocs_iscsi_ctx_post(ctx, status, ext_status);
}


/**
 * @brief This function is the callback for the iSNS server IP addresses.
 *
 * @param ul_arg Pointer to the iscsi object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params Pointer to ocs_hal_ip_address_subnet_t.
 */
static void ocs_iscsi_isns_discover_cb(void *ul_arg,
                       int32_t status,
                       uint32_t ext_status,
                       void   * params)
{
    ocs_config_ctx_t *ctx = ul_arg;
    int in_use = ocs_atomic_read(&ctx->in_use);
    ocs_hal_ip_address_t *isns_servers = params;
    ocs_ip_address_t ip;
    uint32_t indx;

    ctx->num_ips = 0;

    if (in_use) {
        if (status == 0 && isns_servers != NULL) {
            for (indx = 0; indx < 8; indx++) {
                if (isns_servers[indx].ip_type != 0) {
                    ocs_iscsi_convert_to_ip(&ip,
                                &isns_servers[indx]);
                    ctx->ip[ctx->num_ips] = ip;
                    ctx->num_ips++;
                    if (ctx->num_ips == ARRAY_SIZE(ctx->ip) - 1) {
                        break;
                    }
                }
            }
        }
        ocs_iscsi_ctx_post(ctx, status, ext_status);
    }
}


/**
 * @brief This function is the callback for the iSNS send.
 *
 * @param ul_arg Pointer to the iscsi object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params Pointer to ocs_hal_ip_address_subnet_t.
 */
static void ocs_iscsi_isns_send_cb(void *ul_arg,
                   int32_t status,
                   uint32_t ext_status,
                   void   * params)
{
    ocs_config_ctx_t *ctx = ul_arg;
    int in_use = ocs_atomic_read(&ctx->in_use);
    uint16_t *word = params;

    /*
     * Build an iSNS PDU in big endian format
     *   Byte   MSb                        LSb
     *   Offset 0           15 16           31
     *      +---------------------+----------------------+
     *    0 |   iSNSP VERSION     |    FUNCTION ID   | 4 Bytes
     *      +---------------------+----------------------+
     *    4 |     PDU LENGTH      |   FLAGS      | 4 Bytes
     *      +---------------------+----------------------+
     *    8 |   TRANSACTION ID    |    SEQUENCE ID   | 4 Bytes
     *      +---------------------+----------------------+
     *   12 |                        |
     *      |            PDU PAYLOAD         | N Bytes
     *      |            ...             |
     *      +--------------------------------------------+
     *     12+N | AUTHENTICATION BLOCK (Multicast/Broadcast) | L Bytes
     *      +--------------------------------------------+
     */
    if (in_use) {
        ctx->isns_pkt_len = 0;
        ctx->num_ips = 0;
        if (status == 0 && word != NULL) {
            ctx->isns_pkt_len = 12 + ocs_be16toh(word[2]);
            if (ctx->isns_pkt_len > 0) {
                ocs_memcpy(ctx->isns_pkt,
                       word,
                       (ctx->isns_pkt_len > ctx->isns_buff_len ? ctx->isns_buff_len : ctx->isns_pkt_len));
            }
        }
        ocs_iscsi_ctx_post(ctx, status, ext_status);
    }
}

/**
 * @brief Starts an iSNS ESI TCP listen socket.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ip IP address to listen on.
 * @param tcp_port TCP port number to listen on.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_isns_esi_listen_start(ocs_t *ocs, ocs_ip_address_t *ip,
                    uint16_t tcp_port)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_LISTEN_START);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(ip, &hal_ip);
        rc = ocs_hal_portal_esi_listen_start(iscsi->hal,
                             &hal_ip,
                             tcp_port,
                             ocs_iscsi_ctx_general_cb,
                             ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed Starting ESI Listen\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_LISTEN_START,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_debug(iscsi->os, "starting ESI listen status 0x%x ext status 0x%x\n",
                              ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_LISTEN_START);
    }

    return rc;

}


/**
 * @brief Stops an iSNS ESI TCP listen socket.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ip IP address to listen on.
 * @param tcp_port TCP port number to listen on.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_isns_esi_listen_stop(ocs_t *ocs, ocs_ip_address_t *ip,
                       uint16_t tcp_port)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_LISTEN_STOP);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(ip, &hal_ip);
        rc = ocs_hal_portal_esi_listen_stop(iscsi->hal,
                            &hal_ip,
                            tcp_port,
                            ocs_iscsi_ctx_general_cb,
                            ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed Stopping ESI Listen\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_LISTEN_STOP,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "stopping ESI listen status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_LISTEN_STOP);
    }

    return rc;
}


/**
 * @brief Discovers the iSNS through the DHCP service.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param portal Portal to use.
 * @param max_entries Maximum number of entries to be returned.
 * @param num_ips Actual number of entries returned.
 * @param ip IP address to listen on.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_isns_discover(ocs_t *ocs, ocs_hal_portal_t portal,
                uint32_t max_entries,
                uint32_t *num_ips,
                ocs_ip_address_t *ip)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_ISNS_DISC);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_isns_discover(iscsi->hal,
                          portal,
                          ocs_iscsi_isns_discover_cb,
                         ctx);

        if (rc) {
            ocs_log_test(iscsi->os, "iSNS Discover failed\n");
        } else {
            /* Bug 146254 - Use a 6 minute timeout */
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_ISNS_DISC,
                        6 * 60 * 1000000);
            if (rc == 0) {
                if (ctx->status == 0 &&
                    ctx->ext_status == 0) {
                    *num_ips = MIN(ctx->num_ips, max_entries);
                    ocs_memcpy(ip, ctx->ip,
                           sizeof(ocs_ip_address_t) * *num_ips);
                } else {
                    rc = -1;
                    ocs_log_test(iscsi->os, "iSNS Discover status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_ISNS_DISC);
    }

    return rc;
}


/**
 * @brief Sends an iSNS packet to a server to test the interface.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param isns_server IP address of the iSNS server.
 * @param tcp_port TCP port number.
 * @param buffer Pointer to the virtual address of the iSNS buffer. This
 *               buffer is used for both the request and response.
 * @param pkt_len Length of the packet and returns the length of the response.
 * @param buff_len Length of the buffer. Used to truncate the response if required.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_isns_send(ocs_t *ocs,
                ocs_ip_address_t *isns_server,
                uint32_t tcp_port,
                void *buffer, uint32_t *pkt_len, uint32_t buff_len)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_ISNS_SEND);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(isns_server, &hal_ip);
        ctx->isns_pkt = buffer;
        ctx->isns_pkt_len = *pkt_len;
        ctx->isns_buff_len = buff_len;
        rc = ocs_hal_portal_isns_send_packet(iscsi->hal,
                             &hal_ip,
                             tcp_port,
                             buffer,
                             *pkt_len,
                             ocs_iscsi_isns_send_cb,
                             ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "iSNS Send failed\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_ISNS_SEND,
                        12 * 1000000);
            if (rc == 0) {
                if (ctx->status == 0 &&
                    ctx->ext_status == 0) {
                    *pkt_len = ctx->isns_pkt_len;
                } else {
                    rc = -1;
                    ocs_log_test(iscsi->os, "iSNS Send status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_ISNS_SEND);
    }

    return rc;
}


/**
 * @brief This function is the callback for querying IP addresses.
 *
 * @param ul_arg Pointer to the iSCSI object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params Pointer to ocs_hal_ip_address_subnet_t.
 */
static void ocs_iscsi_query_ip_cb(void *ul_arg,
                  int32_t status,
                  uint32_t ext_status,
                  void    * params)
{
    ocs_config_ctx_t *ctx = ul_arg;
    ocs_hal_get_ip_t *rtn = params;
    uint32_t     i;

    ctx->num_ips = 0;
    if (status == 0) {
        ctx->num_ips = MIN(rtn->ip_count, ARRAY_SIZE(rtn->ipsub));
        for (i=0; i < ctx->num_ips; i++) {
            ocs_iscsi_convert_to_ipsub(&ctx->ipsub[i], &rtn->ipsub[i]);
        }
    }
    ocs_iscsi_ctx_post(ctx, status, ext_status);
}


/**
 * @brief Sets the MAC address of the iSCSI device.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param mac_address Pointer to the MAC address value.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_mac_set(ocs_t *ocs, uint8_t *mac_address)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_config_ctx_t* ctx;
    int32_t rc = -1;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_SET_MAC);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_set_mac(iscsi->hal,
                        mac_address,
                        ocs_iscsi_ctx_general_cb,
                        ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed setting MAC address\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_SET_MAC,
                        1 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "setting MAC address status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_MAC);
    }
    return rc;
}

/**
 * @brief Gets the MAC address of the iSCSI device.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 *
 * @return Returns a pointer to an array of 6 bytes containing
 *         the MAC address of the interface.
 */
uint8_t *ocs_iscsi_mac_get(ocs_t *ocs)
{
    return ocs_hal_get_ptr(&ocs->hal, OCS_HAL_MAC_ADDR);
}

/**
 * @brief This function prints the module parameters to the log for
 *        debugging purposes.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 */
static void ocs_iscsi_print_module_params(ocs_iscsi_t *iscsi)
{
    ocs_t *ocs = iscsi->os;
#if defined(OCS_INCLUDE_RAMD)
    char buffer[32];
#endif

    ocs_log_debug(ocs, "Module parameters:\n");
    ocs_log_debug(ocs, "  Initiator=%d\n", ocs->enable_ini);
    ocs_log_debug(ocs, "  Target=%d\n", ocs->enable_tgt);
    ocs_log_debug(ocs, "  ctrlmask=%d\n", ocs->ctrlmask);
    ocs_log_debug(ocs, "  loglevel=%d\n", loglevel);
    ocs_log_debug(ocs, "  enable_sgl_chaining=%d\n", ocs->enable_sgl_chaining);
    ocs_log_debug(ocs, "  enable_immediate_data=%d\n", ocs->enable_immediate_data);
    ocs_log_debug(ocs, "  enable_hdr_digest=%d\n", ocs->enable_hdr_digest);
    ocs_log_debug(ocs, "  enable_data_digest=%d\n", ocs->enable_data_digest);
    ocs_log_debug(ocs, "  enable_jumbo_frame=%d\n", ocs->enable_jumbo_frame);
    ocs_log_debug(ocs, "  max_sge_size=%d\n", ocs->max_sge_size);
    ocs_log_debug(ocs, "  post_sgl_config=%d\n", ocs->post_sgl_config);

#if defined(OCS_INCLUDE_RAMD)
    ocs_get_property("ramdisc_blocksize", buffer, sizeof(buffer));
    ocs_log_debug(ocs, "  ramdisc_blocksize=%s\n", buffer);
    ocs_get_property("ramdisc_size", buffer, sizeof(buffer));
    ocs_log_debug(ocs, "  ramdisc_size=%s\n", buffer);
    ocs_get_property("p_type", buffer, sizeof(buffer));
    ocs_log_debug(ocs, "  p_type=%s\n", buffer);
    ocs_get_property("num_luns", buffer, sizeof(buffer));
    ocs_log_debug(ocs, "  num_luns=%s\n", buffer);
#endif

    ocs_log_debug(ocs, "  num_scsi_ios=%d\n", ocs->num_scsi_ios);
    ocs_log_debug(ocs, "  local_ip=%s\n", ocs->local_ip);
    ocs_log_debug(ocs, "  local_subnet=%s\n", ocs->local_subnet);
    ocs_log_debug(ocs, "  gateway=%s\n", ocs->gateway);
    ocs_log_debug(ocs, "  tcp_window_size=%d\n", ocs->tcp_window_size);
    ocs_log_debug(ocs, "  tcp_window_scale=%d\n", ocs->tcp_window_scale);
    ocs_log_debug(ocs, "  iqn_prefix=%s\n", ocs->iqn_prefix);
    ocs_log_debug(ocs, "  iqn_suffix=%s\n", ocs->iqn_suffix);
}


#if defined(OCS_INCLUDE_RAMD)
/**
 * @ingroup iscsi_main
 * @brief Configures the ramdisc specific parameters through the iSCSI API.
 *
 * @par Description
 * This function configures the target names and CHAP secrets via the iSCSI API.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_ramd_configure(ocs_t *ocs)
{
    char tgt_name[OCS_MAX_ISCSI_NAME];
    char tgt_alias[OCS_ISCSI_MAX_ALIAS_SIZE];
    uint8_t *mac;
    uint32_t i;
    uint32_t rc = 0;

    mac = ocs_hal_get_ptr(&ocs->hal, OCS_HAL_MAC_ADDR);

    for (i=0; i < ocs->num_tgts; i++) {
        if (0 == strncmp(ocs->iqn_suffix, OCS_IQN_SUFFIX_DEFAULT, 7))
            snprintf(tgt_name,
                 OCS_MAX_ISCSI_NAME,
                 "%s:%02x%02x%02x%02x%02x%02x:tgt%d.disk%d",
                 ocs->iqn_prefix,
                 mac[0], mac[1],mac[2],mac[3],mac[4],mac[5],
                 ocs->instance_index,
                 i);
        else
            snprintf(tgt_name,
                 OCS_MAX_ISCSI_NAME,
                 "%s:%s.disk%d",
                 ocs->iqn_prefix, ocs->iqn_suffix, i);
        snprintf(tgt_alias,
             OCS_ISCSI_MAX_ALIAS_SIZE,
             "%s:tgt%d.ramdisc%d",
             ocs->iqn_prefix+16,
             ocs->instance_index,
             i);
        if (ocs_iscsi_tgt_add(ocs, tgt_name, tgt_alias)) {
            ocs_log_test(ocs, "Error adding target name %s\n", tgt_name);
            rc = -1;
        }
    }

    if (ocs_is_target_enabled()) {
        if (ocs_iscsi_chap_user_add(ocs, "EmulexTgt", "ElxTgtPassword",
                        OCS_CHAP_TYPE_INCOMING,
                        OCS_CHAP_MODE_TARGET)) {
            ocs_log_err(ocs, "Error adding target CHAP credentials\n");
            rc = -1;
        }

        if (ocs_iscsi_chap_user_add(ocs, "EmulexTgtMutual",
                        "ElxTgtPassMutual", OCS_CHAP_TYPE_OUTGOING,
                        OCS_CHAP_MODE_TARGET)) {
            ocs_log_err(ocs, "Error adding target CHAP credentials\n");
            rc = -1;
        }
    }

    return rc;
}
#endif

/**
 * @ingroup iscsi_main
 * @brief Returns the number of interrupts needed for this adapter.
 *
 * @par Description
 * This function queries the chip and determine the number of chutes. An
 * interrupt will be requested for each chute.
 *
 * @param os Pointer to the os structure that represents this device.
 * @param hal Pointer to the hal structure. Allocated in the OS specific
 * code due to ties to the hardware interrupt.
 *
 * @return Returns the number of interrupts required, or a negative value on failure.
 */
int32_t
ocs_iscsi_interrupts_required(ocs_os_handle_t os, ocs_hal_t *hal)
{
    ocs_t *ocs = os;
    int32_t rc = 0;
    sli4_port_type_e port_type;
    uint32_t num_chutes = 0;

    if (ocs_is_initiator_enabled() && ocs_is_target_enabled()) {
        port_type = SLI4_PORT_TYPE_ISCSI_BOTH;
        ocs_log_debug(os, "INI/TGT enabled\n");
    } else if (ocs_is_initiator_enabled()) {
        port_type = SLI4_PORT_TYPE_ISCSI_INI;
        ocs_log_debug(os, "INI enabled\n");
    } else {
        port_type = SLI4_PORT_TYPE_ISCSI_TGT;
        ocs_log_debug(os, "TGT enabled\n");
    }

    if ((rc = ocs_hal_setup(hal, os, port_type))) {
        ocs_log_err(os, "ocs_hal_setup failed\n");
        return -1;
    }
    ocs_hal_get(hal, OCS_HAL_NUM_CHUTES, &num_chutes);

    return num_chutes + 1;
}


/**
 * @ingroup iscsi_main
 * @brief Initialize the iSCSI device by setting up the chip.
 *
 * @par Description
 * This function initializes the chip and creates the necessary queues and
 * buffers.
 *
 * @param os Pointer to the os structure that represents this device.
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param hal Pointer to the hal structure. Allocated in the OS specific
 * code due to ties to the hardware interrupt.
 * @param device_instance Counter of the number of devices. Used to build
 * target names when non-global ramdisk is used.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_iscsi_initialize(ocs_os_handle_t os, ocs_iscsi_t *iscsi, ocs_hal_t *hal,
             uint32_t device_instance) {
    ocs_t *ocs = os;
    int32_t rc = 0;
    uint32_t i;
    uint8_t scsi_domains_added = FALSE;
    uint8_t scsi_sports_added = FALSE;
    uint8_t hal_sports_added = FALSE;
    uint8_t login_initialized = FALSE;
    uint8_t cxn_initialized = FALSE;
    uint8_t sess_initialized = FALSE;
    uint8_t isns_initialized = FALSE;
    uint8_t api_initialized = FALSE;
    uint32_t max_sgl;
    uint32_t ocs_chaining_enable;

    /* booleans used for cleanup if initialization fails */
    uint8_t ini_device_set = FALSE;
    uint8_t tgt_device_set = FALSE;

    iscsi->os  = os;
    iscsi->hal = hal;
    iscsi->device_instance = device_instance;

    iscsi->ip_info = ocs_malloc(os, sizeof(*iscsi->ip_info) * OCS_MAX_IP,
                    OCS_M_ZERO | OCS_M_NOWAIT);
    if (iscsi->ip_info == NULL) {
        ocs_log_err(os, "Failed to allocated ip_info lookup table\n");
        return -ENOMEM;
    }

    ocs_memset(iscsi->link_state_callbacks, 0, sizeof(iscsi->link_state_callbacks));
    ocs_lock_init(iscsi->os, &iscsi->link_state_cb_lock, "ocs_iscsi_cb_lock[%d]", ocs_instance(os));

    /*
     * Initialize the API context structures.
     */
    iscsi->ctx = ocs_malloc(os, sizeof(*iscsi->ctx) * OCS_CNFG_CTX_MAX,
                OCS_M_ZERO | OCS_M_NOWAIT);
    if (iscsi->ctx == NULL) {
        ocs_log_err(os, "Failed to allocated API contexts structures\n");
        rc = -1;
        goto exit_free_all;
    }

    for (i = 0; i < OCS_CNFG_CTX_MAX; i++) {
        iscsi->ctx[i].iscsi = iscsi;
        ocs_atomic_init(&iscsi->ctx[i].in_use, 0);
        ocs_sem_init(&iscsi->ctx[i].sem, 0, "api_ctx:%d", i);
    }

    if (ocs_is_target_enabled()) {
        if (ocs->num_tgts > OCS_MAX_SPORTS) {
            ocs_log_warn(iscsi->os, "set max_tgts to %d (exceeded Max)",
                     OCS_MAX_SPORTS);
            ocs->num_tgts = iscsi->num_tgts = OCS_MAX_SPORTS;
        } else {
            iscsi->num_tgts = ocs->num_tgts;
            ocs_log_debug(iscsi->os, "set max_tgts to %d", ocs->num_tgts);
            if (ocs->num_tgts == 0) {
                ocs_log_test(iscsi->os, "ERROR: Number of targets is zero");
                rc = -1;
                goto exit_free_all;
            }
        }
    } else {
        iscsi->num_tgts = 1;
    }

    /* Print module parameters for debugging */
    ocs_iscsi_print_module_params(iscsi);

    /*
     * This code has been temporarily moved to ocs_iscsi_interrupts_required().
     * That function needs to know if the chip supports dual chute, so it has to
     * setup HAL.  Because that function is called by ocs_pci_probe() before
     * calling ocs_device_attach, the HAL will already be setup by the time we get
     * here.
     *
     * {
     *  sli4_port_type_e port_type;
     *
         *  if (ocs_is_initiator_enabled() && ocs_is_target_enabled()) {
         *          port_type = SLI4_PORT_TYPE_ISCSI_BOTH;
         *  } else if (ocs_is_initiator_enabled()) {
         *          port_type = SLI4_PORT_TYPE_ISCSI_INI;
         *  } else {
     *          port_type = SLI4_PORT_TYPE_ISCSI_TGT;
     *      }
         * }
         *
         * if ((rc = ocs_hal_setup(hal, os, port_type))) {
         *         ocs_log_err(iscsi->os, "ocs_hal_setup failed\n");
         * }
     */

    if (!rc) {
        if ((rc = ocs_iscsi_hal_configure(iscsi))) {
            ocs_log_err(iscsi->os, "ocs_iscsi_hal_configure failed\n");
            goto exit_free_all;
        }
    }

    if (!rc) {
        if ((rc = ocs_iscsi_login_initialize(iscsi))) {
            ocs_log_err(iscsi->os, "ocs_iscsi_login_initialize failed\n");
            goto exit_free_all;
        } else {
            login_initialized = TRUE;
        }
    }

    if (!rc) {
        /* Make sure to have equal/lesser number of SGEs as
         * we've configured in initiator mid-layer. */
        ocs_hal_get(hal, OCS_HAL_NUM_SGES_PER_ICD, &max_sgl);
        ocs_hal_get(hal, OCS_HAL_SGL_CHAINING_ENABLE, &ocs_chaining_enable);
        if (ocs_chaining_enable) {
            /* SGL chaining mode, use default SGL count. */
            max_sgl = OCS_DEFAULT_SGL_COUNT;
        }
        ocs->io_pool = ocs_io_pool_create(ocs, ocs->num_scsi_ios, MIN(64, max_sgl));
        if (ocs->io_pool == NULL) {
            rc = -1;
            goto exit_free_all;
        }

        ocs_list_init(&ocs->io_pending_list, ocs_io_t, io_pending_link);
        ocs_atomic_init(&ocs->io_active_count, 0);
        ocs_atomic_init(&ocs->io_pending_count, 0);
        ocs_atomic_init(&ocs->io_total_free, 0);
        ocs_atomic_init(&ocs->io_total_pending, 0);
        ocs_atomic_init(&ocs->io_pending_recursing, 0);
    }


    if (!rc) {
        if ((rc = ocs_iscsi_api_initialize(ocs))) {
            ocs_log_err(iscsi->os, "ocs_iscsi_api_initialize failed\n");
        } else {
            api_initialized = TRUE;
#if defined(OCS_INCLUDE_RAMD)
            if (ocs_iscsi_ramd_configure(ocs)) {
                ocs_log_err(iscsi->os, "ocs_iscsi_ramd_configure failed\n");
                goto exit_free_all;
            }
#endif
        }
    }

    if (!rc) {
        if ((rc = ocs_cxn_initialize(iscsi))) {
            ocs_log_err(iscsi->os, "ocs_cxn_initialize failed\n");
            goto exit_free_all;
        } else {
            cxn_initialized = TRUE;
        }
    }

    if (!rc) {
        if ((rc = ocs_session_initialize(iscsi))) {
            ocs_log_err(iscsi->os, "ocs_session_initialize failed\n");
            goto exit_free_all;
        } else {
            sess_initialized = TRUE;
        }
    }

    if (!rc) {
        if ((rc = ocs_isns_initialize(iscsi))) {
            ocs_log_err(iscsi->os, "ocs_isns_initialize failed\n");
            goto exit_free_all;
        } else {
            isns_initialized = TRUE;
        }
    }

    if (!rc) {
        ocs_domain_alloc(ocs);
        if (ocs->domain == NULL) {
            ocs_log_err(iscsi->os, "ocs_domain_alloc failed\n");
            rc = -ENOMEM;
        } else {
            ocs->domain->sport_instance_count = 0;
            ocs->domain->node_instance_count = 0;
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_domain_add(hal, &ocs->sport[0], ocs->domain))) {
            ocs_log_err(iscsi->os, "adding domain to HAL failed\n");
        }
    }

    if (!rc) {
        uint8_t *mac;

        mac = ocs_hal_get_ptr(&ocs->hal, OCS_HAL_MAC_ADDR);
        for (i=0; i < iscsi->num_tgts; i++) {
            extern ocs_mgmt_functions_t sport_mgmt_functions;
            ocs->sport[i].domain = ocs->domain;
            ocs->sport[i].ocs = ocs;
            ocs->sport[i].index = i;
            ocs->sport[i].mgmt_functions = &sport_mgmt_functions;

            if (mac != NULL) {
                ocs_memcpy(ocs->sport[i].mac, mac, ARRAY_SIZE(ocs->sport[i].mac));
                ocs_snprintf(ocs->sport[i].mac_str,
                         sizeof(ocs->sport[i].mac_str),
                         "%02x%02x%02x%02x%02x%02x",
                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
            }

            ocs_sport_lock_init(&ocs->sport[i]);
            ocs_list_init(&ocs->sport[i].node_list, ocs_node_t, link);
            ocs_domain_lock(ocs->hal.domain);
            ocs_list_add_tail(&ocs->domain->sport_list, &ocs->sport[i]);
            ocs->sport[i].created = TRUE;
            ocs_domain_unlock(ocs->hal.domain);
        }
        hal_sports_added = TRUE;
    }

    /* setup the transport object */
    if (!rc) {
        ocs->xport = ocs_xport_alloc(ocs);
        if (!ocs->xport) {
            ocs_log_err(iscsi->os, "Unable to allocate iSCSI transport\n");
            rc = -1;
        }
    }

    ocs->driver_version = DRV_VERSION;
    ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device);
    ocs->fw_version = (const char*) ocs_hal_get_ptr(&ocs->hal, OCS_HAL_FW_REV);

    if (!rc) {
        if (ocs_is_initiator_enabled()) {
            rc = ocs_scsi_ini_new_device(ocs);
            if (rc == 0) {
                ini_device_set = TRUE;
                rc = ocs_scsi_ini_new_domain(ocs->domain);
                if (rc == 0) {
                    scsi_domains_added = TRUE;
                    ocs->sport[0].tgt_id = 0;
                    rc = ocs_scsi_ini_new_sport(&ocs->sport[0]);
                    if (rc == 0) {
                        scsi_sports_added = TRUE;
                    }
                }
            }
        }
    }

    if (!rc) {
        if (ocs_is_target_enabled()) {
            rc = ocs_scsi_tgt_new_device(ocs);
            if (rc == 0) {
                tgt_device_set = TRUE;
                rc = ocs_scsi_tgt_new_domain(ocs->domain);
            }
            for (i=0; i < iscsi->num_tgts; i++) {
                if (rc == 0) {
                    scsi_domains_added = TRUE;
                    ocs->sport[i].tgt_id = i;
                    rc = ocs_scsi_tgt_new_sport(&ocs->sport[i]);
                    if (rc == 0) {
                        scsi_sports_added = TRUE;
                    }
                }
            }
        }
    }


    if (!rc) {
        if ((rc = ocs_hal_init(hal))) {
            ocs_log_err(iscsi->os, "ocs_hal_init failed\n");
        } else {
            iscsi->is_hal_initialized = TRUE;
        }
    }

    /* Setup the idle connection timer on targets only */
    if (!rc) {
        ocs_setup_timer(ocs, &iscsi->idle_timer,
                ocs_iscsi_idle_timeout,
                iscsi,
                IDLE_TIMER_MS, false);
    }

exit_free_all:
    if (rc) {
        uint32_t i;

        if (ocs->io_pool != NULL) {
            ocs_io_pool_free(ocs->io_pool);
            ocs->io_pool = NULL;
        }

        if (scsi_domains_added) {
            if (ocs_is_initiator_enabled()) {
                ocs_scsi_ini_del_domain(ocs->domain);
            }
            if (ocs_is_target_enabled()) {
                ocs_scsi_tgt_del_domain(ocs->domain);
            }
        }

        for (i=0; i < iscsi->num_tgts; i++) {
            if (scsi_sports_added) {
                if (ocs_is_initiator_enabled()) {
                    ocs_scsi_ini_del_sport(&ocs->sport[i]);
                }
                if (ocs_is_target_enabled()) {
                    ocs_scsi_tgt_del_sport(&ocs->sport[i]);
                }
            }
            if (hal_sports_added) {
                ocs_domain_lock(ocs->hal.domain);
                ocs_list_remove(&ocs->domain->sport_list, &ocs->sport[i]);
                ocs->sport[i].created = FALSE;
                ocs_domain_unlock(ocs->hal.domain);
            }
        }

        if (tgt_device_set) {
            ocs_scsi_tgt_del_device(ocs);
        }

        if (ini_device_set) {
            ocs_scsi_ini_del_device(ocs);
        }

        if (login_initialized) {
            ocs_iscsi_login_teardown(iscsi);
        }

        if (ocs->domain != NULL) {
            ocs_domain_force_free(ocs->domain);
            ocs->domain = NULL;
        }

        if (cxn_initialized) {
            ocs_cxn_teardown(iscsi);
        }

        if (sess_initialized) {
            ocs_session_teardown(iscsi);
        }

        if (api_initialized) {
            ocs_iscsi_api_shutdown(ocs);
        }

        if (isns_initialized) {
            ocs_isns_teardown(iscsi);
        }

        if (iscsi->is_hal_initialized) {
            (void)ocs_hal_teardown(iscsi->hal);
            iscsi->is_hal_initialized = FALSE;
        }

        if (iscsi->ctx) {
            ocs_free(os, iscsi->ctx,
                 sizeof(&iscsi->ctx) * OCS_CNFG_CTX_MAX);
            iscsi->ctx = NULL;
        }

        if (iscsi->ip_info) {
            ocs_free(os, iscsi->ip_info,
                 sizeof(*iscsi->ip_info) * OCS_MAX_IP);
            iscsi->ip_info = NULL;
        }

        ocs_log_debug(iscsi->os, "Failed to initialize iSCSI\n");
    }

    iscsi->is_init_complete = 1;
    return rc;
}

/**
 * @ingroup iscsi_main
 * @brief Indicate that HAL is not initialized.
 *
 * @par Description
 * This function clears the is_hal_initialized flag for the given
 * iSCSI structure. This is to be used following a reset which causes
 * the HAL structures to no longer be valid. Clearing this bit prevents
 * the driver from trying to delete structures in the chip that are no
 * longer there.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 *
 * @return None.
 */
void
ocs_iscsi_uninitialize(ocs_iscsi_t *iscsi) {
    iscsi->is_hal_initialized = FALSE;
}

/**
 * @ingroup iscsi_main
 * @brief Shut down the device
 *
 * @par Description
 * This function will shut down the PCI device and release all resources
 * allocated to it.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_iscsi_teardown(ocs_iscsi_t *iscsi) {
    ocs_t *ocs = iscsi->os;
    int32_t rc = 0;
    uint32_t i;

    ocs_assert(iscsi, -1);

    ocs_log_debug(iscsi->os, "shutting down device\n");
    iscsi->shutting_down = TRUE;

    /* Cancel the idle timer */
    if (ocs_timer_pending(&iscsi->idle_timer)) {
        ocs_del_timer(&iscsi->idle_timer);
    }

    ocs_iscsi_ctx_teardown(iscsi);

    /* Teardown all of the connections */
    if (iscsi->hal->domain) {
        ocs_domain_force_free(iscsi->hal->domain);
        iscsi->hal->domain = NULL;
    }

    if (ocs_iscsi_api_shutdown(ocs)) {
        ocs_log_err(iscsi->os, "ocs_iscsi_api_shutdown() failed\n");
    }

    if (iscsi->is_hal_initialized) {
        rc = ocs_hal_teardown(iscsi->hal);
        iscsi->is_hal_initialized = FALSE;

    }
    /* delete sports, then domains */
    for (i=0; i < iscsi->num_tgts; i++) {
        if (ocs_is_initiator_enabled()) {
            ocs_scsi_ini_del_sport(&ocs->sport[i]);
        }
        if (ocs_is_target_enabled()) {
            ocs_scsi_tgt_del_sport(&ocs->sport[i]);
        }
        ocs_sport_lock_free(&ocs->sport[i]);
    }
    if (ocs_is_initiator_enabled()) {
        if (ocs->domain) {
            ocs_scsi_ini_del_domain(ocs->domain);
        }
        ocs_scsi_ini_del_device(ocs);
    }
    if (ocs_is_target_enabled()) {
        if (ocs->domain) {
            ocs_scsi_tgt_del_domain(ocs->domain);
        }
        ocs_scsi_tgt_del_device(ocs);
    }

    if (ocs->domain) {
        rc |= ocs_hal_domain_free(iscsi->hal, ocs->domain);
    }

    ocs_iscsi_login_teardown(iscsi);
    ocs_session_teardown(iscsi);
    ocs_cxn_teardown(iscsi);
    ocs_isns_teardown(iscsi);

    ocs_lock_free(&iscsi->link_state_cb_lock);

    if (ocs->io_pool != NULL) {
        ocs_io_pool_free(ocs->io_pool);
        ocs->io_pool = NULL;
    }

    if (iscsi->ctx) {
        ocs_free(ocs, iscsi->ctx,
             sizeof(*iscsi->ctx) * OCS_CNFG_CTX_MAX);
        iscsi->ctx = NULL;
    }

    if (iscsi->ip_info) {
        ocs_free(ocs, iscsi->ip_info,
             sizeof(*iscsi->ip_info) * OCS_MAX_IP);
        iscsi->ip_info = NULL;
    }

    return rc;
}

/**
 * @brief Configure the HAL based on iSCSI compile parameters.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_hal_configure(ocs_iscsi_t *iscsi) {
    ocs_t *ocs = iscsi->os;
    int32_t rc = 0;
    uint32_t sgl_chain_capable;

    if ((rc = ocs_hal_callback(iscsi->hal,
                   OCS_HAL_CB_LINK,
                   ocs_iscsi_link_event_cb,
                   iscsi))) {
        ocs_log_err(iscsi->os, "Failed setting link CB\n");
    }

    if (!rc) {
        if ((rc = ocs_hal_callback(iscsi->hal,
                       OCS_HAL_CB_CXN,
                       ocs_iscsi_cxn_event_cb,
                       iscsi))) {
            ocs_log_err(iscsi->os, "Failed setting conection CB\n");
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_callback(iscsi->hal,
                       OCS_HAL_CB_UNSOLICITED,
                       ocs_iscsi_unsolicited_event_cb,
                       iscsi))) {
            ocs_log_err(iscsi->os, "Failed setting unsolicited CB\n");
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_get(iscsi->hal,
                      OCS_HAL_PCI_FUNCTION,
                      &iscsi->pf_num))) {
            ocs_log_err(iscsi->os, "Failed getting PCI function\n");
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_get(iscsi->hal,
                      OCS_HAL_N_IO,
                      &iscsi->num_ios))) {
            ocs_log_err(iscsi->os, "Failed getting number of IOs\n");
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_get(iscsi->hal,
                      OCS_HAL_N_CXNS,
                      &iscsi->num_cxns))) {
            ocs_log_err(iscsi->os, "Failed getting number of connections\n");
        }
    }

    /* Set the Dif mode */
    if (!rc) {
        uint32_t dif_capable;
        uint8_t dif_separate = 0;
        char prop_buf[32];

        if (0 == ocs_hal_get(&ocs->hal, OCS_HAL_DIF_CAPABLE, &dif_capable)) {
            if (dif_capable) {
                if (ocs_get_property("dif_separate", prop_buf, sizeof(prop_buf)) == 0) {
                    dif_separate = ocs_strtoul(prop_buf, 0, 0);
                }

                if ((ocs_hal_set(iscsi->hal, OCS_HAL_DIF_MODE,
                      (dif_separate == 0 ? OCS_HAL_DIF_MODE_INLINE : OCS_HAL_DIF_MODE_SEPARATE)))) {
                    /* Not a fatal error */
                    ocs_log_test(iscsi->os, "Failed setting the DIF MODE\n");
                }
            }
        }
    }

    ocs_log_debug(iscsi->os, "Driver configured for %d IOs\n", iscsi->num_ios);
    ocs_log_debug(iscsi->os, "Driver configured for %d connections\n", iscsi->num_cxns);

    if (!rc) {
            if (0 == ocs_hal_get(&ocs->hal, OCS_HAL_SGL_CHAINING_CAPABLE, &sgl_chain_capable)) {
                    if (sgl_chain_capable) {
                if ((rc = ocs_hal_set(iscsi->hal,
                              OCS_HAL_SGL_CHAINING_ENABLE,
                              (ocs->enable_sgl_chaining ? 1 : 0)))) {
                    ocs_log_err(iscsi->os, "Failed setting chaining SGL Enable\n");
                }
            }
            }
    }

    if (!rc && ocs->post_sgl_config != 0) {
        uint32_t num_sges = 0;
        uint32_t post_ver = 0;

        switch (ocs->post_sgl_config) {
        case 1:
            /* 32  SGEs per ICD Version 0 */
            num_sges = 32;
            post_ver = 0;
            break;
        case 2:
            /* 256 SGEs per ICD Version 0 */
            num_sges = 256;
            post_ver = 0;
            break;
        case 3:
            /* 32  SGEs per ICD Version 1 */
            num_sges = 32;
            post_ver = 1;
            break;
        case 4:
            /* 256 SGEs per ICD Version 1 */
            num_sges = 256;
            post_ver = 1;
            break;
        default:
            ocs_log_err(iscsi->os, "Invalid Post SGL configuration value of %d\n", ocs->post_sgl_config);
            rc = -1;
        }

        if (!rc) {
            if ((rc = ocs_hal_set(iscsi->hal,
                          OCS_HAL_NUM_SGES_PER_ICD,
                          num_sges))) {
                ocs_log_err(iscsi->os, "Failed setting number of SGEs\n");
            }
        }

        if (!rc) {
            if ((rc = ocs_hal_set(iscsi->hal,
                          OCS_HAL_POST_SGL_VERSION,
                          post_ver))) {
                ocs_log_err(iscsi->os, "Failed setting Post_SGL version\n");
            }
        }
    }

    if (!rc) {
        if ((rc = ocs_hal_set_ptr(iscsi->hal,
                          OCS_HAL_WAR_VERSION,
                          ocs->hal_war_version))) {
            ocs_log_err(iscsi->os, "Failed setting hal_war_version\n");
        }
    }

    return rc;
}


/**
 * @brief Sets the TCP MTU size of the iSCSI device.
 *
 * @param ocs Pointer to the ocs structure that represents this device
 * @param is_jumbo If TRUE, then the portal will be set for jumbo, otherwise
 *                 set for the standard 1500 bytes.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_mtu_set(ocs_t *ocs, uint8_t is_jumbo)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_SET_MTU);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_set_mtu(iscsi->hal,
                        is_jumbo,
                        ocs_iscsi_ctx_general_cb,
                        ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed setting TCP MTU size\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_SET_MTU,
                        2 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "setting MTU Size status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_MTU);
    }

    return rc;
}

/**
 * @brief iscsi cluster targets free
 */
void ocs_iscsi_cluster_tgts_free(ocs_iscsi_t *iscsi)
{
    ocs_iscsi_cluster_tgt_t *ctgt = NULL;
    ocs_iscsi_cluster_tgt_t *next;

    ocs_list_foreach_safe(&iscsi->clusttgt.list, ctgt, next) {
        ocs_list_remove(&iscsi->clusttgt.list, ctgt);
        ocs_free(iscsi->os, ctgt, sizeof(*ctgt));
        ocs_atomic_sub_return(&iscsi->clusttgt.cnt, 1);
    }
    iscsi->clusttgt.ctgt_next = NULL;
    iscsi->clusttgt.send_en = false;
}

/**
 * @brief This function is the callback a add route table command.
 *
 * @param ul_arg Pointer to the iscsi object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params Points to the command parameters.
 */
static void ocs_iscsi_ctx_route_table_read_cb(void *ul_arg,
                          int32_t status,
                          uint32_t ext_status,
                          void *params)
{
    ocs_config_ctx_t *ctx = ul_arg;
    ocs_iscsi_route_table_t *route_table = (ocs_iscsi_route_table_t *)params;
    uint32_t inx;
    int32_t ip_type;

    if (status == 0 && ext_status == 0) {
        memset(&ctx->route_table, 0, sizeof(ctx->route_table));
        ctx->route_table.entry_count = route_table->entry_count;

        for (inx = 0; inx < route_table->entry_count; inx++) {
            ip_type = ocs_iscsi_convert_to_ip_type(route_table->entry[inx].ip_addr.ip_type);
            ctx->route_table.entry[inx].ip_type = ip_type;
            format_ip_address(ip_type, route_table->entry[inx].ip_addr.ip_address,
                      (char*)ctx->route_table.entry[inx].ip_addr,
                      sizeof(ctx->route_table.entry[inx].ip_addr));

            ip_type = ocs_iscsi_convert_to_ip_type(route_table->entry[inx].subnet.ip_type);
            format_ip_address(ip_type, route_table->entry[inx].subnet.ip_address,
                      (char*)ctx->route_table.entry[inx].subnet,
                      sizeof(ctx->route_table.entry[inx].subnet));

            ip_type = ocs_iscsi_convert_to_ip_type(route_table->entry[inx].gateway.ip_type);
            format_ip_address(ip_type, route_table->entry[inx].gateway.ip_address,
                      (char*)ctx->route_table.entry[inx].gateway,
                      sizeof(ctx->route_table.entry[inx].gateway));
        }
    }
    ocs_iscsi_ctx_post(ctx, status, ext_status);
}

/**
 * @brief Deletes an entry from a routing table.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ipsub IP Address, subnet and gateway to delete.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_route_table_del_entry(ocs_t *ocs,
                    ocs_ip_address_subnet_t *ipsub,
                    ocs_ip_address_t *gateway)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_config_ctx_t *ctx;
    ocs_hal_ip_address_subnet_t hal_ipsub;
    ocs_hal_ip_address_t hal_gateway;
    int32_t timeout = 4 * 1000000;
    int32_t rc = -EFAULT;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        return rc;
    }

    ocs_iscsi_convert_to_hal_ipsub(ipsub, &hal_ipsub);
    ocs_iscsi_convert_to_hal_ip(gateway, &hal_gateway);
    rc = ocs_hal_portal_set_route_table(iscsi->hal,
                        &hal_ipsub, &hal_gateway, FALSE,
                        ocs_iscsi_ctx_general_cb,
                        ctx);
    if (rc) {
        ocs_log_err(iscsi->os, "Submitting route table add entry failed\n");
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
        return rc;
    }

    rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE, timeout);
    if (rc == 0) {
        if (ctx->status != 0 || ctx->ext_status != 0) {
            rc = -1;
            ocs_log_err(iscsi->os,
                    "Route table entry add failed status 0x%x ext_stat 0x%x\n",
                    ctx->status, ctx->ext_status);
        }
    }

    ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
    return rc;
}


/**
 * @brief Adds an entry to a routing table.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ipsub IP Address, subnet and gateway to add.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_route_table_add_entry(ocs_t *ocs,
                    ocs_ip_address_subnet_t *ipsub,
                    ocs_ip_address_t *gateway)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_config_ctx_t *ctx;
    ocs_hal_ip_address_subnet_t hal_ipsub;
    ocs_hal_ip_address_t hal_gateway;
    int32_t timeout = 4 * 1000000;
    int32_t rc = -EFAULT;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        return rc;
    }

    ocs_iscsi_convert_to_hal_ipsub(ipsub, &hal_ipsub);
    ocs_iscsi_convert_to_hal_ip(gateway, &hal_gateway);
    rc = ocs_hal_portal_set_route_table(iscsi->hal,
                        &hal_ipsub, &hal_gateway, TRUE,
                        ocs_iscsi_ctx_general_cb,
                        ctx);
    if (rc) {
        ocs_log_err(iscsi->os, "Submitting route table add entry failed\n");
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
        return rc;
    }

    rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE, timeout);
    if (rc == 0) {
        if (ctx->status != 0 || ctx->ext_status != 0) {
            rc = -1;
            ocs_log_err(iscsi->os,
                    "Route table entry add failed status 0x%x ext_stat 0x%x\n",
                    ctx->status, ctx->ext_status);
        }
    }

    ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_ROUTE_TABLE);
    return rc;
}

int32_t ocs_iscsi_route_table_read(ocs_t *ocs, ocs_route_table_t *route_table)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_config_ctx_t *ctx;
    int32_t timeout = 4 * 1000000;
    int32_t rc = -EFAULT;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_GET_ROUTE_TABLE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        return rc;
    }

    rc = ocs_hal_portal_get_route_table(iscsi->hal,
                        ocs_iscsi_ctx_route_table_read_cb, ctx);
    if (rc) {
        ocs_log_err(iscsi->os, "Submitting get route table failed\n");
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_GET_ROUTE_TABLE);
        return rc;
    }

    rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_GET_ROUTE_TABLE, timeout);
    if (rc == 0) {
        if (ctx->status != 0 || ctx->ext_status != 0) {
            rc = -1;
            ocs_log_err(iscsi->os,
                    "Get route table failed status 0x%0x ext_stat 0x%x\n",
                    ctx->status, ctx->ext_status);
        } else {
            ocs_memcpy(route_table, &ctx->route_table, sizeof(*route_table));
        }
    }

    ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_GET_ROUTE_TABLE);
    return rc;
}

/**
 * @brief Adds the IP address to the specified interface.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param portal Portal to use.
 * @param ipsub IP Address and subnet to add.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_ip_address_add(ocs_t *ocs,
                 ocs_hal_portal_t portal,
                 ocs_ip_address_subnet_t *ipsub)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_subnet_t hal_ipsub;
    int timeout = 4 * 1000000;
    ocs_ip_address_subnet_t *ipsub_tbl;
    uint32_t num_ips;
    uint32_t i;

    ipsub_tbl = ocs_malloc(ocs, sizeof(ocs_ip_address_subnet_t) * OCS_MAX_IP,
                   OCS_M_ZERO | OCS_M_NOWAIT);
    if (ipsub_tbl == NULL) {
        ocs_log_err(iscsi->os, "failed allocating IP table memory\n");
        rc = -1;
    } else {
        ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_IP_ADD);
        if (ctx == NULL) {
            ocs_log_err(iscsi->os, "context is busy\n");
            rc = -1;
        } else {
            /* Bug 146254 - Use a 6 minute timeout */
            if (ipsub->ip_type == OCS_IP_TYPE_DHCP_V4 ||
                ipsub->ip_type == OCS_IP_TYPE_AUTO_V6) {
                timeout = 6 * 60 * 1000000;
            }

            ocs_iscsi_convert_to_hal_ipsub(ipsub, &hal_ipsub);
            rc = ocs_hal_portal_ip_add(iscsi->hal,
                           portal,
                           &hal_ipsub,
                           ocs_iscsi_ctx_general_cb,
                           ctx);
            if (rc) {
                ocs_log_test(iscsi->os, "failed adding IP\n");
            } else {
                rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_IP_ADD, timeout);
                /* For Auto addresses get the new address */
                if (rc == 0) {
                    if (ctx->status == 0 &&
                        ctx->ext_status == 0) {
                        if (ipsub->ip_type == OCS_IP_TYPE_DHCP_V4 ||
                            ipsub->ip_type == OCS_IP_TYPE_AUTO_V6) {
                            rc = ocs_iscsi_ip_address_query(ocs,
                                            portal,
                                            ipsub->ip_type,
                                            OCS_MAX_IP,
                                            &num_ips,
                                            ipsub_tbl);
                            if (rc == 0) {
                                for(i = 0; i < num_ips; i++) {
                                    if (ipsub_tbl[i].ip_type == ipsub->ip_type) {
                                        /* Copy back to caller */
                                        ocs_memcpy(ipsub,
                                               &ipsub_tbl[i],
                                               sizeof(*ipsub));
                                        break;
                                    }
                                }
                            }
                        }
                        /* Add the IP (recevied with DHCP or static IP) to OCS device table*/
                        ocs_iscsi_add_ip_to_tbl(ocs, "Added", ipsub, portal);
                    } else {
                        rc = -1;
                        ocs_log_test(iscsi->os, "adding IP status 0x%x ext status 0x%x\n",
                                 ctx->status, ctx->ext_status);
                    }
                }
            }
            ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_IP_ADD);
        }
    }

    if (ipsub_tbl != NULL) {
        ocs_free(ocs, ipsub_tbl, sizeof(ocs_ip_address_subnet_t) * OCS_MAX_IP);
    }

    return rc;
}

/**
 * @brief Remove the IP address to the specified interface.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param portal Portal to use.
 * @param ipsub IP Address and subnet to remove.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_ip_address_remove(ocs_t *ocs,
                    ocs_hal_portal_t portal,
                    ocs_ip_address_subnet_t *ipsub)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_subnet_t hal_ipsub;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_IP_REMOVE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ipsub(ipsub, &hal_ipsub);
        rc = ocs_hal_portal_ip_remove(iscsi->hal,
                          portal,
                          &hal_ipsub,
                          ocs_iscsi_ctx_general_cb,
                          ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "Error %d removing IP\n", rc);
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_IP_REMOVE,
                        3 * 1000000);
            if (rc == 0) {
                if ((ctx->status == 0) && (ctx->ext_status == 0)) {
                    ocs_iscsi_remove_ip_from_tbl(ocs, ipsub, portal);
                } else {
                    rc = -1;
                    ocs_log_test(iscsi->os, "Removing IP status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            } else {
                ocs_log_test(iscsi->os, "Timeout Removing IP\n");
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_IP_REMOVE);
    }

    return rc;
}


/**
 * @brief Queries the IP addresses on the default interface.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param portal Portal to use.
 * @param ip_type Enumerated type indicating the type of IP
 * address (IPV4, IPV6, etc).
 * @param max_entries Maximum number of entries to be returned.
 * @param num_ips Actual number of entries returned.
 * @param ipsub Used to return queried IP addresses.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_ip_address_query(ocs_t *ocs,
                   ocs_hal_portal_t portal,
                   ocs_ip_type_e ip_type,
                   uint32_t max_entries,
                   uint32_t *num_ips,
                   ocs_ip_address_subnet_t *ipsub)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc = -1;
    ocs_config_ctx_t* ctx;

    *num_ips = 0;
    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_IP_QUERY);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_ip_get(iscsi->hal,
                       portal,
                       ocs_iscsi_convert_to_hal_ip_type(ip_type),
                       ocs_iscsi_query_ip_cb,
                       ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed querying IPs\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_IP_QUERY,
                        1 * 1000000);
            if (rc == 0) {
                if (ctx->status == 0 &&
                    ctx->ext_status == 0) {
                    *num_ips = MIN(ctx->num_ips, max_entries);
                    ocs_memcpy(ipsub, ctx->ipsub,
                           sizeof(ocs_ip_address_subnet_t) * *num_ips);
                } else {
                    rc = -1;
                    ocs_log_test(iscsi->os, "querying IPs status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_IP_QUERY);
    }

    return rc;
}

/**
 * @brief Adds an IP address to the table.
 *
 * @param ocs Pointer to the ocs structure.
 * @param desc A character description of the IP address being added.
 * @param ipsub Pointer to the IP/subnet structure.
 * @param portal Portal that has the IP address.
 */
int32_t
ocs_iscsi_add_ip_to_tbl(ocs_t *ocs,
            char *desc,
            ocs_ip_address_subnet_t *ipsub,
            ocs_hal_portal_t portal)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_ip_address_t ip;
    ocs_ip_address_t subnet;
    char ip_str[40];
    char mask_str[40];
    char *ip_type_str;
    int32_t rc = 0;

    switch (ipsub->ip_type) {
    case OCS_IP_TYPE_V4:
        ip_type_str = "v4";
        break;
    case OCS_IP_TYPE_DHCP_V4:
        ip_type_str = "DHCP";
        break;
    case OCS_IP_TYPE_V6:
        ip_type_str = "v6";
        break;
    case OCS_IP_TYPE_AUTO_V6:
        ip_type_str = "Auto v6";
        break;
    default:
        ip_type_str = "Invalid";
        break;
    }


    ocs_iscsi_ipsub_split(ipsub,
                  &ip,
                  &subnet);

    format_ip_address(ip.ip_type,
              ip.ip_address,
              ip_str, sizeof(ip_str));
    format_ip_address(subnet.ip_type,
              subnet.ip_address,
              mask_str, sizeof(mask_str));
    ocs_log_debug(ocs, "Adding %s IP address %s mask %s type %s\n",
              desc,
              ip_str,
              mask_str,
              ip_type_str);

    if (iscsi->num_ips < OCS_MAX_IP) {
        ocs_iscsi_tgt_ip_t *api_ip = &iscsi->ip_info[iscsi->num_ips];
        api_ip->portal = portal;
        api_ip->ip = ip;
        api_ip->subnet = subnet;
        api_ip->tcp_port = 0;
        api_ip->ip_added = 1;
        api_ip->listening = 0;
        iscsi->num_ips++;
    } else {
        ocs_log_warn(ocs, "IP Table overflow\n");
        rc = -1;
    }
    return rc;
}

/**
 * @brief Remove an IP address from the table.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ipsub Pointer to the IP/subnet structure.
 * @param portal Portal that has the IP address.
 *
 * @return Returns 0 if the address was removed, or -1 if the address was not found.
 */
int32_t
ocs_iscsi_remove_ip_from_tbl(ocs_t *ocs,
                 ocs_ip_address_subnet_t *ipsub,
                 ocs_hal_portal_t portal)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_ip_address_t ip;
    ocs_ip_address_t subnet;
    uint32_t i;
    int rc = -1;
    int found_at = -1;

    ocs_iscsi_ipsub_split(ipsub, &ip, &subnet);
    for (i = 0; i < iscsi->num_ips; i++) {
        ocs_iscsi_tgt_ip_t *api_ip = &iscsi->ip_info[i];
        if (memcmp(&api_ip->ip, &ip, sizeof(ip)) == 0 &&
            memcmp(&api_ip->subnet, &subnet, sizeof(subnet)) == 0) {
            found_at = i;
            break;
        }
    }

    if (found_at != -1) {
        // Remove the item
        for (i=found_at; i<iscsi->num_ips; i++) {
            ocs_iscsi_tgt_ip_t *src = &iscsi->ip_info[i+1];
            ocs_iscsi_tgt_ip_t *dst = &iscsi->ip_info[i];
            ocs_memcpy(dst, src, sizeof(*src));
        }

        iscsi->num_ips--;
        rc = 0;
    }

    return rc;
}


/**
 * @brief Checks if an IP address/subnet is present in the table.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ipsub Pointer to the IP address/subnet structure to check.
 *
 * @return Returns TRUE if the IP address is found.
 */
int32_t
ocs_iscsi_is_ip_in_tbl(ocs_t *ocs, ocs_ip_address_subnet_t *ipsub)
{
    int32_t rc = FALSE;
    uint32_t i;
    ocs_ip_address_t ip;
    ocs_ip_address_t subnet;
    ocs_iscsi_t *iscsi = &ocs->iscsi;

    ocs_iscsi_ipsub_split(ipsub, &ip, &subnet);
    for (i = 0; i < iscsi->num_ips; i++) {
        ocs_iscsi_tgt_ip_t *api_ip = &iscsi->ip_info[i];
        if (memcmp(&api_ip->ip, &ip, sizeof(ip)) == 0 &&
            memcmp(&api_ip->subnet, &subnet, sizeof(subnet)) == 0) {
            rc = TRUE;
            break;
        }
    }
    return rc;
}


/**
 * @brief Sets the IP gateway address.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param gateway IP address of the gateway.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_gateway_set(ocs_t *ocs, ocs_ip_address_t *gateway)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_SET_GATEWAY);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(gateway, &hal_ip);
        rc = ocs_hal_portal_gateway_add(iscsi->hal,
                        &hal_ip,
                        ocs_iscsi_ctx_general_cb,
                        ctx);

        if (rc) {
            ocs_log_test(iscsi->os, "failed setting gateway\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_SET_GATEWAY,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "setting gateway status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_SET_GATEWAY);
    }

    return rc;
}

/**
 * @brief Retrieves the default portal.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 *
 * @return Returns the default portal.
 */
ocs_hal_portal_t ocs_iscsi_portal_get_default(ocs_t *ocs)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;

    return ocs_hal_portal_get_default(iscsi->hal);
}

/**
 * @brief Find IP address of interface handle
 *        If IP address is found for given interface handle, copy to ip and subnet params.
 *
 * @return Returns TRUE if IP addresses are found for given interface handle,
 *         otherwise FALSE
 */
int32_t ocs_iscsi_portal_find_ip_address(ocs_t *ocs, ocs_hal_portal_t iface_handle,
                     ocs_ip_address_t *ip,
                     ocs_ip_address_t *subnet,
                     uint16_t *tcp_port, int32_t *listening)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc = FALSE;
    uint32_t i;

    for (i = 0; i < iscsi->num_ips; i++) {
        ocs_iscsi_tgt_ip_t *api_ip = &iscsi->ip_info[i];
        if (api_ip->portal == iface_handle) {
            ocs_memcpy(ip, &api_ip->ip, sizeof(*ip));
            ocs_memcpy(subnet, &api_ip->subnet, sizeof(*subnet));
            *tcp_port = api_ip->tcp_port;
            *listening = api_ip->listening;
            rc = TRUE;
            break;
        }
    }

    return rc;
}
 
/**
 * @brief Check and remove IP addresses of the corresponding interface
 *
 * @param ocs Pointer to the OCS context
 * @param iface_handle Interface handle to check for IP addresses
 *
 * @return Returns 0 on success, otherwise a negative value
 */
int32_t ocs_iscsi_portal_remove_ip_addresses(ocs_t *ocs,
                         ocs_hal_portal_t iface_handle)
{
    int32_t rc = 0;
    ocs_ip_address_t ip;
    ocs_ip_address_t subnet;
    ocs_ip_address_subnet_t ipsub;
    char ip_str[40];
    uint16_t tcp_port;
    int32_t listening;

    while (TRUE) {
        ocs_memset(&ip, 0, sizeof(ip));
        ocs_memset(&subnet, 0, sizeof(subnet));
        rc = ocs_iscsi_portal_find_ip_address(ocs, iface_handle, &ip, &subnet,
                              &tcp_port, &listening);
        if (!rc) {
            ocs_log_debug(ocs, "IP's are not found for iface %d\n",
                      iface_handle);
            break;
        }

        format_ip_address(ip.ip_type, ip.ip_address, ip_str, sizeof(ip_str));
        ocs_log_debug(ocs, "Found IP %s in iface %d\n", ip_str, iface_handle);
        /* Stop listening on the IP address */
        if (listening) {
            rc = ocs_iscsi_listen_stop(ocs, &ip, tcp_port);
            if (rc) {
                ocs_log_err(ocs, "Failed to stop listening on IP %s\n",
                        ip_str);
                break;
            } else {
                ocs_log_debug(ocs, "Stopped listening on IP %s\n",
                          ip_str);
            }
        }

        ocs_iscsi_ipsub_combine(&ipsub, &ip, &subnet);
        rc = ocs_iscsi_ip_address_remove(ocs, iface_handle, &ipsub);
        if (rc) {
            ocs_log_err(ocs, "Failed removing IP %s\n", ip_str);
            break;
        } else {
            ocs_log_debug(ocs, "Removed IP %s\n", ip_str);
        }
    }

    return rc;
}

/**
 * @brief Helper function to find respective interface handle of VLAN id
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param vlan_tag The vlan id
 * @param iface_handle 
 *
 * @return Returns 0 if interface handle is found, otherwise a negative value.
 */
int32_t ocs_iscsi_find_portal_from_vlan(ocs_t *ocs, uint32_t vlan_id,
                    ocs_hal_portal_t *iface_handle)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_vlan_portal_info_t *portal;
    int32_t rc = -EFAULT;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->portal_list, portal) {
        if (portal->vlan_id == vlan_id) {
            *iface_handle = portal->iface_handle;
            rc = 0; 
            break;
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return rc;
    
}
/**
 * @brief Check VLAN for duplicate
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param vlan_tag The vlan to check for duplicates.
 *
 * @return Returns TRUE if VLAN is not exists, otherwise FALSE.
 */
int32_t ocs_iscsi_portal_is_vlan_exists(ocs_t *ocs, uint32_t vlan_id)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_vlan_portal_info_t *portal;
    int32_t rc = FALSE;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->portal_list, portal) {
        if (portal->vlan_id == vlan_id) {
            rc = TRUE;
            break;
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return rc;
}

/**
 * @brief Add VLAN and iface handle to portal_list
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param iface The interface handle to add 
 * @param vlan_tag The vlan id to add
 *
 * @return Returns 0 on success, otherwise a negative value 
 */
int32_t ocs_iscsi_portal_add_vlan(ocs_t *ocs, ocs_hal_portal_t iface,
                  uint32_t vlan_id)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_vlan_portal_info_t *portal;

    ocs_lock(&iscsi_api->api_list_lock);

    portal = ocs_malloc(ocs, sizeof(ocs_vlan_portal_info_t),
                OCS_M_ZERO | OCS_M_NOWAIT);
    if (portal == NULL) {
        ocs_log_err(ocs, "Failed to allocate memory\n");
        ocs_unlock(&iscsi_api->api_list_lock);
        return -ENOMEM;
    }

    portal->iface_handle = iface;
    portal->vlan_id = vlan_id;
    ocs_list_add_tail(&iscsi_api->portal_list, portal);
    ocs_log_debug(ocs, "Added portal %d and vlan %d to portal_list\n",
              iface, vlan_id);

    ocs_unlock(&iscsi_api->api_list_lock);
    return 0;
}

/**
 * @brief Delete iface handle and VLAN from portal_list
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param iface The interface handle to delete
 * @param vlan_tag The vlan id to delete
 *
 * @return Returns 0 on success, otherwise a negative value 
 */
int32_t ocs_iscsi_portal_del_vlan(ocs_t *ocs, ocs_hal_portal_t iface)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_vlan_portal_info_t *portal;
    ocs_vlan_portal_info_t *portal_next;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach_safe(&iscsi_api->portal_list, portal, portal_next) {
        if (portal->iface_handle == iface) {
            ocs_log_debug(ocs, "Removing portal %d from portal_list\n",
                      portal->iface_handle);
            ocs_list_remove(&iscsi_api->portal_list, portal);
            ocs_free(ocs, portal, sizeof(*portal));
            break;
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return 0;
}

/**
 * @brief Read VLAN IDs to provided buffer.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param arg_out Pointer to output buffer 
 * @param arg_out_length Length of output buffer
 *
 * @return Returns 0 on success, otherwise a negative value 
 */
int32_t ocs_iscsi_portal_read_vlan_ids(ocs_t *ocs, void *arg_out,
                       uint32_t arg_out_length)
{
    int32_t ret = 0;
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    uint32_t remain = arg_out_length;
    char *userbuff = (char *)arg_out;
    uint32_t len = 0;
    uint32_t bytes_to_copy;
    ocs_vlan_portal_info_t *portal_info;
    ocs_vlan_portal_info_t *portal_next;
    char str[64];

    ocs_lock(&iscsi_api->api_list_lock);
    if (!ocs_list_empty(&iscsi_api->portal_list)) {
        ocs_list_foreach_safe(&iscsi_api->portal_list, portal_info, portal_next) {
            snprintf(str, sizeof(str), "VLAN id %d\n", portal_info->vlan_id);
            len = ocs_strlen(str);
            bytes_to_copy = (len > remain ? remain : len);
            if (ocs_copy_to_user(userbuff, str, bytes_to_copy)) {
                ret = -EFAULT;
                break;
            } else {
                userbuff += bytes_to_copy;
                remain -= bytes_to_copy;
                ret = 0;
            }
        }
    } else {
        snprintf(str, sizeof(str), "VLAN list is empty\n");
        len = ocs_strlen(str);
        bytes_to_copy = (len > remain ? remain : len);
        if (ocs_copy_to_user(userbuff, str, bytes_to_copy)) {
            ret = -EFAULT;
        } else {
            userbuff += bytes_to_copy;
            remain -= bytes_to_copy;
            ret = 0;
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    if (!ret) {
        ret = -EFAULT;
        if (remain > 1) {
            if (!ocs_copy_to_user(userbuff, "\0", 1)) {
                ret = 0;
            }
        }
    }

    return ret;
}

/**
 * @brief This function is the callback for creating an interface/portal
 *
 * @param ul_arg Pointer to the iscsi object.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params NULL for this function.
 */
static void ocs_iscsi_portal_create_cb(void    *ul_arg,
                       int32_t  status,
                       uint32_t ext_status,
                       void    *params)
{
    ocs_config_ctx_t *ctx = ul_arg;
    ocs_hal_portal_t iface = (ocs_hal_portal_t)(uintptr_t)params;

    ctx->iface = iface;
    ocs_iscsi_ctx_post(ctx, status, ext_status);
}


/**
 * @brief Creates a portal for a VLAN
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param vlan_tag The vlan to create.
 * @param portal Portal to create.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_portal_create(ocs_t *ocs, unsigned int vlan_id,
                ocs_hal_portal_t *portal)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;

    /* No need of having multiple interfaces with same vlan_id */
    rc = ocs_iscsi_portal_is_vlan_exists(ocs, vlan_id);
    if (rc) {
        ocs_log_err(ocs, "VLAN id %d is already exists\n");
        return rc;
    }

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_PORTAL_CREATE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_create(iscsi->hal, vlan_id,
                       ocs_iscsi_portal_create_cb,
                       ctx);
        if (rc) {
            ocs_log_err(iscsi->os, "failed creating portal\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_PORTAL_CREATE,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status == 0 &&
                    ctx->ext_status == 0) {
                    *portal = ctx->iface;
                } else {
                    rc = -1;
                    ocs_log_err(iscsi->os, "creating portal status 0x%x ext status 0x%x\n",
                            ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_PORTAL_CREATE);
    }

    if (rc == 0) {
        /* Add VLAN and iface handle to vlan_list */
        ocs_iscsi_portal_add_vlan(ocs, *portal, vlan_id);
    }

    return rc;
}


/**
 * @brief Removes a previously-created portal.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param portal Portal to remove.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_portal_delete(ocs_t *ocs, ocs_hal_portal_t portal)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_PORTAL_DELETE);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        rc = ocs_hal_portal_delete(iscsi->hal, portal,
                       ocs_iscsi_ctx_general_cb,
                       ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed creating portal\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_PORTAL_DELETE,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_err(iscsi->os, "deleting portal status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_PORTAL_DELETE);
    }

    return rc;
}


/**
 * @brief Starts a TCP listen socket.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ip IP address to listen on.
 * @param tcp_port TCP port number to listen on.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_listen_start(ocs_t *ocs, ocs_ip_address_t *ip,
                   uint16_t tcp_port)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_LISTEN_START);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(ip, &hal_ip);
        rc = ocs_hal_portal_listen_start(iscsi->hal,
                         &hal_ip,
                         tcp_port,
                         ocs_iscsi_ctx_general_cb,
                         ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed Starting Listen\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_LISTEN_START,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "starting listen status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_LISTEN_START);
    }

    return rc;
}

/**
 * @brief Stops a TCP listen socket.
 *
 * @param ocs Pointer to the ocs structure that represents this device.
 * @param ip IP address to listen on.
 * @param tcp_port TCP port number to listen on.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_iscsi_listen_stop(ocs_t *ocs, ocs_ip_address_t *ip,
                  uint16_t tcp_port)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    int32_t rc;
    ocs_config_ctx_t* ctx;
    ocs_hal_ip_address_t hal_ip;

    ctx = ocs_iscsi_ctx_alloc(iscsi, OCS_CNFG_CTX_LISTEN_STOP);
    if (ctx == NULL) {
        ocs_log_err(iscsi->os, "context is busy\n");
        rc = -1;
    } else {
        ocs_iscsi_convert_to_hal_ip(ip, &hal_ip);
        rc = ocs_hal_portal_listen_stop(iscsi->hal,
                        &hal_ip,
                        tcp_port,
                        ocs_iscsi_ctx_general_cb,
                        ctx);
        if (rc) {
            ocs_log_test(iscsi->os, "failed Stopping Listen\n");
        } else {
            rc = ocs_iscsi_ctx_wait(iscsi, OCS_CNFG_CTX_LISTEN_STOP,
                        3 * 1000000);
            if (rc == 0) {
                if (ctx->status != 0 ||
                    ctx->ext_status != 0) {
                    rc = -1;
                    ocs_log_test(iscsi->os, "stopping listen status 0x%x ext status 0x%x\n",
                             ctx->status, ctx->ext_status);
                }
            }
        }
        ocs_iscsi_ctx_free(iscsi, OCS_CNFG_CTX_LISTEN_STOP);
    }

    return rc;
}

/**
 * @brief Register to receive link state change notifications.
 *
 * @par Description
 * This function is used by upper level drivers to register a
 * function which should be called when the link state changes.
 *
 * @return Returns 0 on success, or a negative error code value
 *         on failure.
 */
int32_t ocs_iscsi_register_link_state_callback(ocs_t *ocs, ocs_link_state_cb_t cb)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    uint32_t i;

    /* Check to see if we already have this callback registered */
    for (i=0; i<OCS_ISCSI_MAX_LINK_STATE_CALLBACKS; i++) {
        if (iscsi->link_state_callbacks[i] == cb) {
            /* Already registered */
            return 0;
        }
    }

    ocs_lock(&iscsi->link_state_cb_lock);
    for (i=0; i<OCS_ISCSI_MAX_LINK_STATE_CALLBACKS; i++) {
        if (iscsi->link_state_callbacks[i] == NULL) {
            iscsi->link_state_callbacks[i] = cb;
            break;
        }
    }
    ocs_unlock(&iscsi->link_state_cb_lock);


    return 0;

}

/**
 * @brief  Unregister a link state change callback.
 *
 * @par Description
 * This function is used by upper level drivers to remove the
 * registration of a link state callback function.
 *
 * @return None.
 */
void ocs_iscsi_unregister_link_state_callback(ocs_t *ocs, ocs_link_state_cb_t cb)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    uint32_t i;

    ocs_lock(&iscsi->link_state_cb_lock);
    for (i=0; i<OCS_ISCSI_MAX_LINK_STATE_CALLBACKS; i++) {
        if (iscsi->link_state_callbacks[i] == cb) {
            iscsi->link_state_callbacks[i] = NULL;
            break;
        }
    }
    ocs_unlock(&iscsi->link_state_cb_lock);

}

/**
 * @brief Function to receive the notification of link events.
 *
 * @param arg Pointer to the iSCSI structure that represents this device.
 * @param isLinkUp Non-zero means the link is up.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_link_event_cb(void *arg, uint8_t isLinkUp)
{
    ocs_iscsi_t *iscsi = (ocs_iscsi_t *)arg;
    ocs_t *ocs = iscsi->os;
    uint32_t i;
    ocs_link_state_e link_state;

    ocs_log_debug(iscsi->os, "link is %s\n", (isLinkUp ? "UP" : "DOWN"));

    link_state = (isLinkUp ? OCS_LINK_STATE_UP : OCS_LINK_STATE_DOWN);

    for (i=0; i<OCS_ISCSI_MAX_LINK_STATE_CALLBACKS; i++) {
        if (iscsi->link_state_callbacks[i] != NULL) {
            iscsi->link_state_callbacks[i](ocs, link_state);
        }
    }


    return 0;
}


#if defined(OCS_INCLUDE_DEBUG)
/**
 * @brief Function to find and dump the WQE associated with an IO.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param io Pointer to the IO structure.
 */
static void
ocs_iscsi_dump_io(ocs_iscsi_t *iscsi,
          ocs_io_t *io)
{
    ocs_cxn_t *cxn = io->node;
    sli4_queue_t *q = &iscsi->hal->wq[cxn->wq_index];
    sli4_wqe_context_t *ctx;
    char dmphdr[32];

    ocs_log_debug(iscsi->os, "%s ICD %d, ITT 0x%x, dsl=0x%x, wire_xfer_size=0x%x, wire_offset=0x%x, sge_offset=0x%x\n",
              (io->is_read ? "Read" : "Write"),
              (io->hio != NULL ? io->hio->icd : -1),
              io->init_task_tag,
              io->exp_xfer_len,
              io->scsi_wire_xfer_size,
              io->scsi_wire_offset,
              (io->hio != NULL ? io->hio->sge_offset : 0xFFFFFFFF));

    /* data = io->sgl; */
    /* for (index = 0; index < io->n_sge; index++) { */
    /*     ocs_log_debug(iscsi->os, "  sge %d 0x%x 0x%08x len=0x%x\n", */
    /*         index, */
    /*         data[index].buffer_address_high, */
    /*         data[index].buffer_address_low, */
    /*         data[index].buffer_length); */
    /* } */

    ocs_lock(&q->lock);
    ctx = ocs_list_get_head(&q->u.wq.wqe_busy);
    while (ctx != NULL) {
        if (ctx->io != NULL &&
            ctx->io == io) {
            uint8_t *qe = q->dma.virt + (ctx->wrb_index * q->size);

            ocs_snprintf(dmphdr, sizeof(dmphdr), "Io WQE Index %d", ctx->wrb_index);
            ocs_dump32(OCS_DEBUG_ALWAYS, iscsi->os, dmphdr, qe, q->size);
            break;
        }
        ctx = ocs_list_next(&q->u.wq.wqe_busy, ctx);
    }
    ocs_unlock(&q->lock);
}

/**
 * @brief Function to dump the active IOs on a connection.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param cxn Pointer to the connection object.
 */
static void
ocs_iscsi_dump_active_ios(ocs_iscsi_t *iscsi,
           ocs_cxn_t    *cxn)
{
    ocs_io_t *io;
    /* sli4_sge_t  *data; */
    /* uint32_t index; */

    ocs_node_lock(cxn);
    ocs_list_foreach(&cxn->active_ios, io) {
        ocs_iscsi_dump_io(iscsi, io);
    }
    ocs_node_unlock(cxn);
}
#endif


/**
 * @brief Function to process connection invalidation notifications.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param cxn Pointer to the connection object.
 * @param code Error code.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_cxn_event_invalid(ocs_iscsi_t *iscsi,
                ocs_cxn_t   *cxn,
                uint32_t     code)
{
    int32_t rc = 0;
    uint8_t        sendRst = code != SLI_STATUS_RECV_TCP_FIN;

    ocs_log_debug(iscsi->os, "Cxn %p with wq_id 0x%x conn_hdl 0x%x for %s Invalidated in FW (0x%x)\n",
              cxn,
              cxn->wq_id,
              cxn->conn_hdl,
              cxn->display_name,
              code);
#if defined(OCS_INCLUDE_DEBUG)
    ocs_iscsi_dump_active_ios(iscsi, cxn);
#endif

    if (cxn->cxn_state == CONN_STATE_FULL_FEATURE) {
        switch(code) {
        case ISCSI_CQE_CODE_RECV_PDU_DSL_ERROR:
        case ISCSI_CQE_CODE_RECV_SEQ_BURST_ERROR:
        case ISCSI_CQE_CODE_RECV_AHS_NOT_SUPPORTED:
        case ISCSI_CQE_CODE_HDR_DIGEST_ERROR:
        case ISCSI_CQE_CODE_OPCODE_ERROR:
        case ISCSI_CQE_CODE_ITT_TTT_WRONG_CXN:
        case ISCSI_CQE_CODE_ITT_TTT_TOO_BIG:
        case ISCSI_CQE_CODE_BAD_WQE_INDEX:
        case ISCSI_CQE_CODE_RESIDUAL_OVERRUN:
        case ISCSI_CQE_CODE_RESIDUAL_UNDERRUN:
        case ISCSI_CQE_CODE_CMD_DATA_DIFF_CXN:
        case ISCSI_CQE_CODE_RECV_UNSOL_PDU_ERROR:
            if (!cxn->is_ini_cxn) {
                ocs_log_test(iscsi->os, "CQE with code %d - send async logout for %s\n",
                         code, cxn->display_name);
                rc = ocs_iscsi_cxn_request_logout(cxn);
                if (rc != 0) {
                    ocs_log_test(iscsi->os, "Request logout status %d for %s\n",
                             rc, cxn->display_name);
                }
            } else {
                ocs_log_test(iscsi->os, "CQE with code %d on ini cxn %s - close\n",
                         code, cxn->display_name);
            }
            ocs_cxn_close(cxn, FALSE);
            break;
        default:
            rc = ocs_cxn_close(cxn, sendRst);
            break;
        }
    } else {
        rc = ocs_cxn_close(cxn, sendRst);
    }

    return rc;
}

/**
 * @brief Function to process a data digest error.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param tgt_digest Pointer to the data digest error fields.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_cxn_event_data_digest(ocs_iscsi_t *iscsi,
                ocs_hal_tgt_data_digest_t *tgt_digest)
{
    ocs_cxn_t    *cxn = tgt_digest->cxn;
    ocs_hal_io_t *hio = tgt_digest->io;
    ocs_io_t     *io  = tgt_digest->arg;
    int32_t       rc = -1;
    iscsi_data_out_hdr_t hdr;

    ocs_log_debug(iscsi->os, "data digest error on cid %d, icd %d\n",
              cxn->wq_id,
              (hio == NULL ? -1 : hio->icd));

    if (hio != NULL) {
        /*
         * We have to rebuild the header from the provided fields so that
         * we can send the reject PDU!
         */
        ocs_memset(&hdr, 0, sizeof(iscsi_data_out_hdr_t));
        hdr.final   = tgt_digest->fin;
        hdr.opcode = ISCSI_CMD_DATA_OUT;
        hdr.dw2.data_segment_length[0] = (tgt_digest->data_seg_length >> 16) & 0xff;
        hdr.dw2.data_segment_length[1] = (tgt_digest->data_seg_length >>  8) & 0xff;
        hdr.dw2.data_segment_length[2] = tgt_digest->data_seg_length & 0xff;
        hdr.lun.lun_64 = io->iscsi_lun; /* already in BE */
        hdr.itt = ocs_htobe32(io->init_task_tag);
        hdr.ttt = ocs_htobe32(hio->ttt);
        hdr.exp_status_sn = ocs_htobe32(tgt_digest->exp_statsn);
        hdr.data_sn = ocs_htobe32(tgt_digest->datasn);
        hdr.buffer_offset = ocs_htobe32(tgt_digest->buffer_offset);

        rc =  ocs_iscsi_send_reject(cxn, &hdr, sizeof(iscsi_data_out_hdr_t),
                        ISCSI_REJECT_REASON_DATA_DIGEST_ERR);
    }
    return rc;
}

/**
 * @brief Function to receive connection events.
 *
 * @param arg Pointer to the iSCSI structure that represents this device.
 * @param cxn_event Identifies the event that was received.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_cxn_event_cb(void *arg, ocs_hal_cxn_event_t *cxn_event)
{
    ocs_iscsi_t   *iscsi = (ocs_iscsi_t *)arg;
    int32_t        rc = -1;

    switch(cxn_event->event) {
    case OCS_HAL_CXN_NEW:
        rc = ocs_cxn_new_tgt_connection(iscsi, cxn_event->params.cxn_new.cid);
        break;

    case OCS_HAL_CXN_INVALID:
        rc = ocs_iscsi_cxn_event_invalid(iscsi,
                         cxn_event->params.cxn_invalid.cxn,
                         cxn_event->params.cxn_invalid.code);
        break;

    case OCS_HAL_CXN_TGT_DATA_DIGEST:
        rc = ocs_iscsi_cxn_event_data_digest(iscsi,
                             &cxn_event->params.tgt_digest);
        break;

    default:
        ocs_log_test(iscsi->os, "Unhandled cxn event received %d\n",
                 cxn_event->event);
        break;
    }

    return rc;
}


/**
 * @brief Decode a LU Number according to SAM.
 *
 * @param lu Pointer to LU data
 *
 * @note Only handles single level LU.
 *
 * @todo Move to generic FC file.
 *
 * @return Returns LU number or max int on error.
 */
static uint32_t
ocs_iscsi_decode_lun(uint8_t *lu)
{
    uint32_t lun = UINT32_MAX;
    uint8_t  address_method = -1;

    address_method = lu[0] >> ISCSI_LUN_ADDRESS_METHOD_SHIFT;

    switch (address_method) {
    case ISCSI_LUN_ADDR_METHOD_PERIPHERAL:
    {
        uint8_t bus_identifier = lu[0] & ~ISCSI_LUN_ADDRESS_METHOD_MASK;

        if (0 == bus_identifier) {
            lun = lu[1];
        } else {
            ocs_log_test(NULL, "unsupported bus identifier %#02x (LU %02x %02x %02x %02x ...\n",
                     bus_identifier, lu[0], lu[1], lu[2], lu[3]);
        }
        break;
    }
    case ISCSI_LUN_ADDR_METHOD_FLAT:
    {
        lun = (lu[0] & ~ISCSI_LUN_ADDRESS_METHOD_MASK) << 8 | lu[1];
        break;
    }
    case ISCSI_LUN_ADDR_METHOD_EXTENDED:
    {
        uint8_t length, extended_address_method;

        length = (lu[0] & 0x30) >> 4;
        extended_address_method = lu[0] & 0xf;

        if ((1 == length) && (2 == extended_address_method)) {
            lun = (lu[1] << 16) | (lu[2] << 8) | lu[3];
        } else {
            ocs_log_test(NULL, "unsupported extended addressing method (length=%#x method=%#x)\n",
                     length, extended_address_method);
        }
        break;
    }
    default:
        ocs_log_test(NULL, "unsupported LU address method %#02x\n", address_method);
    }

    return lun;
}


/**
 * @brief Function to receive unsolicited command PDUs.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @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.
 *
 * @return Returns 0 on success.
 */
static ocs_pdu_process_rtn_e
ocs_iscsi_recv_cmd(ocs_iscsi_t *iscsi,
           ocs_cxn_t   *cxn,
           ocs_hal_rq_buffer_t *hdr,
           uint32_t hdr_len,
           ocs_hal_rq_buffer_t *data,
           uint32_t data_len)
{
    ocs_t *ocs = iscsi->os;
    iscsi_cmd_hdr_t *cmd_hdr = hdr->dma.virt;
    ocs_io_t *io;
    uint32_t flags = 0;
    //uint32_t exp_xfer_len = 0;
    ocs_pdu_process_rtn_e rc = OCS_PDU_RTN_PROCESSED;
    uint32_t imm_length;
    uint32_t lun;

    if (cxn->cxn_state != CONN_STATE_FULL_FEATURE) {
        ocs_log_test(iscsi->os, "called with connection state %d",
                 cxn->cxn_state);
        ocs_cxn_close(cxn, TRUE);
        return OCS_PDU_RTN_GENERAL_ERROR;
    }

        //exp_xfer_len = ocs_be32toh(cmd_hdr->ExpectedDataTransferLength);

    io = ocs_scsi_io_alloc(cxn, OCS_SCSI_IO_ROLE_RESPONDER);

    if (io != NULL) {
        io->cmd_sn = ocs_be32toh(cmd_hdr->CmdSN);
        io->init_task_tag = ocs_be32toh(cmd_hdr->itt);
        io->exp_xfer_len = ocs_be32toh(cmd_hdr->ExpectedDataTransferLength);
        io->iscsi_lun = cmd_hdr->lun.lun_64;
        lun = ocs_iscsi_decode_lun(cmd_hdr->lun.lun_8);

        switch(cmd_hdr->attributes) {
        case ISCSI_UNTAGGED_TAG:
            flags |= OCS_SCSI_CMD_UNTAGGED;
            break;
        case ISCSI_SIMPLE_TAG:
            flags |= OCS_SCSI_CMD_SIMPLE;
            break;
        case ISCSI_ORDERED_QUEUE_TAG:
            flags |= OCS_SCSI_CMD_ORDERED;
            break;
        case ISCSI_HEAD_OF_QUEUE_TAG:
            flags |= OCS_SCSI_CMD_HEAD_OF_QUEUE;
            break;
        case ISCSI_ACA_TAG:
            flags |= OCS_SCSI_CMD_ACA;
            break;
        default:
            break;
        }
        if (cmd_hdr->wr) {
            flags |= OCS_SCSI_CMD_DIR_IN;
        }
        if (cmd_hdr->rd) {
            flags |= OCS_SCSI_CMD_DIR_OUT;
        }

        //TODO Handle immediate data with DIF
        io_trace(io, "IO started (instance%d)\n", io->instance_index);

        /*
         * Note: The ocs_scsi_recv_cmd will return an error when it sees an
         *   inquiry for a non-existent lun. We don't want this to drop
         *   the connection, so ignore the return code here.
         */
        if (ocs_is_target_enabled()) {
            if (data_len > 0 &&
                data != NULL) {
                imm_length = ((uint32_t)cmd_hdr->dw2.data_segment_length[0] << 16) |
                    ((uint32_t)cmd_hdr->dw2.data_segment_length[1] << 8) |
                    cmd_hdr->dw2.data_segment_length[2];
                io->scsi_mem_xfer_size = imm_length;
                io->scsi_mem_offset = imm_length;
                io->scsi_wire_xfer_size = imm_length;
                io->scsi_wire_offset = imm_length;

                ocs_scsi_recv_cmd_first_burst(io,
                                  lun,
                                  cmd_hdr->cdb,
                                  16,
                                  flags,
                                  &data->dma,
                                  imm_length);
            } else {
                ocs_scsi_recv_cmd(io,
                          lun,
                          cmd_hdr->cdb,
                          16,
                          flags);
            }
        }
    } else {
        ocs_log_test(iscsi->os, "No IO object on connection %s, dropping command\n",
                 cxn->display_name);
        rc = OCS_PDU_RTN_NO_RESOURCES;
    }
    return rc;
}

/**
 * @brief Callback function used to free an IO for a rejected task management function.
 *
 * @param io Pointer to the OS io object.
 * @param status Status of the command.
 * @param flags Flags.
 * @param arg Points to the io object.
 *
 * @return Returns 0 on success.
 */
/* Callback used by send_rd_data(), recv_wr_data(), send_resp() */
static int32_t ocs_iscsi_recv_tm_cb(ocs_io_t *io, ocs_scsi_io_status_e status,
                    uint32_t flags, void *arg)
{
    /* This is used for rejected TMF functions, just free the IOs. */
    ocs_scsi_io_free(io);
    return 0;
}


/**
 * @brief Function to receive unsolicited task management PDUs.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param cxn Pointer to the connection object.
 * @param hdr DMA memory information for the header.
 * @param hdr_len Length of the header received.
 *
 * @return Returns 0 on success.
 */
static ocs_pdu_process_rtn_e
ocs_iscsi_recv_tm(ocs_iscsi_t *iscsi,
          ocs_cxn_t   *cxn,
          ocs_hal_rq_buffer_t *hdr,
          uint32_t     hdr_len)
{
    ocs_t *ocs = iscsi->os;
    iscsi_task_mgmt_hdr_t *tm_hdr = hdr->dma.virt;
    ocs_io_t *io;
    ocs_pdu_process_rtn_e rc = OCS_PDU_RTN_PROCESSED;
    ocs_scsi_tmf_cmd_e tmf_cmd;
    ocs_io_t *abortio = NULL;
    ocs_io_t *listio;
    uint32_t cmd_sn = ocs_be32toh(tm_hdr->cmd_sn);
    uint32_t reftag = ocs_be32toh(tm_hdr->ref_task_tag);
    uint32_t refcmdsn = ocs_be32toh(tm_hdr->ref_cmd_sn);
    uint32_t lun;

    if (cxn->cxn_state != CONN_STATE_FULL_FEATURE) {
        ocs_log_test(iscsi->os, "called with connection state %d",
                 cxn->cxn_state);
        ocs_cxn_close(cxn, TRUE);
        return OCS_PDU_RTN_GENERAL_ERROR;
    }

    io = ocs_scsi_io_alloc(cxn, OCS_SCSI_IO_ROLE_RESPONDER);
    if (io != NULL) {
        io->init_task_tag = ocs_be32toh(tm_hdr->itt);
        io->iscsi_lun = tm_hdr->lun.lun_64;
        lun = ocs_iscsi_decode_lun(tm_hdr->lun.lun_8);

        if (ocs_is_target_enabled()) {
            ocs_log_debug(iscsi->os, "TM (instance%d) started for ITT 0x%x, ref ITT 0x%x\n",
                      io->instance_index, io->init_task_tag, reftag);

            switch (tm_hdr->function) {
            case ISCSI_ABORT_TASK:
                tmf_cmd = OCS_SCSI_TMF_ABORT_TASK;
                /* lookup IO to abort via the reference task tag */
                ocs_node_lock(cxn);
                ocs_list_foreach(&cxn->active_ios, listio) {
                    if (listio->init_task_tag == reftag &&
                        (listio->cmd_sn == refcmdsn ||
                         cmd_sn == refcmdsn)) {
                        abortio = listio;
                        break;
                    }
                }
                ocs_node_unlock(cxn);

                /* Complete the request if the IO is not found (SAM) */
                if (abortio == NULL) {
                    int32_t rc;
                    rc = ocs_session_abort_itt(cxn->session, reftag);
                    ocs_iscsi_send_tmf_resp
                        (io,
                         (rc == 0 ? ISCSI_TASK_MGMT_FUNCTION_COMPLETE :
                          ISCSI_TASK_MGMT_TASK_DOES_NOT_EXIST),
                         ocs_iscsi_recv_tm_cb, io);
                    return OCS_PDU_RTN_PROCESSED;
                } else {
#if defined(OCS_INCLUDE_DEBUG)
                    ocs_iscsi_dump_io(iscsi, abortio);
#endif
                }
                break;
            case ISCSI_ABORT_TASK_SET:
                ocs_session_abort_cmdsn(cxn->session, cmd_sn);
                tmf_cmd = OCS_SCSI_TMF_ABORT_TASK_SET;
                break;
            case ISCSI_CLEAR_ACA:
                tmf_cmd = OCS_SCSI_TMF_CLEAR_ACA;
                break;
            case ISCSI_CLEAR_TASK_SET:
                ocs_session_abort_cmdsn(cxn->session, cmd_sn);
                tmf_cmd = OCS_SCSI_TMF_CLEAR_TASK_SET;
                break;
            case ISCSI_LUN_RESET:
                /* Abort queued commands on all active sessions */
                ocs_session_all_abort_cmdsn(iscsi, cmd_sn);
                tmf_cmd = OCS_SCSI_TMF_LOGICAL_UNIT_RESET;
                break;
            case ISCSI_TARGET_WARM_RESET:
            case ISCSI_TARGET_COLD_RESET:
            case ISCSI_TASK_REASSIGN:
            default:
                rc = ocs_iscsi_send_tmf_resp(io,
                                 ISCSI_TASK_MGMT_NOT_SUPPORTED,
                                 ocs_iscsi_recv_tm_cb,
                                 io);
                return (rc == 0 ? OCS_PDU_RTN_PROCESSED : OCS_PDU_RTN_GENERAL_ERROR);
            }

            ocs_scsi_recv_tmf(io,
                      lun,
                      tmf_cmd,
                      abortio,
                      0);
        }
    } else {
        ocs_log_test(iscsi->os, "No IO object on connection %s, dropping TM\n",
                 cxn->display_name);
        rc = OCS_PDU_RTN_GENERAL_ERROR;
    }
    return rc;
}


/**
 * @brief Function to receive unsolicited task management response PDUs.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param cxn Pointer to the connection object.
 * @param hdr DMA memory information for the header.
 * @param hdr_len Length of the header received.
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_recv_tm_rsp(ocs_iscsi_t *iscsi,
              ocs_cxn_t   *cxn,
              ocs_hal_rq_buffer_t *hdr,
              uint32_t     hdr_len)
{
    iscsi_task_mgmt_response_t *tm_hdr = hdr->dma.virt;
    uint32_t itt = ocs_be32toh(tm_hdr->itt);
    ocs_io_t *io = NULL, *tmp_io;
    ocs_scsi_cmd_resp_t rsp;
    ocs_scsi_rsp_io_cb_t cb;
    int32_t rc = 0;

    if (cxn->cxn_state != CONN_STATE_FULL_FEATURE) {
        ocs_log_test(iscsi->os, "called with connection state %d",
                 cxn->cxn_state);
        ocs_cxn_close(cxn, TRUE);
        return -1;
    }

    /*
     * Loop through the active IOs on this node to find the matching ITT.
     */
    ocs_node_lock(cxn);
    ocs_list_foreach(&cxn->active_ios, tmp_io) {
        if (tmp_io->hio != NULL &&
            tmp_io->hio->itt == itt) {
            io = tmp_io;
            break;
        }
    }
    ocs_node_unlock(cxn);

    if (io) {
        ocs_assert(io->scsi_io_cb, -1);

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

        /* Call initiator server completion */
        if (io->scsi_io_cb) {
            uint32_t flags = 0;
            ocs_scsi_io_status_e cb_status = OCS_SCSI_STATUS_ERROR;

            ocs_memset(&rsp, 0, sizeof(ocs_scsi_cmd_resp_t));

            if (tm_hdr->response == ISCSI_TASK_MGMT_FUNCTION_COMPLETE) {
                rsp.scsi_status = 0;
                cb_status = OCS_SCSI_STATUS_GOOD;
            } else {
                rsp.scsi_status = 2;
                cb_status = OCS_SCSI_STATUS_ERROR;
            }

            cb = io->scsi_io_cb;

            /* Clear the callback before invoking the callback */
            io->scsi_io_cb = NULL;

            io_trace(io, "TM IO completed with status 0x%x (flags 0x%x)\n",
                 cb_status, flags);

            cb(io, cb_status, &rsp, flags, io->scsi_io_cb_arg);
        }
    } else {
        rc = -1;
        ocs_log_test(iscsi->os, "IO with ITT was not found 0x%x", itt);
    }
    return rc;
}


/**
 * @brief Function to process unsolicited PDUs for a target.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @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 reject_reason Returns the reject reason.
 *
 * @return Returns 0 on success.
 */
ocs_pdu_process_rtn_e
ocs_iscsi_tgt_process_cmd_sn(ocs_iscsi_t *iscsi,
                 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,
                 uint8_t    *reject_reason)
{
    iscsi_login_cmd_hdr_t *bhs = hdr->dma.virt;
    ocs_pdu_process_rtn_e rc = OCS_PDU_RTN_PROCESSED;

    *reject_reason = 0;
    switch (bhs->opcode) {
    case ISCSI_CMD_CMD:
        rc = ocs_iscsi_recv_cmd(iscsi,
                    cxn,
                    hdr,
                    hdr_len,
                    data,
                    data_len);
        break;

    case ISCSI_CMD_TASK:
        rc = ocs_iscsi_recv_tm(iscsi, cxn, hdr, hdr_len);
        break;

    case ISCSI_CMD_NOOP:
        rc = ocs_iscsi_recv_nop_out(cxn, hdr, hdr_len, data, data_len);
        break;

    case ISCSI_CMD_LOGIN:
        rc = ocs_iscsi_recv_login(cxn, hdr, hdr_len, data, data_len);
        break;

    case ISCSI_CMD_TEXT:
        rc = ocs_iscsi_recv_text(cxn, hdr, hdr_len, data, data_len, reject_reason);
        break;

    case ISCSI_CMD_LOGOUT:
        rc = ocs_iscsi_recv_logout(cxn, hdr, hdr_len);
        break;

    case ISCSI_CMD_SNACK:
        *reject_reason = ISCSI_REJECT_REASON_SNACK_REJECT;
        rc =  OCS_PDU_RTN_SEND_REJECT;
        break;

    case ISCSI_CMD_DATA_OUT:
    default:
        ocs_log_test(iscsi->os, "received unexpected OPCODE 0x%x", bhs->opcode);
        *reject_reason = ISCSI_REJECT_REASON_PROTOCOL_ERR;
        rc = OCS_PDU_RTN_SEND_REJECT;
        break;
    }

    return rc;
}


/**
 * @brief Function to receive unsolicited PDUs for an initiator.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @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.
 */
static int32_t
ocs_iscsi_unsolicited_event_ini(ocs_iscsi_t *iscsi,
                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_t *ocs = iscsi->os;
    iscsi_login_cmd_hdr_t *bhs = hdr->dma.virt;
    int32_t rc = 0;

    if ((cxn->cxn_state == CONN_STATE_NEW_CONN ||
         cxn->cxn_state == CONN_STATE_LOGIN_PROGRESS) &&
        bhs->opcode != ISCSI_RESP_LOGIN) {
        ocs_log_test(iscsi->os,
                 "startup connection rcvd opcode 0x%x instead of login resp, state=%u",
                 bhs->opcode,
                 cxn->cxn_state);
        ocs_iscsi_rx_buffers_free(iscsi, hdr, data);
        ocs_cxn_close(cxn, TRUE);
        return -1;
    }

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

    /*
     * The statSn processing is handled in the FW, so we only have to capture
     * the value on the final login response.
     *
     * The command window will be typically handled in the normal IO completion
     * path, so ignore it for now as it should only be for login, which is all
     * done with the immediate bit set.
     */

    switch (bhs->opcode) {
    case ISCSI_RESP_LOGIN:
        rc = ocs_iscsi_recv_login_rsp(cxn, hdr, hdr_len, data, data_len);
        if (ocs_is_initiator_enabled()) {
            if (rc == 0 &&
                cxn->cxn_state == CONN_STATE_FULL_FEATURE) {
                if (ocs_scsi_new_target((ocs_node_t *) cxn)) {
                    ocs_log_test(iscsi->os, "CID 0x%x failed adding target to initiator server\n",
                             cxn->conn_hdl);
                } else {
                    ocs_log_debug(iscsi->os, "ocs_scsi_new_target() success\n");
                }
            }
        }
        break;

    case ISCSI_RESP_NOOP:
        rc = ocs_iscsi_recv_nop_in(cxn, hdr, hdr_len, data, data_len);
        break;

    case ISCSI_RESP_LOGOUT:
        rc = ocs_iscsi_recv_logout_rsp(cxn, hdr, hdr_len);
        break;

    case ISCSI_RESP_TASK:
        rc = ocs_iscsi_recv_tm_rsp(iscsi, cxn, hdr, hdr_len);
        break;

    case ISCSI_RESP_TEXT:
    case ISCSI_RESP_ASYNC:
    case ISCSI_RESP_REJECT:
    case ISCSI_RESP_RESP:
    case ISCSI_RESP_R2T:
    case ISCSI_RESP_DATAIN:
    default:
        ocs_log_test(iscsi->os, "received unexpected OPCODE 0x%x", bhs->opcode);
        rc = -1;
        break;
    }

    return rc;
}


/**
 * @brief Function to receive unsolicited PDUs.
 *
 * @param arg Pointer to the iSCSI structure that represents this device.
 * @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.
 */
static int32_t
ocs_iscsi_unsolicited_event_cb(void  *arg,
                   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 = (ocs_iscsi_t *)arg;
    int32_t rc = 0;
    ocs_assert(cxn, -1);
    ocs_assert(hdr, -1);

    if (cxn->is_ini_cxn) {
        /* If there is an initiator unsol handler call that */
        if (iscsi->unsol_ini) {
            return iscsi->unsol_ini(arg, cxn, hdr, hdr_len, data, data_len, code);
        } else {
            rc = ocs_iscsi_unsolicited_event_ini(iscsi,
                    cxn,
                    hdr,
                    hdr_len,
                    data,
                    data_len,
                    code);
        }
    } else {
        rc = ocs_session_tgt_unsol_pdu_recv(cxn,
                            hdr,
                            hdr_len,
                            data,
                            data_len,
                            code);
    }

    if (rc != OCS_LOGIN_REQUEST_QUEUED) {
        ocs_iscsi_rx_buffers_free(iscsi, hdr, data);
    }

    /* close the connection on any errors */
    if (rc &&
        rc != OCS_LOGIN_REQUEST_QUEUED) {
        ocs_log_test(iscsi->os, "Error processing unsolicited PDU\n");
        if (cxn->is_ini_cxn) {
            rc = ocs_iscsi_send_logout(cxn, TRUE, LOGOUT_REASON_CLOSE_CONN);
        } else {
            rc = ocs_iscsi_cxn_request_logout(cxn);
        }

        /* Close the connection if we can't logout/request logout */
        if (rc &&
            rc != OCS_LOGIN_REQUEST_QUEUED) {
            ocs_cxn_close(cxn, TRUE);
        }
    }

    return rc;
}

/**
 * @ingroup iscsi_main
 * @brief Initialize the memory tracker.
 *
 * @param tracker Pointer to the tracker to initialize.
 */
void ocs_iscsi_tracker_init(ocs_iscsi_mem_tracker_t *tracker)
{
    tracker->num_objs    = 0;
    tracker->pages       = NULL;
    tracker->num_pages   = 0;
    tracker->obj_per_page    = 0;
    tracker->obj_size    = 0;
    tracker->obj_size_padded = 0;
}


/**
 * @ingroup iscsi_main
 * @brief Free the memory associated with a memory tracker.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param tracker Pointer to the tracker.
 */
void ocs_iscsi_tracker_free(ocs_iscsi_t *iscsi,
                ocs_iscsi_mem_tracker_t *tracker)
{
    uint32_t  indx;

    if (tracker->pages) {
        for (indx = 0; indx < tracker->num_pages; indx ++)
        {
            ocs_dma_free(iscsi->os, &tracker->pages[indx]);
            ocs_memset(&tracker->pages[indx], 0, sizeof(ocs_dma_t));
        }
        ocs_free(iscsi->os, tracker->pages,
             sizeof(ocs_dma_t) * (tracker->num_pages + tracker->num_objs));
        ocs_iscsi_tracker_init(tracker);
    }
}


/**
 * @ingroup iscsi_main
 * @brief Allocate a group of objects uses pages to minimize waste.
 *
 * @par Description
 * Used to allocate groups of objects into pages and then pull them
 * out. This is done because DMA memory is allocated on page boundaries,
 * which causes wasted space. By grouping the structures together, we attempt
 * to consolidate as many per page as possible.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param tracker Pointer to the tracker.
 * @param zero If non-zero, then the memory will be zeroed.
 * @param object_size The size of the objects in bytes.
 * @param alignment Minimum byte alignment.
 * @param num_objects Number of object to allocate.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
int32_t
ocs_iscsi_tracker_alloc(ocs_iscsi_t *iscsi,
            ocs_iscsi_mem_tracker_t *tracker,
            uint8_t  zero,
            uint32_t object_size,
            uint32_t alignment,
            uint32_t num_objects)
{
    uint32_t  indx;
    uint32_t  padded_size;
    uint32_t  obj_per_page;
    uint32_t  num_pages;
    uint32_t  alloc_size = OCS_ISCSI_PAGE_SIZE;

    /* Calculated the padded object size based on the alignment */
    if (alignment == 0 ||
        (alignment < object_size &&
         (object_size % alignment == 0))) {
        padded_size = object_size;
    } else {
        padded_size = object_size + (object_size % alignment);
    }
    ocs_log_debug(iscsi->os, "alignment %d, object size %d, padded size %d\n",
              alignment, object_size, padded_size);

    obj_per_page = OCS_ISCSI_PAGE_SIZE / padded_size;

    /* Acoount for the case where the object is bigger than a page */
    if (obj_per_page == 0) {
        alloc_size = (((padded_size + (OCS_ISCSI_PAGE_SIZE - 1)) / OCS_ISCSI_PAGE_SIZE) *
                  OCS_ISCSI_PAGE_SIZE);
        obj_per_page = 1;
    }

    num_pages = ((num_objects + (obj_per_page - 1)) / obj_per_page);

    tracker->pages = (ocs_dma_t *)ocs_malloc(iscsi->os, sizeof(ocs_dma_t) *
                         (num_pages + num_objects),
                         OCS_M_ZERO | OCS_M_NOWAIT);
    if (tracker->pages == NULL) {
        ocs_log_err(iscsi->os, "memory allocation failed for ocs_dma_t entries\n");
        return -ENOMEM;
    }

    for (indx = 0; indx < num_pages; indx++) {
        if (ocs_dma_alloc(iscsi->os,
                  &tracker->pages[indx],
                  alloc_size,
                  alignment)) {
            uint32_t  indx_free;

            ocs_log_err(iscsi->os,
                    "memory allocation failed page %d\n",
                    indx);

            for (indx_free = 0; indx_free < indx; indx_free++)
            {
                ocs_dma_free(iscsi->os, &tracker->pages[indx_free]);
            }
            ocs_free(iscsi->os, tracker->pages, sizeof(ocs_dma_t) * num_pages);
            ocs_iscsi_tracker_init(tracker);
            return -ENOMEM;
        }
        if (zero) {
            ocs_memset(tracker->pages[indx].virt, 0, alloc_size);
        }
    }

    /*
     * Calculate the DMA values for each object - Required for Rx buffers.
     */
    for (indx = 0; indx < num_objects; indx++) {
        uint32_t page_index = indx / obj_per_page;
        uint32_t mem_offset = ((indx % obj_per_page) * padded_size);
        ocs_dma_t *mem      = &tracker->pages[num_pages + indx];

        mem->virt = ((uint8_t*)tracker->pages[page_index].virt) + mem_offset;
        mem->phys = tracker->pages[page_index].phys + mem_offset;
        mem->size = object_size;
    }

    tracker->num_objs    = num_objects;
    tracker->num_pages   = num_pages;
    tracker->obj_per_page    = obj_per_page;
    tracker->obj_size    = object_size;
    tracker->obj_size_padded = padded_size;
    return 0;
}

/**
 * @ingroup iscsi_main
 * @brief Helper to return the pointers for a specific object in the group.
 *
 * @param tracker Pointer to the tracker.
 * @param obj_offset Number of the object to retrieve.
 *
 * @return Returns the pointer on success, NULL otherwise.
 */
ocs_dma_t *
ocs_iscsi_tracker_calc(ocs_iscsi_mem_tracker_t *tracker,
               uint32_t         obj_offset)
{
    ocs_dma_t *rval = NULL;
    if (obj_offset < tracker->num_objs) {
        rval = &tracker->pages[tracker->num_pages + obj_offset];
    }
    return rval;
}

/**
 * @brief Add a receive buffer pair to the Receive Queue, if an error is received, then queue the buffer.
 *
 * @param iscsi Pointer to the iSCSI object.
 * @param header DMA memory for the unsolicited header.
 * @param payload DMA memory for the unsolicited payload.
 */
void
ocs_iscsi_rx_buffers_free(ocs_iscsi_t *iscsi, ocs_hal_rq_buffer_t *header, ocs_hal_rq_buffer_t *payload) {
    ocs_hal_rtn_e rc;

    rc = ocs_hal_rxbuffer(iscsi->hal, header, payload);
    if (rc != OCS_HAL_RTN_SUCCESS) {
        ocs_log_test(iscsi->os, "Failed post RQ buffers - buffers leaked\n");
    }
}

void ocs_iscsi_cxn_req_invalidate(ocs_iscsi_t *iscsi)
{
    ocs_hal_t *hal = iscsi->hal;
    ocs_sli_port_t *sport;
    int32_t inters;

    if (hal->domain == NULL) {
        return;
    }

    /* Return if no active connections */
    if (hal->domain->node_instance_count == 0) {
        return;
    }

    ocs_log_debug(iscsi->os, "Invalidate active connections\n");
    ocs_domain_lock(hal->domain);
    ocs_list_foreach(&hal->domain->sport_list, sport) {
        ocs_sport_lock(sport);

        ocs_hal_cxn_req_invalidate(&sport->node_list);

        ocs_sport_unlock(sport);
    }
    ocs_domain_unlock(hal->domain);

    inters = 100;
    do {
        ocs_delay_usec(10000);
        inters--;
    } while (inters);
    ocs_log_debug(iscsi->os, "Done waiting for connection invalidation\n");
}