ocs_iscsi_api.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 API interface functions.
 */

/*!
@defgroup iscsi_api iSCSI target/initiator interface
*/

#include "ocs.h"
#include "ocs_iscsi_spec.h"
#include "ocs_isns.h"

#define OCS_ISCSI_API_INIT_DELAY_MS 100

static int32_t ocs_iscsi_api_link_configure_thread(ocs_thread_t *mythread);

/**
 * @brief Get a next free sport object index
 *
 * @param ocs Pointer to the ocs structure.
 *
 * @return Returns sport inx on success.
 */
ocs_sport_t *ocs_iscsi_tgt_get_free_sport(ocs_t *ocs)
{
    ocs_sport_t *sport = NULL;
    int32_t inx;

    ocs_domain_lock(ocs->hal.domain);
    for (inx = 0; inx < OCS_MAX_SPORTS; inx++) {
        if (ocs->sport[inx].created == FALSE) {
            sport = &ocs->sport[inx];
            sport->index = inx;
            break;
        }
    }
    ocs_domain_unlock(ocs->hal.domain);

    return sport;
}

/**
 * @brief Add sport to iscsi target
 *
 * @param ocs Pointer to the ocs structure.
 * @param scst_tgt Pointer to SCST target 
 * @param sport SPORT that associates SCST target
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_iscsi_tgt_add_sport(ocs_t *ocs, ocs_sport_t *sport)
{
    int8_t *mac;
    extern ocs_mgmt_functions_t sport_mgmt_functions;

    mac = ocs_hal_get_ptr(&ocs->hal, OCS_HAL_MAC_ADDR);
    if (mac == NULL) {
        ocs_log_err(ocs, "HAL mac address get failed\n");
        return -1;
    }

    ocs_domain_lock(ocs->hal.domain);

    ocs_memcpy(sport->mac, mac,
           ARRAY_SIZE(sport->mac));
    ocs_snprintf(sport->mac_str,
             sizeof(sport->mac_str),
             "%02x%02x%02x%02x%02x%02x",
             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

    sport->domain = ocs->domain;
    sport->tgt_id = sport->index;
    sport->created = TRUE;
    sport->ocs = ocs;
    sport->mgmt_functions = &sport_mgmt_functions;

    ocs_sport_lock_init(sport);
    ocs_list_init(&sport->node_list, ocs_node_t, link);
    ocs_list_add_tail(&ocs->domain->sport_list, sport);

    ocs_domain_unlock(ocs->hal.domain);

    return 0;
}

/**
 * @brief Delete sport from iscsi target
 *
 * @param ocs Pointer to the ocs structure
 * @param sport_index SPORT index to be deleted
 *
 */
void ocs_iscsi_tgt_del_sport(ocs_t *ocs, uint32_t sport_index)
{
    ocs_sport_t *sport;
    ocs_sport_t *sport_next;

    ocs_domain_lock(ocs->hal.domain);
    ocs_list_foreach_safe(&ocs->domain->sport_list, sport,
                  sport_next) {
        if (sport->index == sport_index && sport->created == TRUE) {
            sport->created = FALSE;
            ocs_list_remove(&ocs->domain->sport_list,
                    sport);
            break;
        }
    }
    ocs_domain_unlock(ocs->hal.domain);
}

/**
 * @brief Adds a target.
 *
 * @param ocs Pointer to the ocs structure.
 * @param name Target name.
 * @param alias Target alias.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_iscsi_tgt_add(ocs_t *ocs, char* name, char* alias)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    iscsi_api_tgt_t *tgt;

    tgt = ocs_malloc(ocs, sizeof(iscsi_api_tgt_t), OCS_M_ZERO | OCS_M_NOWAIT);
    if (tgt == NULL) {
        ocs_log_err(ocs, "failed to allocate target structure\n");
        return -1;
    }
    ocs_strncpy(tgt->tgt_name, name, ARRAY_SIZE(tgt->tgt_name));
    ocs_strncpy(tgt->tgt_alias, alias, ARRAY_SIZE(tgt->tgt_alias));

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_add_tail(&iscsi_api->tgt_list, tgt);
    ocs_unlock(&iscsi_api->api_list_lock);

    ocs_log_debug(ocs, "iSCSI target %s created\n", name);

    return 0;
}

/**
 * @brief Returns the target name based on the index.
 *
 * @param ocs Pointer to the ocs structure.
 * @param index Index into the target name list.
 *
 * @return Returns pointer to the target name, or NULL if the index exceeds the list.
 */
char *
ocs_iscsi_tgt_get_names(ocs_t *ocs, uint32_t index)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    iscsi_api_tgt_t *tgt;
    uint32_t count = 0;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->tgt_list, tgt) {
        if (count == index) {
            ocs_unlock(&iscsi_api->api_list_lock);
            return tgt->tgt_name;
        }
        count++;
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return NULL;
}


/**
 * @brief Returns the target alias based on the index.
 *
 * @param ocs Pointer to the ocs structure.
 * @param index Index into the target name list.
 *
 * @return Returns pointer to the target name, or NULL if the index exceeds the list.
 */
char *
ocs_iscsi_tgt_get_alias(ocs_t *ocs, uint32_t index)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    iscsi_api_tgt_t *tgt;
    uint32_t count = 0;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->tgt_list, tgt) {
        if (count == index) {
            ocs_unlock(&iscsi_api->api_list_lock);
            return tgt->tgt_alias;
        }
        count++;
    }
    ocs_unlock(&iscsi_api->api_list_lock);
    return NULL;
}


/**
 * @brief Returns the IP address of the target name based on the index.
 *
 * @param ocs Pointer to the ocs structure.
 * @param tgt_name The iSCSI target name.
 * @param index Index into the IP Address list.
 *
 * @return Pointer to the IP address, or NULL if the index exceeds the list.
 */
ocs_ip_address_t *
ocs_iscsi_tgt_get_ip_address(ocs_t *ocs, char *tgt_name, uint32_t index)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    ocs_ip_address_t *rc = NULL;

    /*
     * Since all the targets share IP addresses, we can skip the target
     * name and just lookup in the IP Address table.
     *
     * Note: Not all IP addresses may be listened on, so we only count
     *       the listening IPs here.
     */
    if (index > iscsi->num_ips)
        return rc;
    
    if (iscsi->ip_info[index].listening)
        rc = &iscsi->ip_info[index].ip; 

    return rc;
}


/**
 * @brief Returns the portal group of an IP address of the target name.
 *
 * @param ocs Pointer to the ocs structure.
 * @param tgt_name The iSCSI target name.
 * @param ip_address IP address.
 *
 * @return Returns the target portal group tag.
 */
uint32_t
ocs_iscsi_tgt_get_portal_group(ocs_t *ocs, char *tgt_name, ocs_ip_address_t *ip_address)
{
    /* Always use group 1 since sessions can span the addresses we use */
    return 1;
}


/**
 * @brief Returns TRUE if CHAP is required for the session type.
 *
 * @param ocs Pointer to the ocs structure.
 * @param tgt_name The iSCSI target name.
 * @param type Either discovery or normal sessions.
 *
 * @return Returns TRUE if CHAP is required.
 */
uint8_t
ocs_iscsi_tgt_require_chap(ocs_t *ocs, char *tgt_name, ocs_session_type_e type)
{
    /* Do not require CHAP */
    return ocs->require_chap;
}


/**
 * @brief Checks if this initiator is allowed access to a target.
 *
 * @param ocs Pointer to the ocs structure.
 * @param tgt_name The iSCSI target name.
 * @param ini_name The iSCSI initiator name.
 *
 * @return Returns TRUE if access is allowed.
 */
uint32_t
ocs_iscsi_tgt_is_access_allowed(ocs_t *ocs, char *tgt_name, char *ini_name)
{
    /* Always allow access */
    return TRUE;
}


/**
 * @brief Return this initiator's name.
 *
 * @param ocs Pointer to the ocs structure.
 *
 * @return Pointer to the initiator name.
 */
char *
ocs_iscsi_ini_get_name(ocs_t *ocs)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    uint8_t *mac;

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

    snprintf(iscsi_api->ini_name,
         OCS_MAX_ISCSI_NAME,
         "%s:%02x%02x%02x%02x%02x%02x",
         ocs->iqn_prefix,
         mac[0], mac[1],mac[2],mac[3],mac[4],mac[5]);

    return iscsi_api->ini_name;
}


/**
 * @brief Returns the initiator alias
 *
 * @param ocs Pointer to the ocs structure
 *
 * @return Pointer to the initiator alias or NULL
 */
char *
ocs_iscsi_ini_get_alias(ocs_t *ocs)
{
    return "emulex:ini";
}


/**
 * @brief Initialize the higher level iSCSI software
 *
 * @param ocs Pointer to the ocs structure
 *
 * @return 0 for success
 */
int32_t
ocs_iscsi_api_initialize(ocs_t *ocs)
{
    ocs_ip_address_t ip;
    ocs_ip_address_t subnet;
    iscsi_api_t *iscsi_api;
    int32_t rc;

    ocs->iscsi_api = ocs_malloc(ocs, sizeof(iscsi_api_t),
                    OCS_M_ZERO | OCS_M_NOWAIT);
    if (ocs->iscsi_api == NULL) {
        ocs_log_err(ocs, "failed to allocate iscsi_api structure\n");
        return -1;
    }

    iscsi_api = ocs->iscsi_api;

    ocs_lock_init(ocs, &iscsi_api->api_list_lock, "iscsi API list lock");
    ocs_list_init(&iscsi_api->tgt_list, ocs_chap_user_t, link);
    ocs_list_init(&iscsi_api->chap_list, ocs_chap_user_t, link);
    ocs_list_init(&iscsi_api->portal_list, ocs_vlan_portal_info_t, link);

    ocs_sem_init(&iscsi_api->link_cfg_sem, 0, "link cfg sem");

    /* Convert the supplied local IP Address */
    if(ocs_strcmp(ocs->local_ip, "MGMT") == 0) {
        iscsi_api->enable_mgmt_flag = 1;
    } else if (ocs_strcmp(ocs->local_ip, "DHCP") == 0) {
        iscsi_api->ipsub.ip_type = OCS_IP_TYPE_DHCP_V4;
    } else if (ocs_strcmp(ocs->local_ip, "AutoV6") == 0) {
        iscsi_api->ipsub.ip_type = OCS_IP_TYPE_AUTO_V6;
    } else if (ocs_iscsi_inet_pton4(ocs->local_ip, &ip) == 0) {
        /* Convert the subnet */
        if (ocs_iscsi_inet_pton4(ocs->local_subnet, &subnet) == 0) {
            ocs_iscsi_ipsub_combine(&iscsi_api->ipsub, &ip, &subnet);
        } else {
            ocs_log_err(ocs, "IPv4 address supplied, but subnet is not an valid IPv4 subnet\n");
            ocs_free(ocs, iscsi_api, sizeof(iscsi_api_t));
            return -1;
        }

        /* Convert the gateway */
        if (ocs_iscsi_inet_pton4(ocs->gateway, &ip) == 0) {
            iscsi_api->set_gateway = TRUE;
            iscsi_api->gateway = ip;
        }
    } else if (ocs_iscsi_inet_pton6(ocs->local_ip, &ip) == 0) {
        if (ocs_iscsi_inet_pton6(ocs->local_subnet, &subnet) == 0) {
            ocs_iscsi_ipsub_combine(&iscsi_api->ipsub, &ip, &subnet);
        } else {
            ocs_log_err(ocs, "IPv6 address supplied, but subnet is not an valid IPv6 subnet\n");
            ocs_free(ocs, iscsi_api, sizeof(iscsi_api_t));
            return -1;
        }

        /* Convert the gateway */
        if (ocs_iscsi_inet_pton6(ocs->gateway, &ip) == 0) {
            iscsi_api->set_gateway = TRUE;
            iscsi_api->gateway = ip;
        }
    } else {
        ocs_log_err(ocs, "ERROR: Local address supplied is not a valid IPv4, IPv6, DHCP, AutoV6, or MGMT\n");
        ocs_free(ocs, iscsi_api, sizeof(iscsi_api_t));
        return -1;
    }

    /* Adjust static IP addresses based on the pci function */
    if (iscsi_api->ipsub.ip_type == OCS_IP_TYPE_V4) {
        iscsi_api->ipsub.ip_address[3] += ocs->instance_index;
    } else if (iscsi_api->ipsub.ip_type == OCS_IP_TYPE_V6) {
        iscsi_api->ipsub.ip_address[15] += ocs->instance_index;
    }

    /* Register to received link state change events */
    rc = ocs_iscsi_register_link_state_callback(ocs, ocs_iscsi_api_link_state);
    if (rc != 0) {
        ocs_log_err(ocs, "Failed to register a link state callback function\n");
    }

    /*
     * Start a thread to configure the link as we cannot call the API
     * functions from an interrupt context.
     */
    rc = ocs_thread_create(ocs, &iscsi_api->link_cfg_thread,
                   ocs_iscsi_api_link_configure_thread,
                   "Link cfg thread",
                   ocs,
                   OCS_THREAD_RUN);
    if (rc != 0) {
        ocs_log_err(ocs, "Link config thread start returned %d\n", rc);
    } else {
        iscsi_api->cfg_thread_started = TRUE;
    }

    return rc;
}


/**
 * @brief Initialize the higher level iSCSI software
 *
 * @param ocs Pointer to the ocs structure
 *
 * @return 0 for success
 */
int32_t
ocs_iscsi_api_shutdown(ocs_t *ocs)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    iscsi_api_tgt_t *tgt;
    ocs_vlan_portal_info_t *portal_info;
    ocs_vlan_portal_info_t *portal_next;
    ocs_chap_user_t *chap;
    uint32_t i;
    uint32_t num_ips;
    int32_t rc = 0;
    char ip_str[40];

    if (ocs->iscsi_api == NULL) {
        /* We never got initialized */
        return 0;
    }

    /* Cleanup the target list */
    ocs_lock(&iscsi_api->api_list_lock);
    while ((tgt = ocs_list_remove_head(&iscsi_api->tgt_list)) != NULL) {
        ocs_free(ocs, tgt, sizeof(iscsi_api_tgt_t));
    }

    /* Cleanup the CHAP secret list */
    while ((chap = ocs_list_remove_head(&iscsi_api->chap_list)) != NULL) {
        ocs_free(ocs, chap, sizeof(ocs_chap_user_t));
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    /* Wake up the configure thread */
    if (iscsi_api->cfg_thread_started) {
        if (ocs_thread_terminate(&iscsi_api->link_cfg_thread) != 0) {
            ocs_log_test(ocs, "Error stopping Link config thread\n");
        }
        ocs_sem_v(&iscsi_api->link_cfg_sem);
    }

    if (iscsi_api->link_configured) {
        num_ips = iscsi->num_ips;
        i = 0;
        while (i < num_ips) {
            rc = 0;
            format_ip_address(iscsi->ip_info[i].ip.ip_type,
                      iscsi->ip_info[i].ip.ip_address,
                      ip_str, sizeof(ip_str));

            /* Stop listening on the ip addresses */
            if (iscsi->ip_info[i].listening) {
                if ((rc = ocs_iscsi_listen_stop(ocs,
                                &iscsi->ip_info[i].ip,
                                iscsi->ip_info[i].tcp_port))) {
                    ocs_log_test(ocs, "failed Stopping Listen on IP %s\n",
                             ip_str);
                } else {
                    ocs_log_debug(ocs, "Stopped Listening on IP %s\n", ip_str);
                }
            }

            if (iscsi->ip_info[i].esi_listening) {
                if ((rc = ocs_iscsi_isns_esi_listen_stop(ocs,
                                     &iscsi->ip_info[i].ip,
                                     iscsi->ip_info[i].esi_port))) {
                    ocs_log_test(ocs, "failed Stopping ESI Listen on IP %s\n",
                             ip_str);
                } else {
                    ocs_log_debug(ocs, "Stopped ESI Listening on IP %s\n",
                              ip_str);
                }
            }

            if (iscsi_api->isns_registered) {
                if (ocs_isns_deregister(ocs, iscsi_api->isns_servers, iscsi_api->isns_eid) == 0) {
                    ocs_log_debug(ocs,"iSNS deregistration done successfully!\n");
                } else {
                    ocs_log_test(ocs,"ERROR: iSNS deregistration FAILED!\n");
                }
            }

            /* Remove any IP addresses added */
            if (iscsi->ip_info[i].ip_added) {
                ocs_ip_address_subnet_t ipsub;

                ocs_iscsi_ipsub_combine(&ipsub,
                            &iscsi->ip_info[i].ip,
                            &iscsi->ip_info[i].subnet);
                if ((rc = ocs_iscsi_ip_address_remove(ocs,
                                      iscsi->ip_info[i].portal,
                                      &ipsub))) {
                    ocs_log_test(ocs, "failed removing IP address %s\n", ip_str);
                } else {
                    ocs_log_debug(ocs, "removed IP address %s\n", ip_str);
                }
            }
            
            /* Check if ip_info entry cleanup failed, then move to next entry */
            if (rc) {
                i++;
            }

            /* Update num_ips after each entry removal */
            num_ips = iscsi->num_ips;
        } /* while end */
    }

    /* Cleanup the portal list */
    ocs_list_foreach_safe(&iscsi_api->portal_list, portal_info, portal_next) {
        rc = ocs_iscsi_portal_delete(ocs, portal_info->iface_handle);
        if (rc){
            ocs_log_err(ocs, "Delete IFACE handle %d failed\n",
                    portal_info->iface_handle);
        } else {
            ocs_log_debug(ocs, "Deleted IFACE handle %d of vlan_id %d\n",
                      portal_info->iface_handle, portal_info->vlan_id);
            ocs_list_remove(&iscsi_api->portal_list, portal_info);
            ocs_free(ocs, portal_info, sizeof(*portal_info));
        }
    }

    ocs_lock_free(&iscsi_api->api_list_lock);

    if (iscsi_api->isns_servers != NULL) {
        ocs_free(ocs, iscsi_api->isns_servers, sizeof(ocs_ip_address_t) * OCS_MAX_IP);
        iscsi_api->isns_servers = NULL;
    }

    ocs_free(ocs, iscsi_api, sizeof(iscsi_api_t));
    ocs->iscsi_api = NULL;

    return rc;
}


/**
 * @brief Checks to see if the target name is this target
 *
 * @param ocs Pointer to the ocs structure
 * @param remote_name Pointer to the target name
 *
 * @return 0 if this is a local target, 1 if is not a local target
 */
static uint8_t
ocs_iscsi_api_not_local_target(ocs_t *ocs, char *remote_name)
{
    uint16_t ctr = 0;
    char *my_name;

    my_name = ocs_iscsi_tgt_get_names(ocs, ctr);
    while(my_name){
        if(ocs_strcmp(my_name, remote_name)){
            ocs_log_debug(ocs, "(%d) different: (%s) and (%s)\n", (int) ctr, my_name, remote_name);
            ctr++;
            my_name = ocs_iscsi_tgt_get_names(ocs, ctr);
        }
        else{
            ocs_log_debug(ocs, "(%d) same: (%s) and (%s)\n", (int) ctr, my_name, remote_name);
            return 0;
        }
    }
    return 1;
}

/**
 * @brief Logs into any remote targets discovered through iSNS that are not this
 *        device.
 *
 * @param ocs Pointer to the ocs structure
 * @param ret Pointer from the iSNS query
 * @param nodes_count The number of nodes discovered
 */
static void
ocs_iscsi_api_isns_connect(ocs_t *ocs, void *ret, uint16_t nodes_count)
{
    ocs_ip_address_t remote_ip;
    ocs_hal_ip_address_t hal_ip;
    int32_t rc = 0;
    uint16_t i;
    uint16_t port;
    char *iscsi_name;
    char *ip_string;

    for(i = 0; i < nodes_count; i++){
        iscsi_name = ocs_get_iscsi_name(&ocs->iscsi, ret, i);
        if(ocs_iscsi_api_not_local_target(ocs, iscsi_name)){
            ip_string = ocs_get_ip(&ocs->iscsi, ret, i, 0);
            ocs_str_to_ip_struct(&ocs->iscsi, ip_string, &remote_ip);
            port = ocs_get_port(&ocs->iscsi, ret, i, 0);
            ocs_iscsi_convert_to_hal_ip(&remote_ip, &hal_ip);
            rc |= ocs_cxn_connect(&ocs->iscsi,
                          &hal_ip,
                          port,
                          iscsi_name);
            if (rc){
                ocs_log_test(ocs, "Failed to connect to target %s\n", iscsi_name);
            } else {
                ocs_log_debug(ocs, "connecting to target %s\n", iscsi_name);
            }
        }
    }
    return;
}

/**
 * @brief Register/query the iSNS server.
 *
 * @param ocs Pointer to the ocs structure
 * @param portal The portal to use for iSNS
 * @param isns_servers The table allocated to query the iSNS addresses
 */
static void
ocs_iscsi_isns_configure(ocs_t *ocs,
                     ocs_hal_portal_t portal,
                     ocs_ip_address_t *isns_servers)
{
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    int32_t rc;
    uint32_t num_ips, i;
    char ip_str[40];
    uint16_t nodes_count = 0;
    void *qry_rsp_ptr = NULL;

    rc = ocs_iscsi_isns_discover(ocs, portal, OCS_MAX_IP,
                     &num_ips, isns_servers);
    if (rc == 0) {
        ocs_log_debug(ocs, "iSNS Discovery succeeded, servers found %d\n",
                  num_ips);
        for (i = 0; i < num_ips; i++) {
            format_ip_address(isns_servers[i].ip_type,
                      isns_servers[i].ip_address,
                      ip_str, sizeof(ip_str));
            ocs_log_debug(ocs, "iSNS server found at %s\n", ip_str);

            if (ocs->enable_tgt || ocs->enable_ini) {
                if(ocs_isns_register(&ocs->iscsi, ocs->enable_tgt, ocs->enable_ini, &isns_servers[i], iscsi_api->isns_eid) == 0){
                    iscsi_api->isns_registered = TRUE;
                }
                else{
                    ocs_log_test(ocs, "ISNS REGISTERATION FAILED!\n");
                }
            }
            if (ocs->enable_ini && iscsi_api->isns_registered) {
                /*query the registered targets*/
                qry_rsp_ptr = ocs_isns_qry_tgts(&ocs->iscsi, &isns_servers[i], &nodes_count);
                if(nodes_count == 0){
                    ocs_log_test(ocs, "iSNS ERROR: the number of discovered nodes = 0\n");
                } else if (qry_rsp_ptr != NULL) {
                    ocs_iscsi_api_isns_connect(ocs, qry_rsp_ptr, nodes_count);
                } else {
                    ocs_log_test(ocs, "ISNS TARGETS QUERY FAILED!\n");
                }
                ocs_free(ocs, qry_rsp_ptr, nodes_count * sizeof(ocs_isns_node_t));
            }
        }
    } else {
        ocs_log_test(ocs, "iSNS Discovery status %d\n", rc);
    }

    if (iscsi_api->isns_registered) {
        for (i = 0; i < iscsi->num_ips; i++) {
            if (iscsi->ip_info[i].ip.ip_type == OCS_IP_TYPE_DHCP_V4) {
                format_ip_address(iscsi->ip_info[i].ip.ip_type,
                          iscsi->ip_info[i].ip.ip_address,
                          ip_str, sizeof(ip_str));

                /* Start the ESI listen socket - needs to be on the DHCP address */
                if (ocs_iscsi_isns_esi_listen_start(ocs,
                                    &iscsi->ip_info[i].ip,
                                    ISNS_ESI_PORT) == 0) {
                    ocs_log_debug(ocs, "Start iSNS ESI listen on IP %s\n", ip_str);
                    iscsi->ip_info[i].esi_listening = 1;
                    iscsi->ip_info[i].esi_port = ISNS_ESI_PORT;
                } else {
                    ocs_log_test(ocs, "failed to start iSNS ESI listen on IP %s\n",
                             ip_str);
                }
            }
        }
    }
}

static void ocs_iscsi_api_non_mgmt_config(ocs_t *ocs, ocs_hal_portal_t portal)
{
    uint32_t ip_found;
    uint32_t i;
    uint32_t rc;
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    char ip_str[40];

    if (iscsi_api->isns_servers == NULL) {
        iscsi_api->isns_servers = ocs_malloc(ocs, sizeof(ocs_ip_address_t) * OCS_MAX_IP, OCS_M_ZERO | OCS_M_NOWAIT);
    }

    if (iscsi_api->isns_servers == NULL) {
        ocs_log_err(ocs, "unable to allocate ip temporary variables\n");
        return;
    }

    /* See if our IP address is present, if so, then skip */
    ip_found = ocs_iscsi_is_ip_in_tbl(ocs, &iscsi_api->ipsub);
    if (!ip_found) {
        rc = ocs_iscsi_ip_address_add(ocs, portal, &iscsi_api->ipsub);
        if (rc == 0) {
            /*
             * In the case of auto addresses, it may already be
             * present, so we need to check before adding it to
             * the table.
             */
            ip_found = ocs_iscsi_is_ip_in_tbl(ocs, &iscsi_api->ipsub);
            if (!ip_found) {
                (void)ocs_iscsi_add_ip_to_tbl
                    (ocs, "Added", &iscsi_api->ipsub, portal);
            }
        } else {
            ocs_log_test(ocs, "add IP returned status %d\n", rc);
        }
    }

    if (iscsi_api->set_gateway) {
        rc = ocs_iscsi_gateway_set(ocs, &iscsi_api->gateway);
        if (rc == 0) {
            format_ip_address(iscsi_api->gateway.ip_type,
                      iscsi_api->gateway.ip_address,
                      ip_str, sizeof(ip_str));
            ocs_log_debug(ocs, "Added Gateway address %s\n", ip_str);
        } else {
            ocs_log_test(ocs, "setting gateway returned status %d\n", rc);
        }
    }

    /* Start the listen server for targets */
    if (ocs->enable_tgt) {
        for (i = 0; i < iscsi->num_ips; i++) {
            format_ip_address(iscsi->ip_info[i].ip.ip_type,
                      iscsi->ip_info[i].ip.ip_address,
                      ip_str, sizeof(ip_str));

            iscsi->ip_info[i].tcp_port = OCS_ISCSI_TCP_PORT;
            rc = ocs_iscsi_listen_start(ocs,
                            &iscsi->ip_info[i].ip,
                            iscsi->ip_info[i].tcp_port);
            if (rc == 0) {
                ocs_log_debug(ocs, "Listen server started on %s\n",
                          ip_str);
                iscsi->ip_info[i].listening = 1;
            } else {
                ocs_log_test(ocs, "listen returned status %d on %s\n",
                         rc, ip_str);
            }
        }
    }

    /* try to find the iSNS server */
    if ((ocs->ctrlmask & OCS_CTRLMASK_ISCSI_ISNS_ENABLE) != 0) {
        ocs_iscsi_isns_configure(ocs, portal, iscsi_api->isns_servers);
    }
}


/**
 * @brief Configures the link on initial link up.
 *
 * @param ocs Pointer to the ocs structure
 */
static void
ocs_iscsi_api_link_configure(ocs_t *ocs)
{
    ocs_hal_portal_t portal;
    int32_t rc;
    uint32_t num_ips;
    ocs_ip_address_subnet_t *ipsub_tbl;
    ocs_ip_type_e ip_type;
    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(ocs, "unable to allocate ip temporary variables\n");
        ocs_free(ocs, ipsub_tbl, sizeof(ocs_ip_address_subnet_t) * OCS_MAX_IP);
        return;
    }

    portal = ocs_iscsi_portal_get_default(ocs);
    ocs_log_debug(ocs, "Default portal %d\n", portal);

    rc = ocs_iscsi_mtu_set(ocs, ocs->enable_jumbo_frame);
    if (rc ==0) {
        ocs_log_debug(ocs, "set MTU to %s\n",
            (ocs->enable_jumbo_frame == TRUE ? "Jumbo" : "Standard"));
    } else {
        ocs_log_test(ocs, "Failed setting MTU, status=%d\n", rc);
    }

    /*
     * Initiator and target functions share IP addresses. So query the FW
     * to see if any addresses are set. We have to query IPv4 and IPv6
     * separately.
     */
    ip_type = OCS_IP_TYPE_V4;
    do {
        rc = ocs_iscsi_ip_address_query(ocs,
                        portal,
                        ip_type,
                        OCS_MAX_IP,
                        &num_ips,
                        ipsub_tbl);
        if (rc == 0) {
            /* add to IP table */
            for (i = 0; i < num_ips; i++) {
                /*
                 * If we found a DHCP address and we are doing
                 * DHCP, wait, because the address may change.
                 * Let the protocol proceed and see if we renew.
                 */
                if (ipsub_tbl[i].ip_type == OCS_IP_TYPE_DHCP_V4 ||
                    ipsub_tbl[i].ip_type == OCS_IP_TYPE_AUTO_V6) {
                    continue;
                }

                (void)ocs_iscsi_add_ip_to_tbl
                    (ocs,
                     "Found",
                     &ipsub_tbl[i],
                     portal);
            }
        } else {
            ocs_log_test(ocs, "Query IP returned status %d\n", rc);
        }
        if (ip_type == OCS_IP_TYPE_V4) {
            ip_type = OCS_IP_TYPE_V6;
        } else {
            break;
        }
    } while(1);

    if(ocs->iscsi_api->enable_mgmt_flag) {
            ocs_log_debug(ocs, "waiting for ip managment configuration\n");
    } else if(rc == 0){
        ocs_iscsi_api_non_mgmt_config(ocs, portal);
    }

    ocs_free(ocs, ipsub_tbl, sizeof(ocs_ip_address_subnet_t) * OCS_MAX_IP);
    return;
}


/**
 * @brief Configures the link on initial link up.
 *
 * @param mythread pointer to thread object
 */
static int32_t
ocs_iscsi_api_link_configure_thread(ocs_thread_t *mythread)
{
    ocs_t *ocs = mythread->arg;
    ocs_iscsi_t *iscsi = &ocs->iscsi;
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    int32_t rc;

    while (ocs_thread_terminate_requested(mythread) == 0) {
        rc = ocs_sem_p(&iscsi_api->link_cfg_sem, 100000);

        if (rc == 0) {
            if (!iscsi_api->link_configured) {
                /* wait for initialization to complete */
                while (!iscsi->is_init_complete) {
                    ocs_msleep(OCS_ISCSI_API_INIT_DELAY_MS);
                }
                iscsi_api->link_configured = TRUE;
                ocs_iscsi_api_link_configure(ocs);
            }
        }
    }
    ocs_log_debug(ocs, "link configuration thread exiting\n");
    return 0;
}

/**
 * @brief Notifies the higher level iSCSI software of the link state
 *
 * @param ocs Pointer to the ocs structure
 * @param link_state Provides the status of the link
 */
void
ocs_iscsi_api_link_state(ocs_t *ocs, ocs_link_state_e link_state)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;

    if (link_state == OCS_LINK_STATE_UP) {
        ocs_sem_v(&iscsi_api->link_cfg_sem);
    }
}

/**
 * @brief Returns the maximum number of connections allowed per session.
 *
 * @param ocs Pointer to the ocs structure
 * @param tgt_name The iSCSI target name
 * @param ini_name The iSCSI initiator name
 */
uint32_t
ocs_iscsi_get_max_cxns(ocs_t *ocs, char *tgt_name, char *ini_name)
{
    return ocs->max_cxns_per_session;
}

/**
 * @brief Returns the CHAP user name of corresponding type
 *
 * @param ocs Pointer to the ocs structure
 * @param sess_type Either discovery or nomal session
 * @param mode Username for Target mode or Initaitor mode
 * @param type CHAP incoming or outgoing
 */
char *ocs_iscsi_get_chap_name(ocs_t *ocs, uint8_t sess_type,
                  uint32_t mode, uint32_t type)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->chap_list, chap) {
        if ((chap->mode == mode) && (chap->type == type)) {
            ocs_unlock(&iscsi_api->api_list_lock);
            return chap->username;
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return NULL;
}

/**
 * @brief Returns the unenctypted CHAP secret for a specific user name.
 *        Note: Passwords should be at least 16 characters.
 *
 * @param ocs Pointer to the ocs structure
 * @param name Username to which the secret to be identified
 * @param secret_len Length of the secret code
 */
char *ocs_iscsi_get_chap_secret(ocs_t *ocs, char *name, uint32_t mode,
                uint32_t type, uint32_t *secret_len)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach(&iscsi_api->chap_list, chap) {
        if ((chap->mode == mode) && (chap->type == type)) {
            if (ocs_strcmp(name, chap->username) == 0) {
                *secret_len = ocs_strlen(chap->secret);
                ocs_unlock(&iscsi_api->api_list_lock);
                return chap->secret;
            }
        }
    }

    ocs_unlock(&iscsi_api->api_list_lock);
    *secret_len = 0;
    return NULL;
}

/**
 * @brief Add CHAP user.
 * If CHAP user of same type is already exists, return error.
 *
 * @param ocs Pointer to the ocs structure
 * @param username Username to add 
 * @param secret Secret to add 
 * @param type CHAP type is incoming or outgoing
 * @param mode Target or Initiator mode 
 *
 * Return zero on success, otherwise a negative value
 */
int32_t ocs_iscsi_chap_user_add(ocs_t *ocs, char *username,
                char *secret, uint32_t type, uint32_t mode)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;
    uint8_t found = FALSE;
    int32_t rc = -1;

    ocs_lock(&iscsi_api->api_list_lock);

    /* Check for duplicates */
    ocs_list_foreach(&iscsi_api->chap_list, chap) {
        if ((mode == chap->mode) && (type == chap->type)) {
            found = TRUE;
            break;
        }
    }

    if (!found) {
        chap = ocs_malloc(ocs, sizeof(ocs_chap_user_t),
                  OCS_M_ZERO | OCS_M_NOWAIT);
        if (chap != NULL) {
            ocs_strcpy(chap->username, username);
            ocs_strcpy(chap->secret, secret);
            chap->type = type;
            chap->mode = mode;
            ocs_list_add_tail(&iscsi_api->chap_list, chap);
            rc = 0;
            ocs_log_debug(ocs, "%s CHAP %s:%s is added for %s\n",
                      (type == OCS_CHAP_TYPE_INCOMING) ? "Incoming": "Outgoing",
                      username, secret,
                      (mode == OCS_CHAP_MODE_TARGET) ? "Target" : "Initiator");
        }
    } else {
        ocs_log_info(ocs, "CHAP type %s is already exists\n",
                 (type == OCS_CHAP_TYPE_INCOMING) ? "Incoming" : "Outgoing");
    }

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

/**
 * @brief Delete CHAP user.
 *
 * @param ocs Pointer to the ocs structure
 * @param username Username to delete 
 * @param type CHAP type is incoming or outgoing
 * @param mode Target or Initiator mode 
 *
 * Return zero on success, otherwise a negative value
 */
int32_t ocs_iscsi_chap_user_del(ocs_t *ocs, char *username, uint32_t type, uint32_t mode)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;
    ocs_chap_user_t *chap_next;
    int32_t rc = -1;

    if (ocs->require_chap) {
        ocs_log_info(ocs, "CHAP is enabled! Deletion is not allowed\n");
        return rc;
    }

    ocs_lock(&iscsi_api->api_list_lock);

    /*
     * Restrict deleting CHAP type incoming prior to the type outgoing.
     * No use case to support only the type outgoing.
     */
    if (type == OCS_CHAP_TYPE_INCOMING) {
        ocs_list_foreach_safe(&iscsi_api->chap_list, chap, chap_next) {
            /* If CHAP outgoing found, then just return failure */
            if (chap->type == OCS_CHAP_TYPE_OUTGOING) {
                ocs_log_err(ocs, "CHAP type outgoing must be deleted "
                        "prior to the type incoming.\n");
                ocs_unlock(&iscsi_api->api_list_lock);
                goto exit_err;
            }
        }
    }

    /* Find a match */
    ocs_list_foreach_safe(&iscsi_api->chap_list, chap, chap_next) {
        if ((mode == chap->mode) && (type == chap->type)) {
            if (ocs_strcmp(username, chap->username) == 0) {
                ocs_list_remove(&iscsi_api->chap_list, chap);
                ocs_free(ocs, chap, sizeof(ocs_chap_user_t));
                ocs_log_debug(ocs, "%s CHAP %s:%s is removed for %s\n",
                          (type == OCS_CHAP_TYPE_INCOMING) ? "Incoming": "Outgoing",
                          username, chap->secret,
                          (mode == OCS_CHAP_MODE_TARGET) ? "Target" : "Initiator");
                rc = 0;
                break;
            }
        }
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    if (rc) {
        ocs_log_info(ocs, "CHAP user %s of type %s is not found\n",
                 username,
                 (type == OCS_CHAP_TYPE_INCOMING) ? "Incoming": "Outgoing");
    }

exit_err:
    return rc;
}

/**
 * @brief Returns the count of chap_list.
 */
int32_t ocs_iscsi_chap_list_count(ocs_t *ocs)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;
    ocs_chap_user_t *chap_next;
    int32_t cnt = 0;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach_safe(&iscsi_api->chap_list, chap, chap_next) {
        cnt++;
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return cnt;
}

/**
 * @brief Return CHAP list items
 *
 * @param ocs OCS context
 * @param userbuf User buffer to which chap_list items are copied
 * @param buflen User buffer length
 *
 * @Return zero on success, otherwise a negative value
 */
int32_t ocs_iscsi_chap_list_get(ocs_t *ocs, char *userbuf, int32_t buflen)
{
    iscsi_api_t *iscsi_api = ocs->iscsi_api;
    ocs_chap_user_t *chap;
    ocs_chap_user_t *chap_next;
    ocs_chap_user_buffer_t chap_user_buff;
    int32_t offset = 0;

    ocs_lock(&iscsi_api->api_list_lock);
    ocs_list_foreach_safe(&iscsi_api->chap_list, chap, chap_next) { 
        if (offset >= buflen) {
            ocs_log_err(ocs, "User buffer is insufficient\n");
            ocs_unlock(&iscsi_api->api_list_lock);
            return -EFAULT;
        }

        ocs_memset(&chap_user_buff, 0, sizeof(ocs_chap_user_buffer_t));
        ocs_strncpy(chap_user_buff.username, chap->username,
                sizeof(chap_user_buff.username));
        ocs_strncpy(chap_user_buff.secret, chap->secret,
                sizeof(chap_user_buff.secret));
        chap_user_buff.type = chap->type;
        chap_user_buff.mode = chap->mode;

        if (ocs_copy_to_user(userbuf + offset, &chap_user_buff,
                     sizeof(ocs_chap_user_buffer_t))) {
            ocs_log_err(ocs, "Chap list copy to user failed\n");
            ocs_unlock(&iscsi_api->api_list_lock);
            return -EFAULT;
        }
        offset += sizeof(ocs_chap_user_buffer_t);
    }
    ocs_unlock(&iscsi_api->api_list_lock);

    return 0;
}

static int32_t
ocs_iscsi_unassisted_pdu_cb(struct ocs_hal_io_s *io,
             ocs_cxn_t *cxn,
             int32_t status,
             ocs_ini_cmpl_fields_t *ini_fields,
             void *ul_arg)
{
    ocs_iscsi_pdu_cb_t cb;
    ocs_io_t *ocs_io;
    uint32_t exp_cmdsn = 0;
    uint32_t max_cmdsn = 0;
    uint8_t response = 0;
    int rc = 0;

    ocs_assert(cxn, -1);
    ocs_assert(ul_arg, -1);

    ocs_io = (ocs_io_t *)ul_arg;

    cb = ocs_io->unassisted_cb;
    ocs_io->unassisted_cb = NULL;

    if (ini_fields) {
        exp_cmdsn = ini_fields->exp_cmdsn;
        max_cmdsn = (ini_fields->exp_cmdsn + ini_fields->cmd_window - 1);
        response = ini_fields->response;
    }

    /* Copy the BHS back to io->bhs for open-iscsi */
    ocs_memcpy(ocs_io->bhs, io->bhs.virt, sizeof(iscsi_cmd_hdr_t));

    if (cb) {
        rc = cb(ocs_io, exp_cmdsn, max_cmdsn, response);
    }
    ocs_dma_free(cxn->ocs, &ocs_io->unassisted_payload);

    return rc;

}

int32_t
ocs_iscsi_unassisted_pdu_send(ocs_t *ocs, ocs_io_t *io, ocs_cxn_t *cxn, void *bhs, void *data,
                      uint32_t data_size, bool is_login, bool set_dm,
                      ocs_iscsi_pdu_cb_t cb)
{
    int rc;
    iscsi_bhs_t *iscsi_bhs;

    ocs_memcpy(io->bhs, bhs, sizeof(iscsi_cmd_hdr_t));
    io->node = cxn;
    io->ocs = cxn->ocs;

    // Save the caller's callback function
    io->unassisted_cb = cb;
    io->hal_io_size = data_size;

    iscsi_bhs = (iscsi_bhs_t *)bhs;

    /* If the PDU we're sending is a NOP OUT, and it's an initiator
       requesting a NOP IN response (rather than responding
       to a target's NOP IN request) then we have to send this is a
       INI_RD_CMD rather than as a DM_CMD.  This is because with the
       DM_CMD, Skyhawk won't correctly return the NOP IN response back
       to us.
       */
    ocs_memset(&io->unassisted_payload, 0, sizeof(ocs_dma_t));
    if (data_size) {
        ocs_dma_alloc(ocs, &io->unassisted_payload,
                  data_size, 16);
        ocs_memcpy(io->unassisted_payload.virt, data, data_size);
    }

    if ((iscsi_bhs->opcode == ISCSI_CMD_NOOP) && (iscsi_bhs->itt != ISCSI_RESERVED_TTT)) {
        iscsi_nopout_hdr_t *nop_hdr = bhs;

        io->io_type = OCS_HAL_IO_INITIATOR_READ;
        io->iparam.ini_io.lun = 0;
        io->iparam.ini_io.cmdsn = ocs_be32toh(nop_hdr->cmd_sn);
        io->iparam.ini_io.dif_info = NULL;
    } else {
        io->io_type = OCS_HAL_IO_UNASSISTED;

        io->iparam.unassisted.set_dm   = set_dm;
        io->iparam.unassisted.incr_statsn = FALSE;
        io->iparam.unassisted.is_login = is_login;
        io->iparam.unassisted.payload1 =
            (data_size ? &io->unassisted_payload : NULL);
    }

    rc = ocs_scsi_io_dispatch(io, ocs_iscsi_unassisted_pdu_cb);


    return rc;
}

int32_t
ocs_iscsi_login_cb(ocs_hal_io_t *io, ocs_cxn_t *cxn,
                  int32_t status,
                  ocs_ini_cmpl_fields_t *ini_fields,
                  void *ul_arg);

/**
 * @brief Function to receieve the callback for a context update
 *
 * @param io       pointer to the io object
 * @param cxn      pointer to the connection object
 * @param status   the status of the IO (1 = good)
 * @param ini_fields pointer to the initiator completion fields
 * @param ul_arg   pointer to the login memory structure
 *
 * @return Returns 0 on success.
 */
static int32_t
ocs_iscsi_send_context_udpate_cb(ocs_hal_io_t *io, ocs_cxn_t *cxn,
                 int32_t status,
                 ocs_ini_cmpl_fields_t *ini_fields,
                 void *ul_arg)
{
    ocs_iscsi_t *iscsi = cxn->iscsi;

    if (status != SLI_STATUS_SOL_CMD_CMPL_NORMAL &&
        status != SLI_STATUS_TCP_ACK_NOTIFY) {
        ocs_log_test(iscsi->os, "Invalid status %d\n", status);
        ocs_cxn_close(cxn, TRUE);
    }

    ocs_hal_io_free(iscsi->hal, io);

    return 0;
}


/**
 * @ingroup iscsi_api
 * @brief Sends the login parameters to the FW
 *
 * @param cxn      pointer to the connection object
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_iscsi_send_context_udpate(ocs_cxn_t *cxn)
{
    ocs_iscsi_t *iscsi = cxn->iscsi;
    ocs_session_t *session = cxn->session;
    ocs_hal_io_t *hal_io;
    ocs_hal_io_param_t iparam;
    int32_t rc;

    hal_io = ocs_hal_io_alloc(iscsi->hal);
    if (hal_io == NULL) {
        return OCS_PDU_RTN_NO_RESOURCES;
    }

    /*
     * Update the login parameters in FW
     */
    iparam.context_upd.lgn_options.session_options = session->login_options;
    iparam.context_upd.lgn_options.data_digest = cxn->data_digest;
    iparam.context_upd.lgn_options.hdr_digest  = cxn->hdr_digest;
    iparam.context_upd.lgn_options.max_rcv_dsl = cxn->max_rcv_dsl;
    iparam.context_upd.lgn_options.max_send_dsl = cxn->max_xmit_dsl;
    iparam.context_upd.statsn = cxn->stat_sn;
    rc = ocs_hal_io_send(iscsi->hal,
                 OCS_HAL_IO_CONTEXT_UPDATE,
                 hal_io,
                 0,
                 &iparam,
                 cxn,
                 ocs_iscsi_send_context_udpate_cb,
                 hal_io);
    return rc;
}

#if !defined(OCS_EXPORT)
#define OCS_EXPORT(...)
#endif

OCS_EXPORT(ocs_iscsi_unassisted_pdu_send);
OCS_EXPORT(ocs_iscsi_ini_get_name);
OCS_EXPORT(ocs_iscsi_mac_get);
OCS_EXPORT(ocs_iscsi_rx_buffers_free);
OCS_EXPORT(ocs_xport_control);
OCS_EXPORT(ocs_iscsi_register_link_state_callback);
OCS_EXPORT(ocs_iscsi_unregister_link_state_callback);
OCS_EXPORT(ocs_iscsi_send_context_udpate);