ocs_openiscsi_ini.c

Go to the documentation of this file.

/**
 * Copyright (C) 2013-2015 Emulex
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.  The full GNU General
 * Public License can be found at <http://www.gnu.org/licenses/>.
 *
 * Written by: Chris Moore (chris.moore@emulex.com)
 *
 * Emulex
 * 3333 Susan Street
 * Costa Mesa, CA 92626
 */


/**
 * @file
 * This file contains the linkage to functions that implement the separately loadable
 * back end initiator.
 *
 * Load sequence:
 * - Base driver is loaded.
 * - Separately loadable module (SLM) back-end initiator is loaded.
 * - SLM calls ocs_scsi_ini_driver_init().
 * - SLM enumerates each OCS object, and calls ocs_scsi_ini_new_device().
 */

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_transport.h>
#include <scsi/libiscsi.h>
#include <scsi/scsi_transport_iscsi.h>
#include <linux/if_ether.h>

#include "ocs.h"
#include "ocs_ini_template.h"
#include "ocs_scsi_ini.h"
#include "ocs_iscsi_spec.h"
#include "ocs_iscsi_api.h"
#include "ocs_session.h"

/*!
 * @defgroup openiscsi_initiator Open-iSCSI Interface Module (ocs_openiscsi)
 */

static struct scsi_transport_template *transport_template;

/* forward declarations */
int32_t ocs_scsi_cmd_cb(ocs_io_t *, ocs_scsi_io_status_e,
            ocs_scsi_cmd_resp_t *, uint32_t , void *);
static int32_t ocs_lnx_xport_unsol_cb(void *arg, ocs_cxn_t *cxn,
                      ocs_hal_rq_buffer_t *bhs,
                      uint32_t hdr_len, ocs_hal_rq_buffer_t *data,
                      uint32_t data_len, uint8_t code);
static void ocs_lnx_xport_link_state(ocs_t *ocs, ocs_link_state_e link_state);
int32_t ocs_scsi_map_sgl(ocs_t *, struct scsi_cmnd *, ocs_scsi_sgl_t *, uint32_t *);
static int ocs_conn_update_context(struct iscsi_conn *conn);
int ocs_scsi_abort_io(ocs_hal_t *hal, ocs_hal_io_t *hio,
              ocs_hal_abort_type_e abort_type);
static int ocs_eh_abort(struct scsi_cmnd *sc);

extern struct iscsi_transport ocs_lnx_xport_iscsi;

/* Data structures */
typedef struct ocs_lnx_iscsi_arg_s {
    ocs_sem_t sem;
    uint32_t status;
} ocs_lnx_iscsi_arg_t;

/* defines */
#define ocs_scsi_midlayer_result(host_code, scsi_code) (((host_code) << 16) | scsi_code)

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
#define SCSI_ISCSI_XPORT_ATTR_IS_VISIBLE_V1
#else
#define SCSI_ISCSI_XPORT_ATTR_IS_VISIBLE_V0
#endif

/* globals */
ocs_scsi_ini_template_t ocs_iscsi_ini_template = {
    .ocs_scsi_ini_new_domain = ocs_scsi_ini_new_domain,
    .ocs_scsi_ini_del_domain = ocs_scsi_ini_del_domain,
    .ocs_scsi_ini_new_sport = ocs_scsi_ini_new_sport,
    .ocs_scsi_ini_del_sport = ocs_scsi_ini_del_sport,
    .ocs_scsi_new_target = ocs_scsi_new_target,
    .ocs_scsi_del_target = ocs_scsi_del_target,
    .ocs_scsi_ini_ddump = ocs_scsi_ini_ddump,
};

/**
 * @ingroup openiscsi_initiator
 * @brief Host Template.
 *
 * @par Description
 * This structure is passed to the SCSI midlayer to register the
 * module as a host.
 */
struct scsi_host_template host_template = {
    .module         = THIS_MODULE,
    .name           = "Emulex OCS iSCSI midlayer interface",
    .proc_name      = "ocs",
    .queuecommand       = iscsi_queuecommand,
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0)
    .change_queue_depth = iscsi_change_queue_depth,
#endif
    .can_queue      = ISCSI_DEF_XMIT_CMDS_MAX - 1,
    .this_id        = -1,
    .sg_tablesize       = OCS_DEFAULT_SG_SEG_CNT,
    .cmd_per_lun        = OCS_CMD_PER_LUN,        // queue depth for each LUN
    .eh_abort_handler       = ocs_eh_abort,
    .eh_device_reset_handler= iscsi_eh_device_reset,
    .eh_target_reset_handler = iscsi_eh_recover_target,
    .use_clustering     = ENABLE_CLUSTERING,
    .target_alloc       = iscsi_target_alloc,
    .max_sectors        = 0xFFFF,
    .vendor_id      = OCS_NL_VENDOR_ID,
};

static int ocs_eh_abort(struct scsi_cmnd *sc)
{
    struct iscsi_task *task = (struct iscsi_task *)sc->SCp.ptr;
    ocs_io_t *aborted_io;
    ocs_hal_io_t *hio;
    ocs_t *ocs;
    ocs_iscsi_t *iscsi;
    int rc;
    ocs_io_task_t *io_task;

    io_task = (ocs_io_task_t *)task->dd_data;
    ocs_assert(io_task, -1);

    aborted_io = io_task->io;
    ocs_assert(aborted_io, -1);

    ocs = aborted_io->ocs;
    ocs_assert(ocs, -1);

    iscsi = &ocs->iscsi;
    ocs_assert(iscsi, -1);

    hio = aborted_io->hio;
    ocs_assert(hio, -1);

    ocs_log_debug(ocs, "EH aborted on IO type=%d, icd=%d\n",
              hio->type, hio->icd);

    rc = ocs_scsi_abort_io(iscsi->hal,
                   hio,
                   OCS_HAL_IO_ABORT_TYPE_TMF);
    if (rc) {
        ocs_log_test(ocs, "ocs scsi abort io failed\n");
    }

    return iscsi_eh_abort(sc);
}

int32_t ocs_ramlog_printf(void *os, const char *fmt, ...)
{
    return 0;
}

void ocs_print_stack(void)
{
        dump_stack();
}


/**
 * @brief Initialize initiator client.
 *
 * @par Description
 * Called by OS initialization code to initialize initiator
 * client. This is called prior to any PCI device enumeration.
 * @n @n
 * Registers with open-iscsi as a transport.
 *
 * @param initiator TRUE for initiator mode
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_ini_driver_init(int32_t initiator)
{
    int rc = 0;

        transport_template = iscsi_register_transport(&ocs_lnx_xport_iscsi);
        if (transport_template) {
        printk(KERN_INFO "%s: Registered transport with open-iscsi\n", __func__);
    } else {
        printk(KERN_INFO "%s: Failed to register transport with open-iscsi\n", __func__);
                rc = -1;
        }

    return rc;
}

/**
 * @brief initiator client exit
 *
 * @par Description
 * Called by OS driver-wide clean-up/exit code to clean up
 * initiator client.
 *
 * @param initiator TRUE for initiator mode
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_ini_driver_exit(int32_t initiator)
{
    iscsi_unregister_transport(&ocs_lnx_xport_iscsi);
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Initializes any initiator fields on the ocs structure.
 *
 * @par Description
 * Called by the OS initialization code when a new device is discovered.
 *
 * @param ocs Pointer to ocs.
 *
 * @return Returns 0 on success, or a non-zero error code value
 *         on failure.
 */

int32_t
ocs_scsi_ini_new_device(ocs_t *ocs)
{
    struct Scsi_Host *shost = NULL;
    ocs_iscsi_host_private_t *host_private = NULL;
    int ret;

    printk("%s: entry\n", __func__);

    /* Register with base driver */
    ret = ocs_scsi_register_ini_templ(ocs, &ocs_iscsi_ini_template);
    if (ret) {
        printk("%s: template registration failed\n", __func__);
        return -ENODEV;
    }
    printk("%s: template registration successful\n", __func__);

    /* Allocate a SCSI Host structure in the midlayer */
    shost = iscsi_host_alloc(&host_template, sizeof(*host_private), 0);
    if (!shost) {
        printk("%s: failed to allocate Scsi_Host struct\n", __func__);
        return -1;
    }

    /* save shost to initiator-client context */
    ocs->ini_ocs.shost = shost;

    /* save ocs information to shost LLD-specific space */
    host_private = iscsi_host_priv(shost);
    host_private->ocs = ocs;

    /*
     * Set initial can_queue value to the max SCSI IOs. This is the maximum
     * global queue depth (as opposed to the per-LUN queue depth -- .cmd_per_lun
     * This may need to be adjusted for I+T mode.
     */
    shost->can_queue = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
    shost->max_cmd_len = 16; // 16-byte CDBs

    /* can only accept (from mid-layer) as many SGEs as we've pre-registered */
    shost->sg_tablesize = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGL);

    /* attach iSCSI Transport template to shost */
    shost->transportt = transport_template;

    /* register callback for unsolicited initiator event*/
    ret = ocs_xport_control(ocs->xport, OCS_XPORT_REG_UNSOL_INI_CB, ocs_lnx_xport_unsol_cb);
    if (ret) {
        printk("%s: failed to register unsolicited callback\n", __func__);
        goto ocs_dealloc_iscsi_host;
    }

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

    /* get pci_dev structure and add host to SCSI ML */
    ret = iscsi_host_add(shost, &ocs->ocs_os.pdev->dev);
    if (ret) {
        printk("%s: failed iscsi_host_add\n", __func__);
        goto ocs_dealloc_iscsi_host;
    }

    // TODO:  How do we determine IPV4 or IPV6?
    iscsi_create_iface(shost, &ocs_lnx_xport_iscsi, ISCSI_IFACE_TYPE_IPV4, 0, 0);

    return 0;

ocs_dealloc_iscsi_host:
    iscsi_host_free(shost);
    ocs->ini_ocs.shost = NULL;
    return ret;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Tears down initiator members of ocs structure.
 *
 * @par Description
 * Called by the OS code when the device is removed.
 *
 * @param ocs Pointer to ocs.
 *
 * @return Returns 0.
 */

int32_t
ocs_scsi_ini_del_device(ocs_t *ocs)
{
    if (ocs->ini_ocs.shost) {
        printk("%s: Removing scsi%d from SCSI Midlayer\n", __func__, ocs->ini_ocs.shost->host_no);
        iscsi_host_remove(ocs->ini_ocs.shost);
        ocs->ini_ocs.shost = NULL;
    }

    /* Remove our link state callback registration */
    ocs_iscsi_unregister_link_state_callback(ocs, ocs_lnx_xport_link_state);

    /* Unregister from base driver */
    ocs_scsi_unregister_ini_templ(ocs);

    printk("%s: template unregistered\n", __func__);
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Accept new domain notification.
 *
 * @par Description
 * Called by the base driver when a new domain is discovered.  An initiator-client
 * will accept this call to prepare for new remote node notifications
 * arising from ocs_scsi_new_target(). The domain context has the element 
 * <b>ocs_scsi_ini_domain_t ini_domain</b> which is
 * declared by the initiator-client code and is used for initiator-client private data.
 * @n @n @b Notes: 
 * - This function will only be called if the base-driver has been enabled for initiator
 * capability.
 * - This call is made to initiator-client backends. The ocs_scsi_tgt_new_domain()
 * function is called to target-server backends.
 * - For the open-iscsi driver, nothing needs to be done for a new
 * domain, but this function is left in place as a template for
 * future use.
 *
 * @param domain Pointer to domain.
 *
 * @return Returns 0 for success, or a negative error code value for failure.
 */
int32_t ocs_scsi_ini_new_domain(ocs_domain_t *domain)
{
    ocs_assert(domain, -1);
    ocs_assert(domain->ocs, -1);
    printk("%s()\n", __func__);
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Accept domain lost notification.
 *
 * @par Description
 * Called by the base driver when a domain goes away. An initiator-client
 * uses this call to clean up all domain scoped resources.
 * @n @n @b Notes:
 * - This function is only called if the base driver has been enabled for initiator
 * capability.
 * - This call is made to initiator-client backends. The ocs_scsi_tgt_del_domain()
 * function is called to target-server backends.
 * - For the open-iscsi initiator nothing needs to be done when
 * deleting a domain, but this function is left in place as a
 * template for future use.
 *
 * @param domain Pointer to domain.
 *
 * @return Returns 0 for success, or a negative error code value for failure.
 */
void ocs_scsi_ini_del_domain(ocs_domain_t *domain)
{
    ocs_assert(domain);
    ocs_assert(domain->ocs);
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Process creation of a new SPORT.
 *
 * @par Description
 * This function is called by the base driver when a new SPORT
 * is discovered.
 * @n @n
 * For the open-iscsi initiator, no action is taken on creation
 * of a SPORT, but this function is left here as a template for
 * future use.
 *
 * @param sport The SPORT that has been created.
 *
 * @return Returns 0.
 */
int32_t ocs_scsi_ini_new_sport(ocs_sport_t *sport)
{
    printk("New SPORT: %s\n", sport->display_name);
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Process deletion of a SPORT.
 *
 * @par Description
 * This function is called by the base driver when a SPORT
 * has been deleted.
 * @n @n
 * For the open-iscsi initiator, no action is taken on deletion
 * of a SPORT, but this function is left here as a template for
 * future use.
 *
 * @param sport The SPORT that has been deleted.
 *
 * @return Returns 0.
 */
void ocs_scsi_ini_del_sport(ocs_sport_t *sport)
{
    printk("Del SPORT: %s\n", sport->display_name);
}

/**
 * @ingroup openiscsi_initiator
 * @brief Receive notification of a new SCSI target node.
 *
 * @par Description
 * Sent by the base driver to notify the initiator-client of the presence of a new
 * remote target. The initiator-server may use this call to prepare for
 * inbound IO from this node.
 * @n @n @b Note:
 * This function is only called if the base driver is enabled for initiator capability.
 *
 * @param node Pointer to new remote initiator node.
 *
 * @return None.
 *
 */

int32_t ocs_scsi_new_target(ocs_node_t *node)
{
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Delete a SCSI target node.
 *
 * @par Description
 * Sent by the base driver to notify the initiator-client that a remote target is now gone.
 * The initiator-client should terminate and clean up all I/Os associated with the node.
 * @n @n
 * The ocs_node_t structure has an element of type ocs_scsi_ini_node_t named
 * ni_node that is declared and used by a target-server for private
 * information.
 * @n @n @b Note:
 * This function is only called if the base driver is enabled for target capability.
 *
 * @param node Pointer node being deleted.
 * @param reason Reason for deleting the target.
 *
 * @return 
 * - OCS_SCSI_CALL_ASYNC if target delete is queued for async completion.
 * - OCS_SCSI_CALL_COMPLETE if call completed 
 * - error
 *
 */
int32_t ocs_scsi_del_target(ocs_node_t *node, ocs_scsi_del_target_reason_e reason)
{
    ocs_assert(node, OCS_SCSI_CALL_COMPLETE);
    ocs_assert(node->ocs, OCS_SCSI_CALL_COMPLETE);
    printk("%s()\n", __func__);
    return OCS_SCSI_CALL_COMPLETE;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Generate driver dump data for debugging.
 *
 * @par Description
 * This function is a placeholder for future use in dumping
 * driver debug data.
 *
 * @param textbuf The structure into which the data is dumped.
 * @param type The type of data to dump.
 * @param obj TBD
 */
void ocs_scsi_ini_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
{
}

/**
 * @brief Set scsi_cmnd check condition.
 *
 * @par Description
 * This function is called by the LLD to indicate that the given
 * scsi_cmnd resulted in a check condition. Sense data will be
 * filled out independently.
 *
 * @param scsi_cmd Command for which to set check condition.
 *
 */
static void
ocs_scsi_cmnd_result_chk_cond(struct scsi_cmnd *scsi_cmd)
{
    scsi_cmd->result = DRIVER_SENSE << 24 |
        ocs_scsi_midlayer_result(DID_ABORT, SAM_STAT_CHECK_CONDITION);
}

/**
 * @brief SCSI IO callback function.
 *
 * @par Description
 * This function is called back by the base driver to indicate
 * that the given IO has completed.
 *
 * @param io Pointer to IO that has completed.
 * @param status Status of IO.
 * @param rsp Pointer to response.
 * @param flags Flags.
 * @param arg Pointer to argument passed when sending IO.
 *
 */
int32_t
ocs_scsi_cmd_cb(
    ocs_io_t *io,
    ocs_scsi_io_status_e status,
    ocs_scsi_cmd_resp_t *rsp,
    uint32_t flags,
    void *arg)
{
    struct scsi_cmnd *scsi_cmd = io->ini_io.scsi_cmd;
    struct scsi_sense_hdr sshdr;
    int sense_len;
    ocs_assert(io, -1);
    ocs_assert(scsi_cmd, -1);

    switch (status) {
    case OCS_SCSI_STATUS_GOOD:
        /* success */
        scsi_cmd->result = ocs_scsi_midlayer_result(DID_OK, rsp->scsi_status);
        break;
    case OCS_SCSI_STATUS_ERROR:
        if (rsp->scsi_status == 2) {
            /* set check condition indication in scsi_cmd and copy sense data */
            sense_len = MIN(rsp->sense_data_length, SCSI_SENSE_BUFFERSIZE);
            ocs_scsi_cmnd_result_chk_cond(scsi_cmd);
            ocs_memcpy(scsi_cmd->sense_buffer, rsp->sense_data, sense_len);
            scsi_normalize_sense(scsi_cmd->sense_buffer, sense_len, &sshdr);

            printk("%s: check condition received x%x/x%x/x%x\n",
                __func__, sshdr.sense_key, sshdr.asc, sshdr.ascq);

        } else if (rsp->scsi_status == 0 && rsp->residual) {
            /* residual non-zero but good status; treat as okay */
            scsi_cmd->result = ocs_scsi_midlayer_result(DID_OK, rsp->scsi_status);
        } else {
            /* everything else; send generic error */
            printk("%s: OCS_SCSI_STATUS_ERROR, scsi_status=%d\n",
                __func__, rsp->scsi_status);
            scsi_cmd->result = ocs_scsi_midlayer_result(DID_ERROR, 0);
        }
        break;
    case OCS_SCSI_STATUS_NEXUS_LOST:
        scsi_cmd->result = ocs_scsi_midlayer_result(DID_ERROR, 0);
        break;
    default:
        /* for now, set DID_ERROR */
        scsi_cmd->result = ocs_scsi_midlayer_result(DID_ERROR, 0);
        printk("%s: Unhandled status=%d\n", __func__, status);
        break;
    }

    return 0;
}

/**
 * @brief Map mid-layer SGLs to ocs SGLs
 *
 * @par Description
 * This function is called by ocs_queuecommand() to map the SGL
 * received from the mid-layer to an ocs SGL that can be used by
 * the SCSI API.
 *
 * @param ocs The ocs pointer associated with this request.
 * @param scsi_cmd Command received from mid-layer.
 * @param sgl Resulting ocs SGL.
 * @param sgl_cnt [in] - Maximum number of SGLs that @c sgl can
 *            accommodate; [out] - The resulting number of SGL
 *            entries.
 *
 */
int32_t
ocs_scsi_map_sgl(
    ocs_t *ocs,
    struct scsi_cmnd *scsi_cmd,
    ocs_scsi_sgl_t *sgl,
    uint32_t *sgl_cnt)
{
    int num_seg = 0;
    int i = 0;
    struct scatterlist *sgel = NULL;

    ocs_assert(scsi_sg_count(scsi_cmd), -1);
    num_seg = scsi_dma_map(scsi_cmd);

    if (num_seg > *sgl_cnt) {
        /* shouldn't happen since we've already given mid-layer the max number */
        printk("%s: num SGEs=%d requested exceeds max=%d\n",
            __func__, num_seg, *sgl_cnt);
        return -1;
    }

    /* loop through each scsi_cmd SGE and fill out OCS-specific SGL */
    for (i = 0, sgel = scsi_sglist(scsi_cmd); i < (num_seg); i++, sgel = sg_next(sgel)) {
    //scsi_for_each_sg(scsi_cmd, sgel, nseg, i) {
        sgl[i].addr = sg_dma_address(sgel);
        sgl[i].len = sg_dma_len(sgel);
    }
    *sgl_cnt = i;
//  printk("%s: number of SGEs mapped=%d\n", __func__, *sgl_cnt);

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Unsolicited event handler.
 *
 * @par Description
 * Called by the iSCSI transport layer to handle unsolicited PDUs
 * for initiator connections. For open-iSCSI, we don't want the
 * iSCSI transport layer to receive unsolicited PDUs and push
 * them through state machines. The Linux iSCSI transport layer
 * (open-iSCSI) manages these.
 *
 * @param arg TBD.
 * @param cxn TBD.
 * @param bhs TBD.
 * @param hdr_len TBD.
 * @param data TBD.
 * @param data_len TBD.
 * @param code TBD.
 *
 * @return Returns 0 on success; or a negative error code value
 *         on failure.
 */
static
int32_t
ocs_lnx_xport_unsol_cb(void *arg,
               ocs_cxn_t *cxn,
               ocs_hal_rq_buffer_t *bhs,
               uint32_t   hdr_len,
               ocs_hal_rq_buffer_t *data,
               uint32_t   data_len,
               uint8_t    code)
{
    int rc = 0;
    struct iscsi_hdr *hdr = bhs->dma.virt;
    ocs_iscsi_t *iscsi = (ocs_iscsi_t *)arg;
    ocs_ep_t *ocs_ep;
    ocs_conn_t *ocs_conn;
    struct iscsi_conn *conn;
    struct iscsi_task *task;
    ocs_io_task_t *io_task = NULL;
    ocs_io_t *io = NULL;

    ocs_ep = cxn->ini_node.ocs_ep;
    ocs_assert(ocs_ep, -1);
    ocs_conn = ocs_ep->ocs_conn;
    ocs_assert(ocs_conn, -1);
    conn = ocs_conn->conn;
    ocs_assert(conn, -1);

    switch(hdr->opcode & ISCSI_OPCODE_MASK) {
    case ISCSI_RESP_LOGIN:
        {
            struct iscsi_login_rsp *rsp_hdr = (struct iscsi_login_rsp *)hdr;

            /*
             * libiscsi will handle most of the LOGIN processing, but we need to set
             * up the fields in our ocs_cxn_t to show that LOGIN is complete
             */
            if ((rsp_hdr->status_class == ISCSI_STATUS_CLS_SUCCESS) &&
                ((rsp_hdr->flags) & ISCSI_FLAG_LOGIN_TRANSIT) &&
                (ISCSI_LOGIN_NEXT_STAGE(rsp_hdr->flags) == ISCSI_FULL_FEATURE_PHASE)) {
                ocs_session_exp_cmd_sn_set(cxn, ocs_be32toh(rsp_hdr->exp_cmdsn));
                ocs_session_max_cmd_sn_set(cxn, ocs_be32toh(rsp_hdr->max_cmdsn));
                ocs_session_calc_cmd_window(cxn);
                cxn->cxn_state = CONN_STATE_FULL_FEATURE;
            }

            task = conn->login_task;
        }
        break;
    case ISCSI_RESP_TEXT:
    case ISCSI_RESP_LOGOUT:
        task = conn->login_task;
        break;
    default:
        task = conn->task;
        break;
    }

    if (task != NULL) {
        io_task = (ocs_io_task_t*) task->dd_data;
        if (io_task != NULL) {
            hdr->itt = io_task->original_itt;
            io_task->task_state = OCS_IO_TASK_STATE_FREE;
            io = io_task->io;
        }
    }

    /* Send the PDU to the openiscsi layer to handle the rest */
    rc = iscsi_complete_pdu(conn, hdr, (data ? data->dma.virt : NULL), data_len);
    if (rc) {
        printk("%s: iscsi_complete_pdu failed, rc=%d\n", __func__, rc);
    }

    if (io && io->node) {
        ocs_scsi_io_free(io);
    }

    /* return buffer to RX queue */
    if (!rc) {
        ocs_iscsi_rx_buffers_free(iscsi, bhs, data);
    }

    return rc;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Helper function for marking sessions as failed.
 *
 * @par Description
 * This is a helper function used by ocs_lnx_xport_link_state.
 * When a link goes down that function iterates over all
 * sessions on the link and calls this function for each of
 * them. This function then calls iscsi_session_failure for
 * each of the sessions to let open-iscsi know that the session
 * has failed.
 *
 *
 * @param cls_session TBD.
 */
static void ocs_lnx_xport_fail_session(struct iscsi_cls_session *cls_session)
{
        iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
}

/**
 * @ingroup openiscsi_initiator
 * @brief Called when the link changes state.
 *
 * @param ocs Pointer to the ocs structure.
 * @param link_state Provides the status of the link.
 *
 * @return None.
 */
static void ocs_lnx_xport_link_state(ocs_t *ocs, ocs_link_state_e link_state)
{
    ocs_iscsi_t *iscsi;
    struct Scsi_Host *shost;

    iscsi = &ocs->iscsi;
    shost = ocs->ini_ocs.shost;

    /* Notify libiscsi of the connection state change */
    if (link_state == OCS_LINK_STATE_DOWN) {
        iscsi_host_for_each_session(shost, ocs_lnx_xport_fail_session);

    }

}


/**
 * @ingroup openiscsi_initiator
 * @brief IO completion handler for iSCSI initiator.
 *
 * @par Description
 * This function is called on receipt of a Initiator Solicited CQE
 * in response to a SCSI I/O.  The CQE indicates that the
 * SCSI command has completed.
 * @n @n
 * This function restores the original ITT in the BHS, then calls
 * iscsi_complete_scsi_task to let libiscsi do its processing, then
 * calls ocs_scsi_cmd_cb to let the ocs_scsi layer complete its
 * processing.
 *
 * @param io Pointer to the io that completed.
 * @param status OCS_SCSI status.
 * @param rsp SCSI response, including SCSI status.
 * @param flags Flags (currently unused).
 * @param arg Argument from the upper layer (currently unused).
 *
 * @return Returns 0 on success; or a negative error code value
 *         on failure.
 */

static int32_t ocs_lnx_xport_io_cb (
        ocs_io_t *io,
        ocs_scsi_io_status_e status,
        ocs_scsi_cmd_resp_t *rsp,
        uint32_t flags,
        void *arg)
{
    ocs_cxn_t *cxn;
    ocs_ep_t *ep;
    struct iscsi_conn *conn;
    ocs_conn_t *ocs_conn;
    struct iscsi_hdr *hdr;
    ocs_io_task_t *io_task;
    struct iscsi_task *task;
    int exp_cmdsn;
    int max_cmdsn;
    int32_t rc;
    unsigned long irq_flags;
    spinlock_t *session_lock_iscsi;

    ocs_assert(io, -1);

    cxn = io->node;
    ocs_assert(cxn, -1);

    ep = cxn->ini_node.ocs_ep;
    ocs_assert(ep, -1);

    ocs_conn = ep->ocs_conn;
    ocs_assert(ocs_conn, -1);

    conn = ocs_conn->conn;
    ocs_assert(conn, -1);

    io_task = io->ini_io.io_task;
    ocs_assert(io_task, -1);

    task = io_task->task;
    ocs_assert(task, -1);

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)
    session_lock_iscsi = &task->conn->session->back_lock;
#else
    session_lock_iscsi = &task->conn->session->lock;
#endif

    /*
     * If this IO was aborted by the upper layer then do no issue a
     * callback because libiscsi already issued a completion to the
     * mid layer after calling cleanup_task().
     */
    if (io_task->task_state == OCS_IO_TASK_STATE_CLEANUP) {
        ocs_scsi_io_free(io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        return 0;
    }

    // hdr = io->bhs.virt;
    hdr = task->hdr;

    /* The ITT was modified to match the SLI-4 requirements before
     * the PDU was sent.  Now that the SLI port is done with it we
     * need to change it back to the tag that libiscsi assigned to
     * it so that libiscsi can find the task and complete processing
     * on it.
     */

    hdr->itt = io_task->original_itt;

    exp_cmdsn = ocs_session_exp_cmd_sn_get(cxn);
    max_cmdsn = (exp_cmdsn + ocs_session_cmd_window_get(cxn) - 1);

    rc = ocs_scsi_cmd_cb(io, status, rsp, flags, arg);

    /* Required to hold session lock for this call */
    spin_lock_irqsave(session_lock_iscsi, irq_flags);

    iscsi_complete_scsi_task(task, exp_cmdsn, max_cmdsn);
    spin_unlock_irqrestore(session_lock_iscsi, irq_flags);

    io_task->task_state = OCS_IO_TASK_STATE_FREE;
    ocs_scsi_io_free(io);
    return rc;
}


/**
 * @ingroup openiscsi_initiator
 * @brief Create a new iscsi session.
 *
 * @param ep TBD.
 * @param cmds_max Maximum commands supported.
 * @param qdepth Maximum queue depth.
 * @param initial_cmdsn Initial iSCSI CMDSN.
 *
 * @return Returns a pointer to the session object; or NULL.
 */
struct iscsi_cls_session *ocs_session_create(struct iscsi_endpoint *ep,
                         u16 cmds_max,
                         u16 qdepth,
                         u32 initial_cmdsn)
{
    struct iscsi_cls_session *cls_session;
    struct Scsi_Host *shost;
    struct iscsi_session *sess;
    ocs_t *ocs;
    ocs_ep_t *ocs_ep;
    ocs_session_t *ocs_sess;

    if (!ep) {
        return NULL;
    }
    ocs_ep = ep->dd_data;
    ocs_assert(ocs_ep, NULL);
    ocs_assert(ocs_ep->cxn, NULL);
    ocs = ocs_ep->cxn->ocs;
    ocs_assert(ocs, NULL);
    shost = ocs->ini_ocs.shost;

    // TODO: check max_cmds and update as necessary

    cls_session = iscsi_session_setup(&ocs_lnx_xport_iscsi,
                      shost, cmds_max,
                      sizeof(ocs_session_t),
                      sizeof(ocs_io_task_t),
                      initial_cmdsn, ISCSI_MAX_TARGET);
    if (!cls_session)
        return NULL;
    sess = cls_session->dd_data;
    ocs_sess = sess->dd_data;

    printk("%s(): cls_session=%p, ocs_sess=%p sess->state=%d\n",
        __func__, cls_session, ocs_sess, sess->state);

    return cls_session;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Destroy an iSCSI session.
 *
 * @par Description
 * Destroys iSCSI session instance and releases resources
 * allocated for it.
 *
 * @param cls_session Pointer to the iSCSI session to destroy.
 *
 * @return None.
 */
void ocs_session_destroy(struct iscsi_cls_session *cls_session)
{

    iscsi_session_teardown(cls_session);
}

/**
 * @ingroup openiscsi_initiator
 * @brief Create an instance of iSCSI connection.
 *
 * @param cls_session TBD.
 * @param cid TBD.
 *
 * @return TBD
 */
struct iscsi_cls_conn *
ocs_conn_create(struct iscsi_cls_session *cls_session, u32 cid)
{
    ocs_iscsi_host_private_t *host_private = NULL;
    ocs_t *ocs = NULL;
    struct Scsi_Host *shost;
    struct iscsi_cls_conn *cls_conn;
    ocs_conn_t *ocs_conn;
    struct iscsi_conn *conn;
    struct iscsi_session *sess;
    ocs_session_t *ocs_sess;

    shost = iscsi_session_to_shost(cls_session);
    ocs_assert(shost, NULL);
    host_private = iscsi_host_priv(shost);
    ocs = host_private->ocs;

    /* create iSCSI cls_conn */
    cls_conn = iscsi_conn_setup(cls_session, sizeof(*ocs_conn), cid);
    if (!cls_conn)
        return NULL;

    /* map OCS connection to iSCSI cls_conn connection */
    conn = cls_conn->dd_data;
    ocs_conn = conn->dd_data;
    ocs_conn->conn = conn;

    /* connection not yet bound to endpoint */
    ocs_conn->ocs_ep = NULL;

    /* map OCS session to new OCS connection */
    sess = cls_session->dd_data;
    ocs_sess = sess->dd_data;
    ocs_conn->ocs_sess = ocs_sess;

    return cls_conn;
}


/**
 * @ingroup openiscsi_initiator
 * @brief  Binds an iSCSI connection to an endpoint.
 *
 * @par Description
 * This function binds a connection/session pair to a connected
 * endpoint.
 *
 *
 * @param cls_session Pointer to iSCSI session.
 * @param cls_conn Pointer to iSCSI connection.
 * @param transport_fd File descriptor for the endpoint (not
 *                 used)
 * @param is_leading  Not used.
 *
 * @return Returns 0 on success; or a negative error code value
 *         on failure.
 */
int ocs_conn_bind(struct iscsi_cls_session *cls_session,
              struct iscsi_cls_conn *cls_conn,
              u64 transport_fd, int is_leading)
{
    struct iscsi_conn *conn = cls_conn->dd_data;
    ocs_conn_t *ocs_conn = conn->dd_data;
    struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
    ocs_iscsi_host_private_t *host_private = iscsi_host_priv(shost);
    ocs_t *ocs = host_private->ocs;
    ocs_ep_t *ocs_ep;
    struct iscsi_endpoint *ep;
    ocs_cxn_t *cxn;

    ocs_assert(ocs, -EINVAL);

    /* get iSCSI endpoint from transport_fd */
    ep = iscsi_lookup_endpoint(transport_fd);
    if (!ep)
        return -EINVAL;

    /* get corresponding OCS endpoint */
    ocs_ep = ep->dd_data;

    /* bind iSCSI connection to iSCSI session */
    if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
        return -EINVAL;

    /* map OCS connection (ocs_conn) to OCS endpoint (ocs_ep) */
    ocs_conn->ocs_ep = ocs_ep;
    ocs_ep->ocs_conn = ocs_conn;

    /* Now that the endpoint is associated with a connection we can map the node to the session */
    cxn = ocs_ep->cxn;
    cxn->session = ocs_conn->ocs_sess;

    printk("%s: connection bound to endpoint\n", __func__);
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 * @param shost TBD.
 * @param data TBD.
 * @param dt_len TBD.
 *
 * @return
 */
int ocs_iface_set_param(struct Scsi_Host *shost,
        void *data, uint32_t dt_len)
{

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 * @param iface TBD.
 * @param param_type TBD.
 * @param param TBD.
 * @param buf TBD.
 *
 * @return 
 */
int ocs_iface_get_param(struct iscsi_iface *iface,
        enum iscsi_param_type param_type,
        int param, char *buf)
{

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 *
 * @param ep
 * @param param
 * @param buf
 *
 * @return
 */
int ocs_ep_get_param(struct iscsi_endpoint *ep,
             enum iscsi_param param, char *buf)
{
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 *
 * @param cls_conn
 * @param param
 * @param buf
 *
 * @return
 */
int ocs_conn_get_param(struct iscsi_cls_conn *cls_conn,
               enum iscsi_param param, char *buf)
{
    struct iscsi_conn *conn = cls_conn->dd_data;
    ocs_conn_t *ocs_conn;
    ocs_cxn_t *cxn;
    int len;


    ocs_assert(conn, -1);
    ocs_conn = conn->dd_data;
    ocs_assert(ocs_conn, -1);
    ocs_assert(ocs_conn->ocs_ep, -1);
    cxn = ocs_conn->ocs_ep->cxn;

    switch(param) {
    case ISCSI_PARAM_PERSISTENT_PORT:
        len = sprintf(buf, "%d\n", cxn->source_port);
        break;
    case ISCSI_PARAM_PERSISTENT_ADDRESS:
        ocs_strcpy(buf, cxn->source_ip);
        len = strlen(buf);
        break;
    default:
        len = iscsi_conn_get_param(cls_conn, param, buf);
        break;
    }

    return len;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 *
 * @param cls_session
 * @param param
 * @param buf
 *
 * @return
 */
int ocs_session_get_param(struct iscsi_cls_session *cls_session,
                enum iscsi_param param, char *buf)
{
    int len = 0;

    switch(param) {
    default:
        return iscsi_session_get_param(cls_session, param, buf);
    }

    return len;

}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * 
 * @par Description
 * set iSCSI parameter. Return 0 on success, -ENODATA when param is not
 * supported, and a -Exx value on other error.
 *
 * @param cls_conn
 * @param param
 * @param buf
 * @param buflen
 *
 * @return
 */
int ocs_set_param(struct iscsi_cls_conn *cls_conn,
              enum iscsi_param param, char *buf, int buflen)
{
    struct iscsi_conn *conn = cls_conn->dd_data;
    struct iscsi_session *session = conn->session;
    ocs_conn_t *ocs_conn;
    ocs_cxn_t *cxn;
    ocs_session_t *ocs_sess;
    int ret;



    ocs_assert(conn, -1);
    ocs_conn = conn->dd_data;
    ocs_assert(ocs_conn, -1);
    ocs_assert(ocs_conn->ocs_ep, -1);
    cxn = ocs_conn->ocs_ep->cxn;
    ocs_sess = cxn->session;

    /* libiscsi will set appropriate session field */
    ret = iscsi_set_param(cls_conn, param, buf, buflen);
    if (ret)
        return ret;

    switch (param) {
    case ISCSI_PARAM_FIRST_BURST:
        printk("%s(): cxn=%p first_burst=%d\n", __func__, cxn, session->first_burst);
        // TODO: be2iscsi does this; verify that we need to limit
        if (session->first_burst > 8192)
            session->first_burst = 8192;

        ocs_sess->login_options.first_burst = session->first_burst;
        break;
    case ISCSI_PARAM_MAX_RECV_DLENGTH:
        printk("%s(): cxn=%p max_recv_dl=%d\n", __func__, cxn, conn->max_recv_dlength);
        // TODO: be2iscsi does this; verify that we need to limit
        if (conn->max_recv_dlength > 65536)
            conn->max_recv_dlength = 65536;

        /* save in context for next call to ocs_conn_start */
        cxn->max_rcv_dsl = conn->max_recv_dlength;
        break;
    case ISCSI_PARAM_MAX_BURST:
        printk("%s(): cxn=%p max_burst=%d\n", __func__, cxn, session->max_burst);
        // TODO: be2iscsi does this; verify that we need to limit
        if (session->max_burst > 262144)
            session->max_burst = 262144;

        /* save in context for next call to ocs_conn_start */
        ocs_sess->login_options.max_burst = session->max_burst;
        break;
    case ISCSI_PARAM_MAX_XMIT_DLENGTH:
        printk("%s(): cxn=%p max_xmit_dlen=%d\n",
            __func__, cxn, conn->max_xmit_dlength);
        // TODO: be2iscsi does this; verify that we need to limit
        if ((conn->max_xmit_dlength > OCS_ISCSI_LOGIN_MAX_RECV_DATA_SEG_LEN) ||
            (conn->max_xmit_dlength == 0))
            conn->max_xmit_dlength = OCS_ISCSI_LOGIN_MAX_RECV_DATA_SEG_LEN;

        /* save in context for next call to ocs_conn_start */
        cxn->max_xmit_dsl = conn->max_xmit_dlength;
        break;
    case ISCSI_PARAM_PERSISTENT_ADDRESS:
        ocs_memcpy(cxn->source_ip, conn->persistent_address, 16);
        break;
    case ISCSI_PARAM_PERSISTENT_PORT:
        cxn->source_port = conn->persistent_port;
        break;
    case ISCSI_PARAM_HDRDGST_EN:
        printk("%s(): cxn=%p HdrDigest=%d\n",
            __func__, cxn, conn->hdrdgst_en);
        cxn->hdr_digest = conn->hdrdgst_en;
        break;
    case ISCSI_PARAM_DATADGST_EN:
        printk("%s(): cxn=%p DataDigest=%d\n",
            __func__, cxn, conn->datadgst_en);
        cxn->data_digest = conn->datadgst_en;
        break;
    case ISCSI_PARAM_IMM_DATA_EN:
        printk("%s(): cxn=%p immediate_data=%d\n",
               __func__, cxn, session->imm_data_en);
        ocs_sess->login_options.immediate_data = session->imm_data_en;
        break;
    default:
        break;

    }

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 * @param shost
 * @param param
 * @param buf
 * @param buflen
 *
 * @return
 */
int ocs_set_host_param(struct Scsi_Host *shost,
              enum iscsi_host_param param, char *buf, int buflen)
{
    int ret;

        ret = iscsi_host_set_param(shost, param, buf, buflen);
        if (ret) {
                return ret;
        }

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 *
 * @param shost
 * @param param
 * @param buf
 *
 * @return
 */
int ocs_get_host_param(struct Scsi_Host *shost,
               enum iscsi_host_param param, char *buf)
{
    ocs_iscsi_host_private_t *host_private = iscsi_host_priv(shost);
    ocs_t *ocs = host_private->ocs;
    int status = 0;

    switch (param) {
    case ISCSI_HOST_PARAM_HWADDRESS:
        status = sysfs_format_mac(buf, ocs_iscsi_mac_get(ocs), ETH_ALEN);
        break;
    case ISCSI_HOST_PARAM_INITIATOR_NAME:
        strcpy(buf, ocs_iscsi_ini_get_name(ocs));
        status = strlen(buf);
        break;
    default:
        status = iscsi_host_get_param(shost, param, buf);
        break;
    }

    return status;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 * @par Description
 *
 *
 * @param cls_conn
 * @param stats
 */
void ocs_conn_get_stats(struct iscsi_cls_conn *cls_conn,
                struct iscsi_stats *stats)
{

}

/**
 * @ingroup openiscsi_initiator
 * @brief  Set UPDATE CONTEXT options
 *
 * @par Description
 * Set the parameters that libiscsi keeps track of that are
 * required by CONTEXT_UPDATE_WQE.
 *
 * @param iparam
 * @param conn
 *
 * @return None.
 */
void ocs_set_update_ctx_options (ocs_hal_io_param_t *iparam,
                 struct iscsi_conn *conn)
{
    struct iscsi_session *session = conn->session;

    iparam->context_upd.lgn_options.session_options.max_burst = session->max_burst;
    iparam->context_upd.lgn_options.max_rcv_dsl = conn->max_recv_dlength;
    iparam->context_upd.lgn_options.max_send_dsl = conn->max_xmit_dlength;
    iparam->context_upd.lgn_options.session_options.first_burst = session->first_burst;
    iparam->context_upd.lgn_options.session_options.error_recovery_level = session->erl;
    iparam->context_upd.lgn_options.data_digest = conn->datadgst_en;
    iparam->context_upd.lgn_options.hdr_digest  = conn->hdrdgst_en;
    iparam->context_upd.lgn_options.session_options.initial_r2t = session->initial_r2t_en;
    iparam->context_upd.lgn_options.session_options.immediate_data = session->imm_data_en;
    iparam->context_upd.statsn = (conn->exp_statsn);

}

/**
 * @ingroup openiscsi_initiator
 * @brief Offload of session to chip
 *
 * @par Description
 *
 *
 * @param cls_conn
 *
 * @return Returns 0.
 */
int ocs_conn_start(struct iscsi_cls_conn *cls_conn)
{
    // uint32_t rc;
    // ocs_hal_io_param_t iparam;
    ocs_conn_t *ocs_conn;
    ocs_ep_t *ocs_ep;
    ocs_cxn_t *cxn;
    ocs_iscsi_t *iscsi;
    struct iscsi_conn *conn;
    // ocs_lnx_iscsi_arg_t arg;

    conn = cls_conn->dd_data;
    ocs_assert(conn, -1);
    ocs_conn = conn->dd_data;
    ocs_assert(ocs_conn, -1);
    ocs_ep = ocs_conn->ocs_ep;
    ocs_assert(ocs_ep, -1);
    cxn = ocs_ep->cxn;
    ocs_assert(cxn, -1);
    iscsi = cxn->iscsi;
    ocs_assert(iscsi, -1);


    ocs_conn_update_context(conn);

    iscsi_conn_start(cls_conn);

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 *
 * @par Description
 *
 * @param conn
 *
 * @return
 */
static
int ocs_conn_update_context(struct iscsi_conn *conn)
{
    uint32_t rc = 0;
    struct iscsi_session *session;
    ocs_conn_t *ocs_conn;
    ocs_ep_t *ocs_ep;
    ocs_cxn_t *cxn;
    ocs_session_t *ocs_session;

    ocs_assert(conn, -1);
    ocs_conn = conn->dd_data;
    ocs_assert(ocs_conn, -1);
    session = conn->session;
    ocs_assert(session, -1);
    ocs_ep = ocs_conn->ocs_ep;
    ocs_assert(ocs_ep, -1);
    cxn = ocs_ep->cxn;
    ocs_assert(cxn, -1);
    ocs_session = cxn->session;
    ocs_assert(session, -1);

    // Copy data from the open-iscsi structures to the ocs structures
    cxn->data_digest = conn->datadgst_en;
    cxn->hdr_digest = conn->hdrdgst_en;
    cxn->max_rcv_dsl = conn->max_recv_dlength;
    cxn->max_xmit_dsl = conn->max_xmit_dlength;
    cxn->stat_sn = conn->exp_statsn;
    ocs_session->login_options.max_burst = session->max_burst;
    ocs_session->login_options.first_burst = session->first_burst;
    ocs_session->login_options.error_recovery_level = session->erl;
    ocs_session->login_options.initial_r2t = session->initial_r2t_en;
    ocs_session->login_options.immediate_data = session->imm_data_en;

    rc = ocs_iscsi_send_context_udpate(cxn);

    return rc;
}

/**
 * @ingroup openiscsi_initiator
 * @brief
 *
 * @par Description
 *
 * @param addr
 * @param hal_ip
 * @param port
 *
 * @return
 */
static int
ocs_sockaddr_to_hal_ip(struct sockaddr *addr, ocs_hal_ip_address_t *hal_ip, uint16_t *port)
{
    struct sockaddr_in *daddr_in = (struct sockaddr_in *)addr;
    struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)addr;
    if (addr->sa_family == PF_INET) {
        __be32 s_addr = daddr_in->sin_addr.s_addr;
        hal_ip->ip_type = OCS_HAL_IP_TYPE_V4;
        hal_ip->ip_address[0] = s_addr & 0x000000ff;
        hal_ip->ip_address[1] = (s_addr & 0x0000ff00) >> 8;
        hal_ip->ip_address[2] = (s_addr & 0x00ff0000) >> 16;
        hal_ip->ip_address[3] = (s_addr & 0xff000000) >> 24;
        *port = ntohs(daddr_in->sin_port);
    } else if (addr->sa_family == PF_INET6) {
        hal_ip->ip_type = OCS_HAL_IP_TYPE_V6;
        memcpy(hal_ip->ip_address, &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
        *port = ntohs(daddr_in6->sin6_port);
    } else{
        return -1;
    }
    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Ask the chip to create TCP connection.
 *
 * @par Description
 * This routine first asks the chip to create a connection and then
 * allocates an EP.
 *
 * @param shost Pointer to Scsi_Host structure.
 * @param dst_addr The IP address of the target.
 * @param non_blocking Blocking or non-blocking call.
 *
 * @return
 * - A pointer to an endpoint on success.
 * - A negative error value on error.
 */
struct iscsi_endpoint *
ocs_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr, int non_blocking)
{
    ocs_iscsi_host_private_t *host_private = NULL;
    ocs_t *ocs = NULL;
    ocs_ep_t *ocs_ep = NULL;
    struct iscsi_endpoint *ep;
    int ret;
    ocs_hal_ip_address_t remote_ip;
    uint16_t remote_port = 0;
    ocs_cxn_t *cxn = NULL;

    if (shost) {
        host_private = iscsi_host_priv(shost);
    } else {
        ret = -ENXIO;
        return ERR_PTR(ret);
    }

    ocs = host_private->ocs;
    ep = iscsi_create_endpoint(sizeof(ocs_ep_t));
    if (!ep) {
        ret = -ENOMEM;
        return ERR_PTR(ret);
    }

    ocs_ep = ep->dd_data;
    ocs_ep->openiscsi_ep = ep;
    ocs_ep->cxn = NULL;

    /* translate socket address format to hal IP address and port */
    ret = ocs_sockaddr_to_hal_ip(dst_addr, &remote_ip, &remote_port);
    if (ret) {
        printk("%s(): failed to translate IP address\n", __func__);
        ret = -EIO;
        goto ocs_free_ep;
    }

    /* use OCS Transport API to connect */
    if (remote_ip.ip_type == OCS_HAL_IP_TYPE_V4) {
        printk("%s(): attempt to connect to IPv4 address %d.%d.%d.%d\n",
            __func__,
            remote_ip.ip_address[0],
            remote_ip.ip_address[1],
            remote_ip.ip_address[2],
            remote_ip.ip_address[3]);
    } else {
        uint16_t *word = (uint16_t *)remote_ip.ip_address;
        printk("%s(): attempt to connect to IPv6 address %x:%x:%x:%x:%x:%x:%x:%x\n",
            __func__,
            word[0],
            word[1],
            word[2],
            word[3],
            word[4],
            word[5],
            word[6],
            word[7]);
    }
    ret = ocs_xport_control(ocs->xport, OCS_XPORT_CONNECT, &remote_ip, remote_port, &cxn);
    if (ret) {
        printk("%s(): connection failed, status=%d\n", __func__, ret);
        ret = -EIO;
        goto ocs_free_ep;
    } else {
        ocs_assert(cxn, ERR_PTR(-EIO));
        printk("%s(): connection success\n", __func__);
        cxn->cxn_state = CONN_STATE_NEW_CONN;
    }

    ocs_ep->cxn = cxn;
    cxn->ini_node.ocs_ep = ocs_ep;
    return ep;

ocs_free_ep:
    iscsi_destroy_endpoint(ep);
    return ERR_PTR(ret);
}


/**
 * @ingroup openiscsi_initiator
 * @brief  Poll to see if a connection is established.
 *
 * @par Description
 * Poll to see if TCP connection is established.
 *
 * @param ep The endpoint to be polled.
 * @param timeout_ms Maximum time to wait (not used).
 *
 * @return Returns 1 if the endpoint is connected; or 0 if not.
 */
int ocs_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
{
    ocs_ep_t *ocs_ep;
    int ret;

    if (!ep) {
        return -1;
    }

    ocs_ep = ep->dd_data;
    ocs_assert(ocs_ep, -1);

    /* return 1 if connection is valid, 0 otherwise */
    ret = (ocs_ep->cxn ? 1 : 0);
    return ret;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Tears down the TCP connection.
 *
 * @par Description
 * Tears down a TCP connection.
 *
 * @param ep The endpoint to be disconnected.
 *
 * @return None.
 */
void ocs_ep_disconnect(struct iscsi_endpoint *ep)
{
    ocs_ep_t *ocs_ep;
    ocs_cxn_t *cxn = NULL;
    int32_t ret;
    ocs_t *ocs = NULL;
    uint32_t reset;

    if (!ep) {
        return;
    }

    ocs_ep = ep->dd_data;
    ocs_assert(ocs_ep);
    cxn = ocs_ep->cxn;
    ocs = cxn->ocs;

    if (ocs_ep->ocs_conn != NULL) {
        iscsi_suspend_queue(ocs_ep->ocs_conn->conn);
        reset = 1;
    } else {
        reset = 0;
    }

    /* use OCS Transport API to disconnect */
    ret = ocs_xport_control(ocs->xport, OCS_XPORT_DISCONNECT, cxn, reset);
    if (ret) {
        printk("%s(): disconnect failed, status=%d\n", __func__, ret);
        return;
    }
    // ocs_iscsi_login_cxn_cleanup(cxn) needed ?
    // ocs_iscsi_del_target(cxn) needed ?
    printk("%s(): disconnect success, ep=%p ocs_ep=%p cxn=%p\n",
        __func__, ep, ocs_ep, cxn);

    /* use OCS Transport API to "upload" connection */
    ret = ocs_xport_control(ocs->xport, OCS_XPORT_UPLOAD, cxn, reset);
    if (ret) {
        printk("%s(): upload failed, status=%d\n", __func__, ret);
        return;
    }
    // ocs_iscsi_login_cxn_cleanup(cxn) needed ?
    // ocs_iscsi_del_target(cxn) needed ?
    printk("%s(): upload success, ep=%p ocs_ep=%p cxn=%p\n",
        __func__, ep, ocs_ep, cxn);

    iscsi_destroy_endpoint(ocs_ep->openiscsi_ep);
}


/**
 * @ingroup openiscsi_initiator
 * @brief Completion handler for non-SCSI initiator tasks that complete on
 *        TCP ACK.
 *
 * @par Description
 * This function is called on receipt of a DMSG_CQE. The CQE indicates that a
 * DM_CMD_WQE has been sent with the DM flag set and a TCP ACK has been
 * received. We must wait for the response to come up the unsolicited path
 * to complete the "task" to libiscsi.
 *
 * @param io Pointer to the io that completed.
 * @param exp_cmdsn TBD.
 * @param max_cmdsn TBD.
 * @param response TBD.
 *
 * @return Returns 0 on success; negative error value on
 *         failure.
 */

int32_t ocs_iscsi_mtask_cb_tcp_ack_wait_rsp(ocs_io_t *io, uint32_t exp_cmdsn,
                        uint32_t max_cmdsn, uint8_t response)
{
    ocs_io_task_t *io_task;
    ocs_cxn_t *cxn;
    ocs_ep_t *ep;
    ocs_conn_t *ocs_conn;
    struct iscsi_conn *conn;

    ocs_assert(io, -1);

    cxn = io->node;
    ocs_assert(cxn, -1);

    ep = cxn->ini_node.ocs_ep;
    ocs_assert(ep, -1);

    ocs_conn = ep->ocs_conn;
    ocs_assert(ocs_conn, -1);

    io_task = io->ini_io.io_task;
    ocs_assert(io_task, -1);

    conn = ocs_conn->conn;
    ocs_assert(conn, -1);

    /*
     * If this IO was aborted by the upper layer then do no issue a
     * callback because libiscsi already issued a completion to the
     * mid layer after calling cleanup_task().
     */
    if (io_task->task_state == OCS_IO_TASK_STATE_CLEANUP) {
        ocs_scsi_io_free(io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        return 0;
    }

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Completion handler for non-SCSI initiator tasks that complete on
 *        TCP ACK.
 *
 * @par Description
 * This function is called on receipt of a DMSG_CQE. The CQE indicates that a
 * DM_CMD_WQE has been sent with the DM flag set and a TCP ACK has been
 * received. There is no response coming, so complete the "task" to libiscsi.
 *
 * @param io Pointer to the io that completed.
 * @param exp_cmdsn TBD.
 * @param max_cmdsn TBD.
 * @param response TBD.
 *
 * @return Returns 0 on success; negative error value on
 *         failure.
 */

int32_t ocs_iscsi_mtask_cb_tcp_ack_no_rsp(ocs_io_t *io, uint32_t exp_cmdsn,
                      uint32_t max_cmdsn, uint8_t response)
{
    struct iscsi_hdr *hdr;
    ocs_io_task_t *io_task;
    ocs_cxn_t *cxn;
    ocs_ep_t *ep;
    ocs_conn_t *ocs_conn;
    struct iscsi_conn *conn;
    int rc;

    ocs_assert(io, -1);

    cxn = io->node;
    ocs_assert(cxn, -1);

    ep = cxn->ini_node.ocs_ep;
    ocs_assert(ep, -1);

    ocs_conn = ep->ocs_conn;
    ocs_assert(ocs_conn, -1);

    io_task = io->ini_io.io_task;
    ocs_assert(io_task, -1);

    conn = ocs_conn->conn;
    ocs_assert(conn, -1);

    /*
     * If this IO was aborted by the upper layer then do no issue a
     * callback because libiscsi already issued a completion to the
     * mid layer after calling cleanup_task().
     */
    if (io_task->task_state == OCS_IO_TASK_STATE_CLEANUP) {
        ocs_scsi_io_free(io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        return 0;
    }

    /* Reset the ITT back to the one that libiscsi is expecting to see */
    hdr = (struct iscsi_hdr *)io->bhs;
    hdr->itt = io_task->original_itt;

    io_task->task_state = OCS_IO_TASK_STATE_FREE;
    rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
    if (rc) {
        if (rc == ISCSI_ERR_BAD_OPCODE) {
            printk("%s: iscsi_complete_pdu returns BAD_OPCODE %d\n",
                   __func__, hdr->opcode);
        } else {
            printk("%s: iscsi_complete_pdu failed, rc=%d\n", __func__, rc);
        }
    }

    ocs_scsi_io_free(io);
    return rc;
}

/**
 * @ingroup openiscsi_initiator
 * @brief Completion handler for non-SCSI initiator tasks.
 *
 * @par Description
 * This function is called on receipt of a DMSG_CQE with a response PDU.
 * The CQE indicates that a DM_CMD_WQE has been sent without the DM flag set.
 * A response is received as part of the completion.
 *
 * @param io Pointer to the io that completed.
 * @param exp_cmdsn TBD.
 * @param max_cmdsn TBD.
 * @param response TBD.
 *
 * @return Returns 0 on success; or a negative error value on
 *         failure.
 */

int32_t ocs_iscsi_mtask_cb_with_rsp(ocs_io_t *io, uint32_t exp_cmdsn,
                    uint32_t max_cmdsn, uint8_t response)
{
    struct iscsi_hdr *hdr;
    ocs_io_task_t *io_task;
    ocs_cxn_t *cxn;
    ocs_ep_t *ep;
    ocs_conn_t *ocs_conn;
    struct iscsi_conn *conn;
    int rc;

    ocs_assert(io, -1);

    cxn = io->node;
    if (cxn == NULL) {
        return -1;
    }

    ep = cxn->ini_node.ocs_ep;
    ocs_assert(ep, -1);

    ocs_conn = ep->ocs_conn;
    ocs_assert(ocs_conn, -1);

    io_task = io->ini_io.io_task;
    ocs_assert(io_task, -1);

    conn = ocs_conn->conn;
    ocs_assert(conn, -1);

    /*
     * If this IO was aborted by the upper layer then do no issue a
     * callback because libiscsi already issued a completion to the
     * mid layer after calling cleanup_task().
     */
    if (io_task->task_state == OCS_IO_TASK_STATE_CLEANUP) {
        ocs_scsi_io_free(io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        return 0;
    }

    /* Reset the ITT back to the one that libiscsi is expecting to see */
    hdr = (struct iscsi_hdr *)io->bhs;
    hdr->itt = io_task->original_itt;


    /*
     * For nop-out, the FW does not put the response into the BHS, so we
     * end up having to build a fake NOP-IN here to get things to work.
     */
    if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_CMD_NOOP) {
        iscsi_nopin_hdr_t *nop_hdr = (iscsi_nopin_hdr_t *)io->bhs;
        nop_hdr->expCmdSN = ocs_htobe32(exp_cmdsn);
        nop_hdr->maxCmdSN = ocs_htobe32(max_cmdsn);
        nop_hdr->opcode = ISCSI_OP_NOOP_IN;
        nop_hdr->ttt = 0xffffffff;
    }

    io_task->task_state = OCS_IO_TASK_STATE_FREE;
    rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
    if (rc) {
        if (rc == ISCSI_ERR_BAD_OPCODE) {
            printk("%s: iscsi_complete_pdu returns BAD_OPCODE %d\n",
                   __func__, hdr->opcode);
        } else {
            printk("%s: iscsi_complete_pdu failed, rc=%d\n", __func__, rc);
        }
    }

    ocs_scsi_io_free(io);
    return rc;
}


/**
 * @ingroup openiscsi_initiator
 * @brief  Transmit a management task
 *
 * @par Description
 * Transmits a task that does not perform a SCSI I/O.
 *
 * @param task Task to be transmitted.
 *
 * @return Returns 0 on success; or a negative error code value
 *         on failure.
 */
static int ocs_xmit_mtask(struct iscsi_task *task)
{
    ocs_io_task_t *io_task = task->dd_data;
    ocs_io_t *io = io_task->io;
    struct iscsi_conn *conn = task->conn;
    ocs_t *ocs;
    ocs_conn_t *ocs_conn = conn->dd_data;
    ocs_cxn_t *cxn;
    iscsi_bhs_t *bhs;
    ocs_iscsi_pdu_cb_t cb;
    bool is_login;
    bool set_dm;
    int32_t  rc;

    ocs_assert(ocs_conn, -EINVAL);
    ocs_assert(ocs_conn->ocs_ep, -EINVAL);
    cxn = ocs_conn->ocs_ep->cxn;
    ocs_assert(cxn, -EINVAL);
    ocs = cxn->ocs;

    bhs = (iscsi_bhs_t *)task->hdr;

    is_login = FALSE;
    set_dm = TRUE;

    switch (bhs->opcode & ISCSI_OPCODE_MASK) {
    case ISCSI_CMD_NOOP: {
        iscsi_nopout_hdr_t *nop_hdr = (iscsi_nopout_hdr_t *)task->hdr;

        /*
         * If the ttt is all f's then check the ITT to see if we are
         * requesting a response.
         */
        if (nop_hdr->ttt == 0xffffffff) {
            if (nop_hdr->itt == 0xffffffff) {
                /* no response expected */
                set_dm = TRUE;
                cb = ocs_iscsi_mtask_cb_tcp_ack_no_rsp;
            } else {
                /* response expected */
                set_dm = FALSE;
                cb = ocs_iscsi_mtask_cb_with_rsp;
            }
        } else {
            /* response to target nop */
            set_dm = TRUE;
            cb = ocs_iscsi_mtask_cb_tcp_ack_no_rsp;
        }
        break;
    }
    case ISCSI_CMD_LOGIN:
        /* Login response is handled in the unsolicited path */
        set_dm = TRUE;
        is_login = TRUE;
        cb = ocs_iscsi_mtask_cb_tcp_ack_wait_rsp;
        break;
    case ISCSI_CMD_LOGOUT:
        /* Logout response is handled in the unsolicited path */
        set_dm = TRUE;
        cb = ocs_iscsi_mtask_cb_tcp_ack_wait_rsp;
        break;
    case ISCSI_CMD_TEXT:
        /* Text response is handled in the unsolicited path */
        set_dm = TRUE;
        cb = ocs_iscsi_mtask_cb_tcp_ack_wait_rsp;;
        break;
    case ISCSI_CMD_TASK:
        /* Task management response is sent as unsolicited */
        set_dm   = TRUE;
        cb = ocs_iscsi_mtask_cb_tcp_ack_wait_rsp;
        break;
    case ISCSI_CMD_SNACK:
        set_dm   = TRUE;
        cb = ocs_iscsi_mtask_cb_tcp_ack_wait_rsp;
        break;
    default:
        printk("%s: unhandled opcode=%d\n", __func__, bhs->opcode);
        return -1;
    }

    rc = ocs_iscsi_unassisted_pdu_send(ocs, io, cxn, (void *)task->hdr,
                       (void *)task->data, task->data_count,
                       is_login, set_dm, cb);
    if (rc == 0) {
        io_task->task_state = OCS_IO_TASK_STATE_IN_CHIP;
    }
    return rc;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Clean up an iSCSI task.
 *
 * @par Description
 * Issue a completion to the upper layer and free internal resources for the IO.
 *
 * @param task The iSCSI task to transmit.
 */
static void
ocs_task_cleanup(struct iscsi_task *task)
{
    ocs_io_task_t *io_task = task->dd_data;
    struct scsi_cmnd *scsi_cmnd = task->sc;

    if (io_task->io) {
        ocs_scsi_io_free(io_task->io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        io_task->io = NULL;
    }

    if (scsi_cmnd != NULL) {
        scsi_cmnd->result = DID_NO_CONNECT;
        scsi_cmnd->scsi_done(scsi_cmnd);
    }
}


/**
 * @ingroup openiscsi_initiator
 * @brief  Transmit an iSCSI task.
 *
 * @par Description
 * Transmit an iSCSI task to the target.
 * @n @n
 * Requests LLD to transfer cmd task. Returns 0 or the the number of bytes
 * transferred on success, and -Exyz value on error. When offloading the data
 * path, this is called from queuecommand with the session lock, or from the
 * iscsi_conn_send_pdu context with the session lock. When not offloading the
 * data path, this is called from the scsi work queue without the session lock.
 *
 * @param task The iSCSI task to transmit.
 *
 * @return Returns 0 on success; or a non-zero error code value on
 *         failure.
 */
static int ocs_task_xmit(struct iscsi_task *task)
{
    ocs_io_task_t *io_task = task->dd_data;
    ocs_io_t *io = NULL;
    struct iscsi_conn *conn = task->conn;
    ocs_conn_t *ocs_conn = conn->dd_data;
    ocs_cxn_t *ocs_cxn = ocs_conn->ocs_ep->cxn;
    ocs_t *ocs = ocs_cxn->ocs;
    struct scsi_cmnd *scsi_cmnd = task->sc;
    int num_sg;
    unsigned xferlen;
    ocs_scsi_sgl_t sgl[OCS_DEFAULT_SG_SEG_CNT];
    uint32_t sgl_count;
    int rc;

    io_task->task = task;
    io = io_task->io;
    io_task->original_itt = task->hdr->itt;

    if (scsi_cmnd == NULL) {
        rc = ocs_xmit_mtask(task);
        if (rc) {
            ocs_task_cleanup(task);
        }
        return rc;
    }

    /* save mid-layer command and callback function */
    ocs_memset(&io->ini_io, 0, sizeof(io->ini_io));
    io->ini_io.scsi_cmd = scsi_cmnd;
    io->ini_io.done = scsi_cmnd->scsi_done;
    io->ini_io.io_task = io_task;

    io_task->scsi_cmnd = scsi_cmnd;

    num_sg = scsi_dma_map(scsi_cmnd);

    if (num_sg < 0) {
        printk("%s: scsi_dma_map returned %d\n", __func__, num_sg);
        ocs_task_cleanup(task);
        return num_sg;
    }

    xferlen = scsi_bufflen(scsi_cmnd);

    if (scsi_sg_count(scsi_cmnd)) {
        /* map SGL from Mid-layer to OCS SGL */
        sgl_count = sizeof(sgl)/sizeof(sgl[0]);
        ocs_scsi_map_sgl(ocs, scsi_cmnd, sgl, &sgl_count);

        switch (scsi_cmnd->sc_data_direction) {
        case DMA_FROM_DEVICE:
            /* read command */
            rc = ocs_scsi_send_rd_io(ocs_cxn, io, scsi_cmnd->device->lun,
                         scsi_cmnd->cmnd, scsi_cmnd->cmd_len, NULL,
                         sgl, sgl_count, scsi_bufflen(scsi_cmnd),
                         ocs_lnx_xport_io_cb, NULL);
            break;
        case DMA_TO_DEVICE:
            /* write command */
            rc = ocs_scsi_send_wr_io(ocs_cxn, io, scsi_cmnd->device->lun,
                         scsi_cmnd->cmnd, scsi_cmnd->cmd_len, NULL,
                         sgl, sgl_count, scsi_bufflen(scsi_cmnd),
                         ocs_lnx_xport_io_cb, NULL);
            break;
        default:
            rc = -1;
            printk("%s: default %d\n", __func__, scsi_cmnd->sc_data_direction);
        }
    } else {
        /* no data transfer */
        rc = ocs_scsi_send_nodata_io(ocs_cxn, io, scsi_cmnd->device->lun,
                         scsi_cmnd->cmnd, scsi_cmnd->cmd_len,
                         ocs_lnx_xport_io_cb, NULL);
    }

    if (rc) {
        ocs_task_cleanup(task);
    } else {
        io_task->task_state = OCS_IO_TASK_STATE_IN_CHIP;
    }
    return rc;

}

/**
 * @ingroup openiscsi_initiator
 * @brief
 *
 * @par Description
 * Requests LLD to fail task. Called with session lock and after the connection
 * has been suspended and terminated during recovery. If called from abort task,
 * then connection is not suspended or terminated but sk_callback_lock is held.
 *
 * @param task The iSCSI task to be cleaned up.
 *
 * @return None.
 */
void ocs_cleanup_task(struct iscsi_task *task) {
    ocs_io_task_t *io_task;
    ocs_io_t *io;

    io_task = task->dd_data;
    io = io_task->io;

    switch (io_task->task_state) {
    case OCS_IO_TASK_STATE_INIT:
        ocs_scsi_io_free(io);
        io_task->task_state = OCS_IO_TASK_STATE_FREE;
        io_task->io = NULL;
        break;
    case OCS_IO_TASK_STATE_IN_CHIP:
        io_task->task_state = OCS_IO_TASK_STATE_CLEANUP;
        break;
    case OCS_IO_TASK_STATE_CLEANUP:
    case OCS_IO_TASK_STATE_FREE:
        break;
    }
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Allocate a new PDU.
 *
 * @par Description
 * This function is called by libiscsi to create a new PDU for a
 * task. This function calls the SCSI API to allocate an I/O
 * object for the task. libiscsi expects us to allocate memory
 * for the PDU and point task->hdr to it.
 *
 * @param task iSCSI task to which the new PDU belongs.
 * @param opcode Opcode of the new PDU.
 *
 * @return Returns 0 on success; or a negative error code value
 *         on failure.
 */
static int ocs_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
{
    ocs_io_task_t *io_task;
    struct iscsi_conn *conn;
    ocs_conn_t *ocs_conn;
    ocs_ep_t *ocs_ep;
    ocs_io_t *io;
    ocs_cxn_t *cxn;
    ocs_iscsi_t *ocs_iscsi;
    ocs_t *ocs;

    ocs_assert(task, -EINVAL);

    io_task = task->dd_data;
    ocs_assert(io_task, -EINVAL);

    conn = task->conn;
    ocs_assert(conn, -EINVAL);

    ocs_conn = conn->dd_data;
    ocs_assert(ocs_conn, -EINVAL);

    ocs_ep = ocs_conn->ocs_ep;
    ocs_assert(ocs_ep, -EINVAL);

    cxn = ocs_ep->cxn;
    ocs_assert(cxn, -EINVAL);

    ocs_iscsi = cxn->iscsi;
    ocs_assert(ocs_iscsi, -EINVAL);

    ocs = cxn->ocs;
    ocs_assert(ocs, -EINVAL);

    /* 
     * Return error if WQ is full.
     * Lets upper layer to requeue request.
     */
    if (ocs_scsi_check_cxn_wq_full(ocs, cxn))
        return -ENOMEM;

    io = ocs_scsi_io_alloc(cxn, OCS_SCSI_IO_ROLE_ORIGINATOR);
    if (!io) {
        printk("%s: No io is available", __func__);
        // TODO:  Queue the request?
        return -ENOMEM;
    }

    io_task->io = io;
    io_task->task_state = OCS_IO_TASK_STATE_INIT;
    io->ini_io.io_task = io_task;

    /*
     * Save libiscsi's itt.  We change it because SLI-4 has specific
     * requirements about the format of the ITT and will be changing
     * it.  Later, when we get
     * the completion from SLI-4, we'll change it back before we hand
     * the PDU back to libiscsi for processing.
     */

    /* setup header so Linux iSCSI transport populate */
    task->hdr = (struct iscsi_hdr *)io->bhs;
    task->hdr_len = 0;
    task->hdr_max = OCS_BHS_ALLOC_SIZE;

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  Return sysfs visibility for a parameter.
 * @par Description
 *
 *
 * @param param_type Type of parameter to query.
 * @param param Parameter to query.
 *
 * @return Returns a non-zero mode_t if a parameter is visible
 *         through sysfs; or 0 if the parameter is not visible.
 */
#if defined(SCSI_ISCSI_XPORT_ATTR_IS_VISIBLE_V0)
mode_t ocs_attr_is_visible(int param_type, int param)
#endif
#if defined(SCSI_ISCSI_XPORT_ATTR_IS_VISIBLE_V1)
umode_t ocs_attr_is_visible(int param_type, int param)
#endif
{
    switch (param_type) {
    case ISCSI_NET_PARAM:
        switch (param) {
        case ISCSI_NET_PARAM_IFACE_ENABLE:
        case ISCSI_NET_PARAM_IPV4_ADDR:
        case ISCSI_NET_PARAM_IPV4_SUBNET:
        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
        case ISCSI_NET_PARAM_IPV4_GW:
        case ISCSI_NET_PARAM_IPV6_ADDR:
        case ISCSI_NET_PARAM_VLAN_ID:
        case ISCSI_NET_PARAM_VLAN_PRIORITY:
        case ISCSI_NET_PARAM_VLAN_ENABLED:
            return S_IRUGO;
        default:
            return 0;
        }
    case ISCSI_HOST_PARAM:
        switch (param) {
        case ISCSI_HOST_PARAM_HWADDRESS:
        case ISCSI_HOST_PARAM_INITIATOR_NAME:
            /* TODO : Enable when PORT_SPEED and PORT_STATE
               support added in OEM kernel
             */
#if 0
        case ISCSI_HOST_PARAM_PORT_STATE:
        case ISCSI_HOST_PARAM_PORT_SPEED:
#endif
            return S_IRUGO;
        default:
            return 0;
        }
    case ISCSI_PARAM:
        switch (param) {
        case ISCSI_PARAM_MAX_RECV_DLENGTH:
        case ISCSI_PARAM_MAX_XMIT_DLENGTH:
        case ISCSI_PARAM_HDRDGST_EN:
        case ISCSI_PARAM_DATADGST_EN:
        case ISCSI_PARAM_CONN_ADDRESS:
        case ISCSI_PARAM_CONN_PORT:
        case ISCSI_PARAM_EXP_STATSN:
        case ISCSI_PARAM_PERSISTENT_ADDRESS:
        case ISCSI_PARAM_PERSISTENT_PORT:
        case ISCSI_PARAM_PING_TMO:
        case ISCSI_PARAM_RECV_TMO:
        case ISCSI_PARAM_INITIAL_R2T_EN:
        case ISCSI_PARAM_MAX_R2T:
        case ISCSI_PARAM_IMM_DATA_EN:
        case ISCSI_PARAM_FIRST_BURST:
        case ISCSI_PARAM_MAX_BURST:
        case ISCSI_PARAM_PDU_INORDER_EN:
        case ISCSI_PARAM_DATASEQ_INORDER_EN:
        case ISCSI_PARAM_ERL:
        case ISCSI_PARAM_TARGET_NAME:
        case ISCSI_PARAM_TPGT:
        case ISCSI_PARAM_USERNAME:
        case ISCSI_PARAM_PASSWORD:
        case ISCSI_PARAM_USERNAME_IN:
        case ISCSI_PARAM_PASSWORD_IN:
        case ISCSI_PARAM_FAST_ABORT:
        case ISCSI_PARAM_ABORT_TMO:
        case ISCSI_PARAM_LU_RESET_TMO:
        case ISCSI_PARAM_IFACE_NAME:
        case ISCSI_PARAM_INITIATOR_NAME:
            return S_IRUGO;
        default:
            return 0;
        }
    }

    return 0;
}

/**
 * @ingroup openiscsi_initiator
 * @brief  iSCSI transport entry points.
 *
 * @par Description
 * This structure defines the hooks that libiscsi uses to
 * call various functions in this driver.
 *
 */
struct iscsi_transport ocs_lnx_xport_iscsi = {
    .owner = THIS_MODULE,
    .name = "ocs",
    .caps = (CAP_RECOVERY_L0 |
         CAP_HDRDGST |
         CAP_DATADGST |
         CAP_TEXT_NEGO |
         CAP_MULTI_CONN |
         CAP_DIGEST_OFFLOAD |
         CAP_DATA_PATH_OFFLOAD),
    .create_session = ocs_session_create,
    .destroy_session = ocs_session_destroy,
    .create_conn = ocs_conn_create,
    .bind_conn = ocs_conn_bind,
    .destroy_conn = iscsi_conn_teardown,
    .attr_is_visible = ocs_attr_is_visible,
    .set_iface_param = ocs_iface_set_param,
    .get_iface_param = ocs_iface_get_param,
    .set_param = ocs_set_param,
    .set_host_param = ocs_set_host_param,
    .get_conn_param = ocs_conn_get_param,
    .get_session_param = ocs_session_get_param,
    .get_host_param = ocs_get_host_param,
    .start_conn = ocs_conn_start,
    .stop_conn = iscsi_conn_stop,
    .send_pdu = iscsi_conn_send_pdu,
    .xmit_task = ocs_task_xmit,
    .cleanup_task = ocs_cleanup_task,
    .alloc_pdu = ocs_alloc_pdu,
    .get_stats = ocs_conn_get_stats,
    .get_ep_param = ocs_ep_get_param,
    .ep_connect = ocs_ep_connect,
    .ep_poll = ocs_ep_poll,
    .ep_disconnect = ocs_ep_disconnect,
    .session_recovery_timedout = iscsi_session_recovery_timedout,
};

/**
 * @page openiscsi_init_overview Initiator API and Open iSCSI Interface Module
 * - @ref openiscsi_initiator
 *
 * <div class="overview">
 *
 * <h2>Overview</h2>
 * <img src="elx_iscsi_init.jpg" alt="iSCSI Initiator Interface" title="iSCSI Initiator Interface" align="right"/>
 *
 * The Emulex Open-iSCSI interface (ocs_openiscsi) module is a separate loadable module
 * included in the OneCore Storage SDK package to be used for initiator support with the
 * Linux ocs_iscsi_driver
 * (see the <a href="../../../ocs_openiscsi/" target="_blank">driver/linux/ocs_openiscsi
 * directory</a>).<br><br>
 *
 * The ocs_openiscsi module acts as an interface adapter between the driver’s Initiator
 * API and the Open-iSCSI kernel module (iSCSI transport and libiscsi.ko).
 * The ocs_openiscsi module registers with Linux ocs_iscsi_ramd driver as an initiator, then
 * registers with Open-iSCSI as a transport. Emulex SLI-4 adapters are then presented to
 * the SCSI Mid-layer as available SCSI host devices.<br><br>
 *
 * The ocs_openiscsi module depends on symbols exported from the Open-iSCSI’s
 * libiscsi.ko module (libiscsi) and the Linux ocs_iscsi_ramd driver. As such, the libiscsi
 * and Linux ocs_iscsi_ramd driver must be loaded before the ocs_openiscsi module is
 * loaded.<br><br>
 *
 * Once the ocs_openiscsi module is loaded, it calls into the libiscsi to register
 * itself as an interface and calls into the Linux ocs_iscsi_ramd driver to register
 * itself as an initiator.<br><br>
 *
 * <h2>Initiator Task Tag (ITT) Handling</h2>
 * Open-iSCSI presents its iSCSI transport with complete PDUs to be executed. The ITT is
 * set by the libiscsi and is used on a task completion to associate the response PDU with
 * the correct task.<br><br>
 *
 * SLI-4 has its own rules about the contents of the ITT in a PDU. The ITT for SLI-4 must
 * contain the WRB index and the SGL_ICD index for the command being submitted. To
 * accommodate these requirements, the ocs_openiscsi module must store the ITT when a
 * task is submitted, and then restore the ITT before it reports a completion back to the
 * libiscsi.ko. The ITT is saved by the ocs_alloc_pdu() function, and then restored by the
 * various callback functions.
 *
 * <h2>ocs_openiscsi Module Load</h2>
 * When the ocs_openiscsi module is loaded, it calls iscsi_register_transport. This
 * provides the libiscsi with pointers (such as start_conn, ep_connect, and
 * get_stats) to the ocs_openiscsi module functions (such as ocs_conn_start(),
 * ocs_ep_connect(), and ocs_conn_get_stats()) that are needed to act as a transport. The libiscsi
 * can then use those ocs_openiscsi module functions to manage Open-iSCSI connections
 * and I/Os.<br><br>
 *
 * After registering with the libiscsi, the ocs_openiscsi module calls ocs_get_instance() in
 * the Linux ocs_iscsi_ramd driver to get information about each device that the driver
 * has available. For each of these devices, the ocs_openiscsi module calls
 * ocs_scsi_register_ini_templ() in the driver. This function call provides pointers to
 * functions that the driver can use to add/delete domains, sports, and targets, and to
 * send notifications to the ocs_openiscsi module.<br><br>
 *
 * Finally, the ocs_openiscsi module completes the registration with the libiscsi by calling
 * iscsi_host_add and iscsi_create_iface.
 *
 * <h2>ocs_openiscsi Module Load</h2>
 * The connect process of Open-iSCSI to the Linux ocs_iscsi_ramd driver has four steps:
 *
 * <ol><li>Create an endpoint.</li>
 * <li>Create a session.</li>
 * <li>Create a connection structure.</li>
 * <li>Bind the three (endpoint, session, and connection structure) together.</li></ol>
 *
 * <br>For the first step, the Open-iSCSI iSCSI transport calls ocs_ep_connect(). The
 * ocs_ep_connect() function calls into the libiscsi to create the endpoint structure, then
 * calls ocs_xport_control() into the Linux ocs_iscsi_ramd driver to establish the
 * connection.<br><br>
 *
 * The remaining three steps do not require any interaction with the Linux ocs_iscsi_ramd
 * driver. The iSCSI transport calls into the ocs_openiscsi module, which calls into libiscsi
 * to create the required structures and bind them.
 *
 * <h2>Management PDU Processing</h2>
 * Open-iSCSI has an interface to send management (non-I/O) PDUs, such as LOGIN and NO-OP.<br><br>
 *
 * The iSCSI transport calls iscsi_conn_send_pdu, which then calls ocs_alloc_pdu() to
 * allocate memory for the transaction. It fills in the PDU structure and calls
 * ocs_task_xmit(). Within the task structure, the scsi_cmnd pointer is NULL (the
 * distinguishing factor between a management task and an I/O task). The ocs_task_xmit()
 * keys off the NULL scsi_cmnd pointer and calls ocs_xmit_mtask() to send the management
 * task. The ocs_xmit_mtask() function sets up the correct callback function based on the
 * type of PDU, and then calls into ocs_iscsi_unassisted_pdu_send() in the ocs_iscsi_ramd
 * driver’s iSCSI API to send the PDU.<br><br>
 *
 * Depending on the value of the set_dm argument, the callback is called either when the
 * PDU is sent or when the response to the PDU is received. The callback function
 * performs any required processing on the response; calls iscsi_complete_pdu to notify
 * libiscsi that the task is done; and finally calls ocs_scsi_io_free() to free the I/O
 * resources.
 *
 * <h2>IO PDU Processing</h2>
 * I/O PDU processing is similar to management PDU processing. The I/O begins in the
 * SCSI mid-layer with a call to scsi_dispatch_cmd, which then gets forwarded to
 * iscsi_queue_command in libiscsi. A PDU is allocated by calling ocs_alloc_pdu(). The
 * libiscsi fills in the PDU details, including the SCSI CDB and data; and then calls
 * ocs_task_xmit() to send the task.<br><br>
 *
 * The ocs_openiscsi module identifies the task as a SCSI command task due to the
 * non-NULL scsi_cmd pointer. Based on the sc_data_direction field in the scsi_cmd, the
 * ocs_openiscsi module calls ocs_scsi_send_rd_io() or ocs_scsi_send_wr_io(). The
 * command callback is set to ocs_lnx_xport_io_cb().<br><br>
 *
 * When the command completes and ocs_lnx_xport_io_cb() is called, the ocs_openiscsi
 * module calls iscsi_complete_scsi_task to inform the libiscsi that the task is complete.
 * Next, the ocs_openiscsi module calls ocs_scsi_cmd_cb(), which then calls the scsi_done
 * function from the I/O.<br><br>
 *
 * Finally, the ocs_openiscsi module calls ocs_scsi_io_free to release the I/O resources.
 *
 * <br>
 * </div><!-- overview -->
 *
 */