ocs_cxn.c

Go to the documentation of this file.

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

/**
 * @file
 * OCS iSCSI connection management functions.
 */

/**
 * @defgroup cxn_mgnt iSCSI Connection Management
 * @defgroup cxn_sm Connection State Machine: Connection States
*/

#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_login.h"
#include "ocs_session.h"
#include "ocs_cxn.h"

#define std_cxn_state_decl(...) \
    ocs_cxn_t *cxn = NULL; \
    ocs_iscsi_t *iscsi = NULL; \
    ocs_t *ocs = NULL; \
    \
    ocs_assert(ctx, NULL); \
    cxn = ctx->app; \
    ocs_assert(cxn, NULL); \
    iscsi = cxn->iscsi; \
    ocs_assert(iscsi, NULL); \
    ocs = cxn->ocs; \
    ocs_assert(ocs, NULL); \

#define cxn_sm_trace()  \
    do { \
        if (ocs_debug_is_enabled(OCS_DEBUG_ENABLE_SM_TRACE))    \
            ocs_log_info(cxn->ocs, "[%s] %-20s %-20s\n", cxn->display_name, __func__, ocs_sm_event_name(evt)); \
    } while (0)

void ocs_mgmt_node_list(ocs_textbuf_t *textbuf, void *node);
void ocs_mgmt_node_get_all(ocs_textbuf_t *textbuf, void *node);
int ocs_mgmt_node_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *node);
int ocs_mgmt_node_set(char *parent, char *name, char *value, void *node);
int ocs_mgmt_node_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
        void *arg_out, uint32_t arg_out_length, void *node);
static ocs_mgmt_functions_t node_mgmt_functions = {
    .get_list_handler   =   ocs_mgmt_node_list,
    .get_handler        =   ocs_mgmt_node_get,
    .get_all_handler    =   ocs_mgmt_node_get_all,
    .set_handler        =   ocs_mgmt_node_set,
    .exec_handler       =   ocs_mgmt_node_exec,
};

/* declare local functions */
static void * __ocs_cxn_connect(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_connect_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_connect_delay(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_get_info(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_get_info_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_offload(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_offload_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_reject(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_reject_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_connected(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_close_abort_io(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_abort_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_close_abort_login(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_close(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_close_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_upload(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_upload_wait(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
static void * __ocs_cxn_error(ocs_sm_ctx_t *, ocs_sm_event_t, void *);

static void ocs_cxn_connect_cb(void *, int32_t, uint32_t, void *);
static void ocs_cxn_close_cb(void *, int32_t, uint32_t, void*);
static void ocs_cxn_upload_cb(void *, int32_t, uint32_t, void*);
static void ocs_cxn_get_info_cb(void *, int32_t, uint32_t, void*);
static void ocs_cxn_offload_cb(void *, int32_t, uint32_t, void*);
static void ocs_cxn_reject_cb(void *, int32_t, uint32_t, void*);


/**
 * @brief Initialize the iSCSI connection objects.
 *
 * @param iscsi Pointer to the iSCSI object.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
int32_t ocs_cxn_initialize(ocs_iscsi_t *iscsi)
{
    ocs_iscsi_tracker_init(&iscsi->cxn_login_hdr);
    if (ocs_iscsi_tracker_alloc(iscsi,
                    &iscsi->cxn_login_hdr,
                    FALSE,
                    64,
                    OCS_ISCSI_CACHE_LINE_SIZE,
                    iscsi->num_cxns)) {
        ocs_log_err(iscsi->os, "Failed to allocate login hdr buffers\n");
        return -ENOMEM;
    }

    ocs_iscsi_tracker_init(&iscsi->cxn_login_data);
    if (ocs_iscsi_tracker_alloc(iscsi,
                    &iscsi->cxn_login_data,
                    FALSE,
                    OCS_ISCSI_LOGIN_PAYLOAD_SIZE,
                    OCS_ISCSI_CACHE_LINE_SIZE,
                    iscsi->num_cxns)) {
        ocs_log_err(iscsi->os, "Failed to allocate login data buffers\n");
        return -ENOMEM;
    }

    return 0;
}

/**
 * @brief Free the iSCSI connection objects.
 *
 * @param iscsi Pointer to the iSCSI object.
 *
 * @return Returns 0 on success, or a non-zero value otherwise.
 */
void ocs_cxn_teardown(ocs_iscsi_t *iscsi)
{
    ocs_iscsi_tracker_free(iscsi, &iscsi->cxn_login_hdr);
    ocs_iscsi_tracker_free(iscsi, &iscsi->cxn_login_data);
}

/**
 * @brief Free memory resources of a node object.
 *
 * @par Description
 * The node object's child objects are freed after which the
 * node object is freed.
 *
 * @param cxn Pointer to connection.
 *
 * @return None.
 */

void
ocs_cxn_force_free(ocs_cxn_t *cxn)
{
    ocs_t    *ocs = cxn->ocs;
    ocs_io_t *io;
    ocs_io_t *next;

    /* shutdown sm processing */
    ocs_sm_disable(&cxn->sm);

    ocs_scsi_notify_node_force_free((ocs_node_t *)cxn);

    ocs_device_lock(ocs);
    ocs_lock(&cxn->active_ios_lock);
    ocs_list_foreach_safe(&cxn->active_ios, io, next) {
        ocs_list_remove(&cxn->active_ios, io);

        /* clear from the pending list */
        if (ocs_list_on_list(&io->io_pending_link)) {
            ocs_list_remove(&ocs->io_pending_list, io);
        }
        ocs_io_free(cxn->ocs, io);
    }
    ocs_list_foreach_safe(&cxn->aborted_ios, io, next) {
        ocs_list_remove(&cxn->aborted_ios, io);
        /* clear from the pending list */
        if (ocs_list_on_list(&io->io_pending_link)) {
            ocs_list_remove(&ocs->io_pending_list, io);
        }
        ocs_io_free(cxn->ocs, io);
    }
    ocs_unlock(&cxn->active_ios_lock);
    ocs_device_unlock(ocs);

    /* manually purge pending frames (if any) */
    (void)ocs_iscsi_login_cxn_cleanup(cxn);
}


/**
 * @brief Transition state of a node.
 *
 * @par Description
 * The connection's state is transitioned to the requested state. Entry/Exit
 * events are posted as needed.
 *
 * @param cxn Pointer to connection.
 * @param state State to transition to.
 * @param data Transition data.
 *
 * @return None.
 */

static void
ocs_cxn_transition(ocs_cxn_t *cxn, ocs_sm_function_t state, void *data)
{
    ocs_sm_ctx_t *ctx = &cxn->sm;

    if (ctx->current_state == state) {
        ocs_sm_post_event(ctx, OCS_EVT_REENTER, data);
    } else {
        ocs_sm_post_event(ctx, OCS_EVT_EXIT, data);
        ctx->current_state = state;
        ocs_sm_post_event(ctx, OCS_EVT_ENTER, data);
    }
}


/**
 * @brief This function is called on timer expiration and sends an event to the
 *        the state machine.
 *
 * @param arg Pointer to the cxn object.
 */
static void ocs_cxn_retry_timeout(void *arg)
{
    ocs_cxn_t   *cxn = arg;
    ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_RETRY_TIMER_EXPIRED, NULL);
}


/**
 * @brief Set the SM timer to retry a command at a later time.
 *
 * @param cxn Pointer to the connection object.
 * @param timeout Timeout value in milliseconds.
 */
static void
ocs_cxn_set_sm_retry_timer(ocs_cxn_t *cxn, uint32_t timeout)
{
    if (ocs_timer_pending(&cxn->sm_retry_timer)) {
        ocs_del_timer(&cxn->sm_retry_timer);
    }

    ocs_setup_timer(cxn->ocs, &cxn->sm_retry_timer,
            ocs_cxn_retry_timeout,
            cxn,
            timeout, false);
}

/**
 * @ingroup cxn_sm
 * @brief State: Common device event handler.
 *
 * @par Description
 * For connection nodes, this handles default/common events.
 *
 * @param funcname Higher level function name.
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_REENTER:
    case OCS_EVT_EXIT:
    case OCS_EVT_SHUTDOWN:
        break;

    default:
        ocs_log_test(ocs, "[%s] %-20s %-20s not handled\n", cxn->display_name, funcname, ocs_sm_event_name(evt));
        break;
    }
    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief State: Initial state.
 *
 * @par Description
 * For connection nodes, this handles connect/connection received events.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_initial(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        /* Kill the test negotiation timer if it is active */
        if (ocs_timer_pending(&cxn->ffp_timer)) {
            ocs_del_timer(&cxn->ffp_timer);
        }

        /* Cleanup any cbit buffers */
        ocs_iscsi_cbit_cleanup(cxn);
        break;

    case OCS_EVT_CXN_CONNECT:
        ocs_cxn_transition(cxn, __ocs_cxn_connect, NULL);
        break;

    case OCS_EVT_CXN_INCOMING_REQ:
        ocs_cxn_transition(cxn, __ocs_cxn_get_info, NULL);
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
    case OCS_EVT_IO_CMPL:
        /* Ignore */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief State: Connect to a remote node
 *
 * @par Description
 * For connection nodes, this handles connecting to a remote node.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_connect(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_hal_ip_address_t remote_ip;
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        remote_ip.ip_type = cxn->dest_ip_type;
        ocs_memcpy(remote_ip.ip_address, cxn->dest_ip, 16);

        rc = ocs_hal_cxn_connect(iscsi->hal,
                     cxn,
                     &remote_ip,
                     cxn->dest_port,
                     ocs->tcp_window_size,
                     ocs->tcp_window_scale,
                     ocs_cxn_connect_cb,
                     cxn);
        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_initial, NULL);
            (void)ocs_session_cxn_del(cxn);
            ocs_hal_cxn_free(iscsi->hal, cxn);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_connect_wait, NULL);
        }
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for the connection to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_connect_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        break;

    case OCS_EVT_CXN_CONNECT_CMPL:
        // TODO: transition first then do stuff?
        // "connected" before LOGIN PDU completes?
        ocs_cxn_transition(cxn, __ocs_cxn_connected, NULL);

        rc = ocs_iscsi_send_login(cxn, FALSE, cxn->session->tgt_name);
        if (rc) {
            ocs_log_err(iscsi->os, "failing building login (rc=%d)\n", rc);
            ocs_cxn_close(cxn, FALSE);
        }
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        cxn->sendRst   = (evt == OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST);
        ocs_cxn_transition(cxn, __ocs_cxn_close, NULL);
        break;

    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_connect_delay, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Connection to target failed, delay before retrying.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_connect_delay(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_CONNECT_MS);
        break;

    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        ocs_cxn_transition(cxn, __ocs_cxn_connect, NULL);
        break;

    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_connect_delay, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Connected, waiting for the teardown request.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_connected(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        cxn->sendRst   = (evt == OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST);
        ocs_cxn_transition(cxn, __ocs_cxn_close_abort_io, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief Aborts active IO objects on a connection.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_close_abort_io(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    ocs_io_t *io, *abort_io = NULL;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        /* Purge any IOs for this connection off the pending list */
        ocs_scsi_pending_cleanup(cxn);

        /* try to find one with a HAL IO allocated. */
        ocs_node_lock(cxn);
        ocs_list_foreach(&cxn->active_ios, io) {
            if (io->hio != NULL) {
                abort_io = io;
                break;
            }
        }
        ocs_node_unlock(cxn);
        if (abort_io == NULL) {
            ocs_cxn_transition(cxn, __ocs_cxn_close_abort_login, NULL);
        } else {
            rc = ocs_hal_io_abort(iscsi->hal,
                          abort_io->hio,
                          OCS_HAL_IO_ABORT_SCOPE_NODE,
                          OCS_HAL_IO_ABORT_TYPE_TCP_CLOSED);

            if (rc == OCS_HAL_RTN_NO_RESOURCES ||
                rc == OCS_HAL_RTN_NO_MEMORY) {
                // TODO - no Memory may require a big hammer reset
                ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
            } else if (rc) {
                ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
            } else {
                ocs_log_debug(iscsi->os, "cxn, hdl=0x%x abort ICD %d\n",
                          cxn->conn_hdl,
                          (abort_io->hio != NULL) ? abort_io->hio->icd : -1);
                ocs_cxn_transition(cxn, __ocs_cxn_close_abort_login, NULL);
            }
        }
        break;

    case OCS_EVT_CXN_OFFLOAD_CMPL:
        /* Reset during offload - just ignore */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief Aborts any login transactions on a connection.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_close_abort_login(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        rc = ocs_iscsi_login_cxn_cleanup(cxn);

        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_abort_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_OFFLOAD_CMPL:
        /* Reset during offload - just ignore */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for the IO aborts to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_abort_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    uint8_t is_io_empty;
    uint8_t are_login_reqs;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_IO_CMPL:
        /* Check to see if all the IOs are completed */
        ocs_node_lock(cxn);
        is_io_empty = ocs_list_empty(&cxn->active_ios);
        ocs_node_unlock(cxn);
        are_login_reqs = ocs_iscsi_are_login_reqs_outstanding(cxn);

        if (is_io_empty && !are_login_reqs) {
            if (cxn->send_logout_rsp) {
                rc = ocs_iscsi_send_logout_rsp(cxn,
                                   cxn->logout_rsp,
                                   cxn->logout_itt);

                if (rc == 0) {
                    cxn->send_logout_rsp = FALSE;
                    ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
                } else if (rc == OCS_HAL_RTN_NO_RESOURCES) {
                    ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
                } else {
                    ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
                }
            } else {
                ocs_cxn_transition(cxn, __ocs_cxn_close, NULL);
            }
        }
        break;

    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        /* Ignore */
        break;
    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
        /* We are already closing */
        break;
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        cxn->sendRst = TRUE;
        ocs_cxn_transition(cxn, __ocs_cxn_close, NULL);
        break;

    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief Closes a TCP connection.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_close(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        if (cxn->cxn_state != CONN_STATE_LOGOUT_REQUESTED) {
            cxn->cxn_state = CONN_STATE_CLEANUP;
        }
        rc = ocs_hal_cxn_close(iscsi->hal,
                       cxn,
                       cxn->sendRst,
                       ocs_cxn_close_cb,
                       cxn);

        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        } else {
            // TODO: should we wait to clean up until connection closed?
            ocs_log_debug(iscsi->os, "sent request to close cxn, hdl=0x%x\n",
                      cxn->conn_hdl);
            if (cxn->is_ini_cxn) {
                ocs_scsi_del_target(cxn, OCS_SCSI_TARGET_DELETED);
            } else {
                ocs_scsi_del_initiator(cxn, OCS_SCSI_INITIATOR_DELETED);
            }
            ocs_cxn_transition(cxn, __ocs_cxn_close_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
    case OCS_EVT_CXN_OFFLOAD_CMPL:
        /* Reset during offload - just ignore */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Closing, waiting for the close callback.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_close_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        /* ignore since we are already closing */
        break;

    case OCS_EVT_CXN_OFFLOAD_CMPL:
        /* Reset during offload - just ignore */
        break;

    case OCS_EVT_CXN_CLOSE_CMPL:
        ocs_cxn_transition(cxn, __ocs_cxn_upload, NULL);
        break;

    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Closing, waiting for the close callback.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_upload(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        rc = ocs_hal_cxn_upload(iscsi->hal,
                    cxn,
                    !cxn->sendRst,
                    ocs_cxn_upload_cb,
                    cxn);
        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_upload_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        /* ignore since we are already closing */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for connection upload to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_upload_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_hal_ip_address_t remote_ip;
    uint16_t tcp_port = 0;
    uint8_t  is_ini_cxn;
    char tgt_name[OCS_MAX_ISCSI_NAME];
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        /* ignore since we are already closing */
        break;

    case OCS_EVT_CXN_UPLOAD_CMPL:
        ocs_log_debug(iscsi->os, "Upload completed on connection\n");
        /*
         * Attempt to re-establish initiator connections. Free
         * connections on the target
         */
        is_ini_cxn = cxn->is_ini_cxn;
        if (is_ini_cxn &&
            !iscsi->shutting_down) {
            remote_ip.ip_type = cxn->dest_ip_type;
            ocs_memcpy(remote_ip.ip_address, cxn->dest_ip, 16);
            if (cxn->session != NULL) {
                ocs_strcpy(tgt_name, cxn->session->tgt_name);
            } else {
                ocs_log_test(iscsi->os, "INI session with no session - cannot retry connection %s\n",
                         cxn->display_name);
                is_ini_cxn = FALSE;
            }
            tcp_port = cxn->dest_port;
        }

        ocs_cxn_transition(cxn, __ocs_cxn_initial, NULL);
        (void)ocs_session_cxn_del(cxn);

        /* Free any IOs on the aborted IO list */
        ocs_cxn_force_free(cxn);

        if (ocs_hal_cxn_free(iscsi->hal, cxn)) {
            ocs_log_test(iscsi->os, "Failed to free connection %s\n", cxn->display_name);
        }

        if (is_ini_cxn &&
            !iscsi->shutting_down) {
            if (ocs_cxn_connect(iscsi, &remote_ip, tcp_port, tgt_name)) {
                ocs_log_test(iscsi->os, "failed Starting connection to target\n");
            }
        }
        break;

    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
        break;


    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}



/**
 * @ingroup cxn_sm
 * @brief Get information on the connection.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_get_info(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        /*
         * Get the connection information including the TCP MSS
         */
        rc = ocs_hal_cxn_get_info(iscsi->hal, cxn,
                      ocs_cxn_get_info_cb, cxn);
        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_reject, NULL);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_get_info_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        ocs_cxn_transition(cxn, __ocs_cxn_reject, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for connection information request to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_get_info_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_reject, NULL);
        break;

    case OCS_EVT_CXN_GET_INFO_CMPL:
        ocs_cxn_transition(cxn, __ocs_cxn_offload, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief Offload the connection to the chip.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_offload(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:

        rc = ocs_hal_cxn_offload(iscsi->hal,
                     cxn,
                     ocs->tcp_window_size,
                     0, /* data_digest */
                     0, /* hdr_digest */
                     OCS_ISCSI_LOGIN_MAX_RECV_DATA_SEG_LEN,
                     ocs_cxn_offload_cb,
                     cxn);
        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_cxn_transition(cxn, __ocs_cxn_reject, NULL);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_offload_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        ocs_cxn_transition(cxn, __ocs_cxn_reject, NULL);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for connection offload request to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_offload_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        ocs_log_debug(iscsi->os, "conn_hdl 0x%x Offloading new connection from %s, MSS %d\n",
                  cxn->conn_hdl,
                  cxn->display_name,
                  cxn->tcp_mss);
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
    case OCS_EVT_ERROR:
        ocs_cxn_transition(cxn, __ocs_cxn_close_abort_io, NULL);
        break;

    case OCS_EVT_CXN_OFFLOAD_CMPL:
        ocs_cxn_transition(cxn, __ocs_cxn_connected, NULL);
        break;

    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief Reject a connection after some connection protocol started.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_reject(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t rc;
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        rc = ocs_hal_cxn_reject(iscsi->hal, cxn->conn_hdl, ocs_cxn_reject_cb, cxn);
        if (rc == OCS_HAL_RTN_NO_RESOURCES) {
            ocs_cxn_set_sm_retry_timer(cxn, OCS_ISCSI_CXN_RETRY_TIMER_NO_RESOURCES_MS);
        } else if (rc) {
            ocs_log_test(iscsi->os, "connection from %s failed to reject\n", cxn->display_name);

            /* At least free up the cxn object */
            ocs_cxn_transition(cxn, __ocs_cxn_initial, NULL);
            (void)ocs_session_cxn_del(cxn);
            ocs_hal_cxn_free(iscsi->hal, cxn);
        } else {
            ocs_cxn_transition(cxn, __ocs_cxn_reject_wait, NULL);
        }
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
        /* we are rejecting already, so we have it covered */
        break;

    case OCS_EVT_CXN_GET_INFO_CMPL:
        /*
         * Since the connection can be closed during these operations,
         * there may be libgering events pending, just ignore them
         * as we are rejecting the connection.
         */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @ingroup cxn_sm
 * @brief State: Waiting for connection reject request to complete.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_reject_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        break;

    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
    case OCS_EVT_ERROR:
        /* Already rejected */
        break;

    case OCS_EVT_CXN_REJECT_CMPL:
        ocs_cxn_transition(cxn, __ocs_cxn_initial, NULL);
        (void)ocs_session_cxn_del(cxn);
        ocs_hal_cxn_free(iscsi->hal, cxn);
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}

/**
 * @ingroup cxn_sm
 * @brief An error was received, something unexpected occurred.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_cxn_error(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    std_cxn_state_decl();

    cxn_sm_trace();

    switch(evt) {
    case OCS_EVT_ENTER:
        ocs_log_test(iscsi->os, "connection from %s is in the error state\n",
                 cxn->display_name);
        break;

    case OCS_EVT_CXN_GET_INFO_CMPL:
    case OCS_EVT_CXN_OFFLOAD_CMPL:
    case OCS_EVT_CXN_REJECT_CMPL:
    case OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST:
    case OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST:
    case OCS_EVT_CXN_CLOSE_CMPL:
    case OCS_EVT_CXN_UPLOAD_CMPL:
    case OCS_EVT_CXN_RETRY_TIMER_EXPIRED:
        /* jusr stay here as something we don;t expect happened */
        break;

    default:
        __ocs_cxn_common(__func__, ctx, evt, arg);
        return NULL;
    }

    return NULL;
}


/**
 * @brief Function to receive the notification that the connection reject is
 *    complete.
 *
 * @param ul_arg Pointer to the cxn structure.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params NULL for this call.
 */
void
ocs_cxn_reject_cb(void *ul_arg,
          int32_t status,
          uint32_t ext_status,
          void   * params)
{
    ocs_cxn_t     *cxn     = ul_arg;
    ocs_iscsi_t   *iscsi   = cxn->iscsi;

    if (status) {
        ocs_log_test(iscsi->os, "Failed rejecting connection from %s\n", cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        ocs_log_debug(iscsi->os, "cxn rejected from %s\n", cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_REJECT_CMPL, NULL);
    }
}


/**
 * @brief Function to receive the notification that the connection info is
 *    available.
 *
 * @param ul_arg Pointer to the cxn structure.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params NULL for this call.
 *
 * @return Returns 0 on success.
 */
void
ocs_cxn_offload_cb(void *ul_arg,
           int32_t status,
           uint32_t ext_status,
           void  * params)
{
    ocs_cxn_t     *cxn     = ul_arg;
    ocs_iscsi_t   *iscsi   = cxn->iscsi;

    if (status) {
        ocs_log_test(iscsi->os, "Failed offloading connection from %s\n",
                 cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        ocs_log_debug(iscsi->os, "cxn Offloaded from %s, window scale %d\n",
                  cxn->display_name,
                  cxn->tcp_wscale);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_OFFLOAD_CMPL, NULL);
    }
}

/**
 * @brief Function to receive the notification that the connection info is
 *    available.
 *
 * @param ul_arg Pointer to the cxn structure.
 * @param status Status of the command.
 * @param ext_status Extended status of the command.
 * @param params NULL for this call.
 *
 * @return Returns 0 on success.
 */
void
ocs_cxn_get_info_cb(void *ul_arg,
            int32_t status,
            uint32_t ext_status,
            void      * params)
{
    ocs_cxn_t     *cxn     = ul_arg;
    ocs_iscsi_t   *iscsi   = cxn->iscsi;
    char ip_str[40];

    if (status) {
        ocs_log_test(iscsi->os, "Failed offloading connection from %s\n",
                 cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        format_ip_address(ocs_iscsi_convert_to_ip_type(cxn->source_ip_type),
                  cxn->source_ip,
                  ip_str, sizeof(ip_str));

        ocs_snprintf(cxn->display_name,
             sizeof(cxn->display_name),
             "%s(%d) cid %x",
             ip_str,
             cxn->source_port,
            cxn->conn_hdl);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_GET_INFO_CMPL, NULL);
    }
}

/**
 * @brief This function is the callback for connecting to a target.
 *
 * @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_cxn_connect_cb(void *ul_arg,
                   int32_t status,
                   uint32_t ext_status,
                   void  * params)
{
    ocs_cxn_t   *cxn = ul_arg;
    ocs_iscsi_t *iscsi = cxn->iscsi;

    if (status == 0) {
        ocs_log_debug(iscsi->os, "Connect success\n");
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_CONNECT_CMPL, NULL);
    } else {
        ocs_log_test(iscsi->os, "TCP connect failed with status %d, ext_status %d\n",
                 status, ext_status);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    }
}

/**
 * @brief This function is the callback for uploading a connection
 *
 * @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 NULL.
 */
static void ocs_cxn_upload_cb(void    *ul_arg,
                  int32_t  status,
                  uint32_t ext_status,
                  void    *params)
{
    ocs_cxn_t *cxn = ul_arg;
    ocs_iscsi_t *iscsi = cxn->iscsi;

    if (status) {
        ocs_log_test(iscsi->os, "Failed to upload connection %s\n",
                 cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        ocs_log_debug(iscsi->os, "connection uploaded %s\n",
                  cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_UPLOAD_CMPL, NULL);
    }
}


/**
 * @brief This function is the callback for closing a connection
 *
 * @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 NULL.
 */
static void ocs_cxn_close_cb(void *ul_arg,
                 int32_t status,
                 uint32_t ext_status,
                 void      * params)
{
    ocs_cxn_t *cxn = ul_arg;
    ocs_iscsi_t *iscsi = cxn->iscsi;

    if (status) {
        ocs_log_test(iscsi->os, "Failed to close connection %s\n",
                 cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        ocs_log_debug(iscsi->os, "closed connection %s\n",
                  cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_CLOSE_CMPL, NULL);
    }
}

/**
 * @ingroup cxn_mgnt
 * @brief Log an initiator into the specified target address
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param remote_ip Remote IP address to connect to.
 * @param tcp_port  Remote TCP port to connect to.
 * @param tgt_name The iSCSI target name.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_cxn_connect(ocs_iscsi_t *iscsi,
        ocs_hal_ip_address_t *remote_ip,
        uint16_t tcp_port,
        char *tgt_name)
{
    ocs_cxn_t *cxn;
    int32_t rc = -1;
    char ip_str[40];

    if (ocs_strlen(tgt_name) > OCS_MAX_ISCSI_NAME) {
        ocs_log_test(iscsi->os, "target name exceeds maximum length\n");
        return -1;
    }

    cxn = ocs_cxn_alloc(iscsi, 0);
    if (cxn != NULL) {
        int64_t isid;

        /* Use the Emulex OUI 0000c9 */
        isid = 0x0000c9000000l | cxn->instance_index;
        rc = ocs_session_cxn_new(cxn,
                     tgt_name,
                     ocs_iscsi_ini_get_name(cxn->ocs),
                     isid,
                     0, /* tsih */
                     cxn->instance_index, /* cid */
                     1); /* cmd_sn */

        /* This should not fail since there are as many sessions as cxn */
        if (rc) {
            ocs_log_test(iscsi->os, "failed, ocs_session_cxn_new() return %d\n",
                     rc);
            ocs_hal_cxn_free(iscsi->hal, cxn);
            return rc;
        }

        /* save the remote IP address for retries */
        cxn->dest_ip_type = remote_ip->ip_type;
        ocs_memcpy(cxn->dest_ip, remote_ip->ip_address, 16);
        cxn->dest_port = tcp_port;
        format_ip_address(ocs_iscsi_convert_to_ip_type(remote_ip->ip_type),
                  remote_ip->ip_address,
                  ip_str, sizeof(ip_str));
        ocs_snprintf(cxn->display_name,
             sizeof(cxn->display_name),
             "%s(%d)",
             ip_str,
             tcp_port);
        ocs_log_debug(iscsi->os, "attempt to connect to IP address %s\n",
                  ip_str);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_CONNECT, NULL);
    } else {
        ocs_log_err(iscsi->os, "Failed allocating an initiator connection\n");
    }
    return rc;
}

/**
 * @ingroup cxn_mgnt
 * @brief Function to receive new TCP connections.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param conn_hdl Connection handle from the firmware.
 *
 * @return Returns 0 on success.
 */
int32_t ocs_cxn_new_tgt_connection(ocs_iscsi_t *iscsi,
                   uint32_t     conn_hdl)
{
    ocs_t         *ocs = iscsi->os;
    ocs_cxn_t     *cxn = NULL;
    int32_t        rc = -1;

    ocs_log_debug(iscsi->os, "cxn event received conn_hdl 0x%x\n", conn_hdl);

    cxn = ocs_cxn_alloc(iscsi, conn_hdl);
    if (cxn == NULL) {
        rc = ocs_hal_cxn_reject(iscsi->hal, conn_hdl, NULL, NULL);
    } else {
        if (ocs_is_target_enabled()) {
            /*
             * Use validate initiator here to allow the target to reject
             * initiators.  Will call ocs_scsi_new_initiator during login, when
             * the initiator name is known.
             */
            if ((ocs_scsi_validate_initiator((ocs_node_t *) cxn) == FALSE) ) {
                ocs_log_test(iscsi->os, "conn_hdl %u failed adding initiator to target server\n",
                         conn_hdl);
                (void)ocs_session_cxn_del(cxn);
                ocs_hal_cxn_free(iscsi->hal, cxn);
                ocs_hal_cxn_reject(iscsi->hal, conn_hdl, NULL, NULL);
                return -1;
            }
        }
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_INCOMING_REQ, NULL);
    }

    return rc;
}

static void ocs_tgt_cxn_invalidate_cb(void *ul_arg,
                       int32_t status,
                       uint32_t ext_status,
                       void *params)
{
    ocs_cxn_t *cxn = ul_arg;
    ocs_iscsi_t *iscsi = cxn->iscsi;

    if (status) {
        ocs_log_test(iscsi->os, "Failed to close connection %s\n",
                 cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_ERROR, NULL);
    } else {
        ocs_log_debug(iscsi->os, "Invalidated cxn %s success\n",
                  cxn->display_name);
        ocs_sm_post_event(&cxn->sm, OCS_EVT_CXN_CLOSE_CMPL, NULL);
    }
}

void ocs_tgt_cxn_invalidate(ocs_cxn_t *cxn)
{
    ocs_iscsi_t *iscsi;
    int32_t rc;

    iscsi = cxn->iscsi;

    rc = ocs_hal_cxn_close(iscsi->hal, cxn, cxn->sendRst,
                   ocs_tgt_cxn_invalidate_cb,
                   cxn);
    if (rc) {
        ocs_cxn_transition(cxn, __ocs_cxn_error, NULL);
    } else {
        ocs_log_debug(iscsi->os, "sent request to close cxn, hdl=0x%x\n",
                  cxn->conn_hdl);
        ocs_scsi_del_initiator(cxn, OCS_SCSI_INITIATOR_DELETED);

        ocs_cxn_transition(cxn, __ocs_cxn_close_wait, NULL);
    }
}

/**
 * @ingroup cxn_mgnt
 * @brief Issues a request to the HAL to close the connection.
 *
 * @param cxn Pointer to the connection object.
 * @param sendRst Non-zero sends a TCP reset on the connection.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_cxn_close(ocs_cxn_t *cxn,
            uint8_t sendRst)
{
    ocs_sm_post_event(&cxn->sm,
              (sendRst ? OCS_EVT_CXN_SW_REQ_CLOSE_WITH_RST : OCS_EVT_CXN_SW_REQ_CLOSE_NO_RST),
              NULL);
    return 0;
}

/**
 * @brief Allocates a connection and initializes the fields as required.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device.
 * @param conn_hdl Connection handle from the firmware.
 *
 * @return Returns 0 on success.
 */
ocs_cxn_t*
ocs_cxn_alloc(ocs_iscsi_t *iscsi,
          uint32_t   conn_hdl)
{
    ocs_t     *ocs   = iscsi->os;
    ocs_cxn_t *cxn;

    cxn = ocs_hal_cxn_alloc(iscsi->hal, conn_hdl);
    if (cxn != NULL) {
        /*
         * Set the login parameters to the desired values and then let the
         * login change them as required.
         */
        cxn->data_digest = (ocs->enable_data_digest ? 1 : 0);
        cxn->hdr_digest  = (ocs->enable_hdr_digest ? 1 : 0);
        cxn->use_chap    = 0;
        cxn->max_rcv_dsl = 8192;
        cxn->max_xmit_dsl = 8192;
        cxn->chap_state  = 0;
        cxn->chap_ident_recv = 0;
        cxn->chap_challenge_recv = NULL;
        cxn->chap_response = NULL;
        cxn->chap_name_recv = NULL;
        cxn->chap_name_send = NULL;

        cxn->ocs          = iscsi->os;
        cxn->iscsi        = iscsi;
        cxn->session          = NULL;
        cxn->cxn_state        = CONN_STATE_NEW_CONN;
        cxn->is_leading_login     = TRUE;
        cxn->is_first_login_rsp   = 1;
        cxn->send_logout_rsp      = 0;
        cxn->logout_rsp           = 0;
        cxn->idle_count       = 0;
        cxn->lgn_parms_sent   = 0;
        cxn->lgn_parms_recv   = 0;
        cxn->stat_sn          = 0;
        cxn->no_idle_timer    = FALSE;
        cxn->sm.app       = cxn;
        cxn->ffp_is_neg_active    = FALSE;
        ocs_list_init(&cxn->cbit_list, ocs_cxn_q_cbit_t, link);
        cxn->cbit_rsp             = NULL;
        cxn->cbit_rsp_len         = 0;
        cxn->cbit_rsp_offset      = 0;
        cxn->data_digest_error    = FALSE;
        cxn->login_hdr_mem =
            *ocs_iscsi_tracker_calc(&iscsi->cxn_login_hdr, cxn->instance_index);
        cxn->login_data_mem =
            *ocs_iscsi_tracker_calc(&iscsi->cxn_login_data, cxn->instance_index);
        cxn->mgmt_functions   = &node_mgmt_functions;
        ocs_atomic_init(&cxn->login_mem_in_use, 0);
        ocs_list_init(&cxn->aborted_ios, ocs_io_t, link);
        ocs_atomic_init(&cxn->nop_abort_counter, 0);


        ocs_cxn_transition(cxn, __ocs_cxn_initial, NULL);
    }
    return cxn;
}

/**
 * @brief Generate node ddump data.
 *
 * @par Description
 * Generates the node ddump data.
 *
 * @param textbuf Pointer to text buffer.
 * @param node Pointer to node context.
 *
 * @return Returns 0 on success, or a negative value on failure.
 */

int
ocs_ddump_node(ocs_textbuf_t *textbuf, ocs_node_t *node)
{
    ocs_io_t *io;
    char ip_str[40];
    int retval = 0;

    ocs_ddump_section(textbuf, "node", node->instance_index);
    ocs_ddump_value(textbuf, "display_name", "%s", node->display_name);

    ocs_ddump_value(textbuf, "conn_hdl", "0x%x", node->conn_hdl);
    ocs_ddump_value(textbuf, "wq_id", "%d", node->wq_id);
    ocs_ddump_value(textbuf, "wq_index", "%d", node->wq_index);
    ocs_ddump_value(textbuf, "source_ip_type", "%d", node->source_ip_type);

    format_ip_address(ocs_iscsi_convert_to_ip_type(node->source_ip_type),
              node->source_ip, ip_str, sizeof(ip_str));
    ocs_ddump_value(textbuf, "source_ip", "%s", ip_str);
    ocs_ddump_value(textbuf, "source_port", "%d", node->source_port);
    ocs_ddump_value(textbuf, "dest_ip_type", "%d", node->dest_ip_type);

    format_ip_address(ocs_iscsi_convert_to_ip_type(node->dest_ip_type),
              node->dest_ip, ip_str, sizeof(ip_str));
    ocs_ddump_value(textbuf, "dest_ip", "%s", ip_str);
    ocs_ddump_value(textbuf, "dest_port", "%d", node->dest_port);
    ocs_ddump_value(textbuf, "tcp_mss", "%d", node->tcp_mss);
    ocs_ddump_value(textbuf, "max_wr_xfer_size", "%d", node->max_wr_xfer_size);

    // ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_NODE, node);
    ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_NODE, node);

    if (ocs_node_lock_try(node) != TRUE) {
        /* Didn't get the lock */
        return -1;
    }
        ocs_list_foreach(&node->active_ios, io) {
            ocs_ddump_io(textbuf, io);
        }
    ocs_node_unlock(node);

    ocs_ddump_endsection(textbuf, "node", node->instance_index);

    return retval;
}

void
ocs_mgmt_node_list(ocs_textbuf_t *textbuf, void *object)
{
    ocs_io_t *io;
    ocs_node_t *node = (ocs_node_t *)object;

    ocs_mgmt_start_section(textbuf, "node", node->instance_index);

    /* Readonly values */

    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "cid");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "source_ip_type");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "source_ip");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "source_port");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "dest_ip_type");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "dest_ip");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "dest_port");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tcp_mss");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "is_ini_cxn");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "max_wr_xfer_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "cxn_state");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "is_discovery_session");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "is_leading_login");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "sendRst");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "idle_count");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "lgn_parms_sent");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "lgn_parms_recv");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "cmd_sn");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "cmd_window");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "exp_cmd_sn");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "max_cmd_sn");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "stat_sn");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "sess_id");


    if (ocs_node_lock_try(node) == TRUE) {

        /* Here the node lock is held */
        ocs_list_foreach(&node->active_ios, io) {
            if ((io->mgmt_functions) && (io->mgmt_functions->get_list_handler)) {
                io->mgmt_functions->get_list_handler(textbuf, io);
            }
        }
        ocs_node_unlock(node);
    }

    ocs_mgmt_end_section(textbuf, "node", node->instance_index);
}

int
ocs_mgmt_node_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
{
    ocs_io_t *io;
    ocs_node_t *node = (ocs_node_t *)object;
    char qualifier[80];
    char ip_str[40];
    int retval = -1;

    ocs_mgmt_start_section(textbuf, "node", node->instance_index);
    ocs_snprintf(qualifier, sizeof(qualifier), "%s.node%d", parent, node->instance_index);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
        char *unqualified_name = name + strlen(qualifier) +1;

        /* See if it's a value I can supply */
        if (ocs_strcmp(unqualified_name, "cid") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cid", "0x%x", node->cid);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "source_ip_type") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "source_ip_type", "0x%x", node->source_ip_type);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "source_ip") == 0) {
            format_ip_address(ocs_iscsi_convert_to_ip_type(node->source_ip_type),
                      node->source_ip, ip_str, sizeof(ip_str));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "source_ip", ip_str);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "source_port") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "source_port", "%d", node->source_port);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "dest_ip_type") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "dest_ip_type", "0x%x", node->dest_ip_type);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "dest_ip") == 0) {
            format_ip_address(ocs_iscsi_convert_to_ip_type(node->dest_ip_type),
                      node->dest_ip, ip_str, sizeof(ip_str));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "dest_ip", ip_str);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "dest_port") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "dest_port", "%d", node->dest_port);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tcp_mss") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_mss", "%d", node->tcp_mss);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "is_ini_cxn") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_ini_cxn", node->is_ini_cxn);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "max_wr_xfer_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "max_wr_xfer_size", "%d", node->max_wr_xfer_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "display_name") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", node->display_name);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "cxn_state") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cxn_state", "0x%x", node->cxn_state);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "is_leading_login") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_leading_login", node->is_leading_login);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "sendRst") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "sendRst", "0x%x", node->sendRst);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "idle_count") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "idle_count", "%d", node->idle_count);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "lgn_parms_sent") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "lgn_parms_sent", "0x%" PRIx64 , node->lgn_parms_sent);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "lgn_parms_recv") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "lgn_parms_recv", "0x%" PRIx64 , node->lgn_parms_recv);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "stat_sn") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "stat_sn", "0x%x", node->stat_sn);
            retval = 0;
        } else {
            /* If I didn't know the value of this status pass the request to each of my children */
            ocs_node_lock(node);
            ocs_list_foreach(&node->active_ios, io) {
                if ((io->mgmt_functions) && (io->mgmt_functions->get_handler)) {
                    retval = io->mgmt_functions->get_handler(textbuf, qualifier, name, io);
                }

                if (retval == 0) {
                    break;
                }
            }
            ocs_node_unlock(node);
        }
    }

    ocs_mgmt_end_section(textbuf, "node", node->instance_index);

    return retval;
}

void
ocs_mgmt_node_get_all(ocs_textbuf_t *textbuf, void *object)
{
    ocs_io_t *io;
    ocs_node_t *node = (ocs_node_t *)object;
    char ip_str[40];

    ocs_mgmt_start_section(textbuf, "node", node->instance_index);

    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cid", "0x%x", node->cid);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "source_ip_type", "0x%x", node->source_ip_type);
    format_ip_address(ocs_iscsi_convert_to_ip_type(node->source_ip_type),
              node->source_ip, ip_str, sizeof(ip_str));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "source_ip", ip_str);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "source_port", "%d", node->source_port);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "dest_ip_type", "0x%x", node->dest_ip_type);
    format_ip_address(ocs_iscsi_convert_to_ip_type(node->dest_ip_type),
              node->dest_ip, ip_str, sizeof(ip_str));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "dest_ip", ip_str);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "dest_port", "%d", node->dest_port);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_mss", "%d", node->tcp_mss);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_ini_cxn", node->is_ini_cxn);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "max_wr_xfer_size", "%d", node->max_wr_xfer_size);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", node->display_name);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cxn_state", "0x%x", node->cxn_state);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_leading_login", node->is_leading_login);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "sendRst", "0x%x", node->sendRst);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "idle_count", "%d", node->idle_count);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "lgn_parms_sent", "0x%" PRIx64 ,  node->lgn_parms_sent);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "lgn_parms_recv", "0x%" PRIx64 , node->lgn_parms_recv);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "stat_sn", "0x%x", node->stat_sn);

    ocs_node_lock(node);
    ocs_list_foreach(&node->active_ios, io) {
        if ((io->mgmt_functions) && (io->mgmt_functions->get_all_handler)) {
            io->mgmt_functions->get_all_handler(textbuf, io);
        }

    }
    ocs_node_unlock(node);

    ocs_mgmt_end_section(textbuf, "node", node->instance_index);
}

int
ocs_mgmt_node_set(char *parent, char *name, char *value, void *object)
{
    ocs_io_t *io;
    ocs_node_t *node = (ocs_node_t *)object;
    char qualifier[80];
    int retval = -1;

    ocs_snprintf(qualifier, sizeof(qualifier), "%s/node[%d]", parent, node->instance_index);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {

        /* If I didn't know the value of this status pass the request to each of my children */
        ocs_node_lock(node);
        ocs_list_foreach(&node->active_ios, io) {
            if ((io->mgmt_functions) && (io->mgmt_functions->set_handler)) {
                retval = io->mgmt_functions->set_handler(qualifier, name, value, io);
            }

            if (retval == 0) {
                break;
            }
        }
        ocs_node_unlock(node);
    }

    return retval;
}

int
ocs_mgmt_node_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
           void *arg_out, uint32_t arg_out_length, void *object)
{
    ocs_io_t *io;
    ocs_node_t *node = (ocs_node_t *)object;
    char qualifier[80];
    int retval = -1;

    ocs_snprintf(qualifier, sizeof(qualifier), "%s.node%d", parent, node->instance_index);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {

        /* If I didn't know how to do this action pass the request to each of my children */
        ocs_node_lock(node);
        ocs_list_foreach(&node->active_ios, io) {
            if ((io->mgmt_functions) && (io->mgmt_functions->exec_handler)) {
                retval = io->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length,
                                      arg_out, arg_out_length, io);
            }

            if (retval == 0) {
                break;
            }
        }
        ocs_node_unlock(node);
    }

    return retval;
}