ocs_ramd.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
 * Implement the SCSI RAMD target-server.
 */

/**
 * @defgroup io_sm RAMD Target IO State Machine
 * @defgroup scsi_cmd SCSI Command Processing
 * @defgroup scsi_api_target SCSI Target
 */

#include "ocs.h"
#include "ocs_ramd.h"
#include "ocs_ramdisc.h"
#include "scsi_cmds.h"
#include "ocs_mgmt.h"

/**
 * @brief A structure that contains the status and extended status fields.
 */
typedef struct {
    uint32_t status;
    uint32_t ext_status;
} ocs_ramd_status_t;

/* globals */
static ocs_lock_t ramd_lock;
static ocs_ramdisc_t **ocs_ramd = NULL;
static uint32_t ocs_ramd_count = 0;
static int ramd_ref_cnt = 0;

typedef struct {
    ocs_list_link_t link;
    uint32_t tgt_id;
    ocs_ramdisc_t **rdisc;
    uint32_t rdisc_count;
} ocs_port_rdisc_t;


#define INVALID_APP_TAG     0xffffffff
#define RAMD_APP_TAG        0x0

#define IOFMT "[%04x][i:%0*x t:%0*x h:%04x][c:%02x]"
#define IOFMT_ITT_SIZE(ocs) ((ocs->ocs_xport == OCS_XPORT_FC) ? 4 : 8)
#define IOFMT_ARGS(io) io->instance_index, IOFMT_ITT_SIZE(io->ocs), io->init_task_tag, IOFMT_ITT_SIZE(io->ocs), io->tgt_task_tag, io->hw_tag, io->tgt_io.cdb[0]

#define io_sm_trace()  \
    do { \
        if (OCS_LOG_ENABLE_SCSI_TGT_TRACE(io->node->ocs)) \
            ocs_log_info(io->ocs, "[%s]" IOFMT " (IO) %-20s %-20s\n", \
                (io->node ? io->node->display_name : ""), \
                IOFMT_ARGS(io), __func__, ocs_sm_event_name(evt)); \
    } while (0)

#define tmfio_sm_trace()  \
    do { \
        if (OCS_LOG_ENABLE_SCSI_TGT_TRACE(tmfio->ocs)) \
            ocs_log_info(tmfio->ocs, "[%s]" IOFMT " (TMF) %-20s %-20s\n", \
                (tmfio->node ? tmfio->node->display_name : ""), \
                IOFMT_ARGS(tmfio), __func__, ocs_sm_event_name(evt)); \
    } while (0)

#define io_printf(io, fmt, ...)  \
    do { \
        ocs_log_debug(io->ocs, "[%s]" IOFMT " %-20s " fmt, \
            (io->node ? io->node->display_name : ""),   \
            IOFMT_ARGS(io), __func__, ##__VA_ARGS__);   \
    } while (0)

#define OCS_RAMD_MIN_SIZE       (1024*1024)

#define ENABLE_CMD_TRACE    0
#define ENABLE_API_TRACE    0
#define ENABLE_BUFFER_DUMP  0

#define trace(io, enable_flag, fmt, ...) \
    do { \
        if (enable_flag) { \
            if (io) { \
                ocs_log_debug(NULL, "[%s]" IOFMT " %s: " fmt, io->node->display_name,  \
                    IOFMT_ARGS(io), __func__, ##__VA_ARGS__); \
            } else { \
                ocs_log_debug(NULL, "%s: " fmt, __func__, ##__VA_ARGS__); \
            } \
        } \
    } while(0)

#define cmd_trace(io, fmt, ...) trace(io, ENABLE_CMD_TRACE, fmt, ##__VA_ARGS__)

#define api_trace(...)  \
    do { \
        if (ENABLE_API_TRACE) \
            ocs_log_debug(NULL, "%s:\n", __func__);  \
    } while(0)

#ifndef container_of
#define container_of(p, stype, field) ((stype *)(((uint8_t *)(p)) - offsetof(stype, field)))
#endif

#if defined(OCS_INCLUDE_ISCSI)
#define ACTIVE_IO_COUNT(ocs)    ocs_atomic_read(&ocs->io_active_count) 
#else /* For FC*/
#define ACTIVE_IO_COUNT(ocs)    ocs_atomic_read(&ocs->xport->io_active_count) 
#endif

typedef enum {
    __OCS_RAMD_IO_INIT = 0,
    __OCS_RAMD_IO_INIT_ERR_INJECTION,
    __OCS_RAMD_IO_WAIT_FIRST_BURST,
    __OCS_RAMD_IO_WAIT_DATAPHASE_COMPL,
    __OCS_RAMD_IO_WAIT_AND_VALIDATE_DATAPHASE,
    __OCS_RAMD_IO_WAIT_AND_COMPLETE_WRITESAME_DATAPHASE,
    __OCS_RAMD_IO_WAIT_RESP_COMPL,
    __OCS_RAMD_IO_ABORTING,
    __OCS_RAMD_IO_ABORTING_WAIT_IO_CMPL,
    __OCS_RAMD_IO_ABORTING_WAIT_ABORT_CMPL,
    __OCS_RAMD_TMF_WAIT_RESP_CMPL,
    __OCS_RAMD_ABTS_WAIT_IO_ABORT_RESP,
    __OCS_RAMD_WAIT_ABTS_ACC_CMPL,
    __OCS_RAMD_IO_WAIT_FIRST_BURST_SEND_RESP
} ocs_ramd_state_t;

static const char *ocs_ramd_state_names[] = {
    "__ocs_ramd_io_init",
    "__ocs_ramd_io_init_err_injection",
    "__ocs_ramd_io_wait_first_burst",
    "__ocs_ramd_io_wait_dataphase_compl",
    "__ocs_ramd_io_wait_and_validate_dataphase",
    "__ocs_ramd_io_wait_and_complete_writesame_dataphase",
    "__ocs_ramd_io_wait_resp_compl",
    "__ocs_ramd_io_aborting",
    "__ocs_ramd_io_aborting_wait_io_cmpl",
    "__ocs_ramd_io_aborting_wait_abort_cmpl",
    "__ocs_ramd_tmf_wait_resp_cmpl",
    "__ocs_ramd_abts_wait_io_abort_resp",
    "__ocs_ramd_wait_abts_acc_cmpl",
    "__ocs_ramd_io_wait_first_burst_send_resp"
};

static void * __ocs_ramd_io_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_init_err_injection(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_first_burst(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_dataphase_compl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_and_validate_dataphase(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_and_complete_writesame_dataphase(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_resp_compl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_aborting(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_aborting_wait_io_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_aborting_wait_abort_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void *__ocs_ramd_tmf_wait_resp_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void *__ocs_ramd_abts_wait_io_abort_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void *__ocs_ramd_wait_abts_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static void * __ocs_ramd_io_wait_first_burst_send_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
static int32_t ocs_ramd_data_phase_start(ocs_io_t *io);

/* SCSI command handlers */
static ocs_ramd_hndlr_rtn_e ocs_ramd_write6(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write12(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write32(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_long10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_long16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_same10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_same16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_same32(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read6(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read12(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read32(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read_long10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read_long16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_inquiry(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_test_unit_ready(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_reserve_release(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read_capacity10(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read_capacity16(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_report_luns(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_format_unit(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_mode_select(ocs_io_t *io, uint8_t cdb[]);
static ocs_ramd_hndlr_rtn_e ocs_ramd_request_sense(ocs_io_t *io, uint8_t cdb[]);

static int32_t ocs_ramd_abort_node_tasks(ocs_node_t *nodes, ocs_io_t *io);
static int32_t ocs_ramd_abort_node_tasks_lun(ocs_node_t *node, uint32_t lun, ocs_io_t *io);

static uint32_t scsi_validate_format_unit(ocs_io_t *io);
static int32_t scsi_format_unit_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg);
static uint32_t scsi_validate_mode_select(ocs_io_t *io);
static int32_t scsi_mode_select_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg);
static ocs_ramd_hndlr_rtn_e ocs_ramd_complete_write_same(ocs_io_t *io);
static void ocs_scsi_ramd_free(ocs_t *ocs, ocs_ramdisc_t ***rdisc, uint32_t *rdisc_count);

static ocs_ramd_hndlr_rtn_e ocs_ramd_read_common(ocs_io_t *io, uint64_t lba, uint32_t block_count, uint8_t rdprotect,
                         uint32_t app_tag, uint32_t ref_tag);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_common(ocs_io_t *io, uint64_t lba, uint32_t block_count, uint8_t wrprotect,
                          uint32_t app_tag, uint32_t ref_tag);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_same_common(ocs_io_t *io, uint64_t lba, uint32_t block_count,
                               uint8_t wrprotect, uint8_t pbdata, uint8_t lbdata,
                               uint32_t app_tag, uint32_t ref_tag);
static ocs_ramd_hndlr_rtn_e ocs_ramd_write_long_common(ocs_io_t *io, uint64_t lba, uint16_t xfer_len,
                               uint8_t cor_dis, uint8_t wr_uncor, uint8_t pblock);
static ocs_ramd_hndlr_rtn_e ocs_ramd_read_long_common(ocs_io_t *io, uint64_t lba, uint16_t xfer_len,
                              uint8_t pblock, uint8_t corrct);
static int32_t ocs_ramd_io_error(ocs_io_t *io, ocs_scsi_io_status_e scsi_status);
static int32_t ocs_ramd_abort_tgt_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg);
static int32_t ocs_mgmt_read_block(ocs_t *ocs, char *, void *, uint32_t, void *, uint32_t);

/**
 * @brief A structure used to map a handler function to a SCSI sommand.
 */
typedef struct {
    uint8_t check_lun;
    uint8_t data_dir;
    uint32_t scsi_cmd;
    ocs_ramd_hndlr_rtn_e (*handler)(ocs_io_t *io, uint8_t cdb[]);
} scsi_cmd_table_t;

#define DATA_DIR_NONE   0x00
#define DATA_DIR_READ   0x01
#define DATA_DIR_WRITE  0x02
#define DATA_DIR_RDWR   0x03
static scsi_cmd_table_t *scsi_cmd_lookup[256];

static scsi_cmd_table_t scsi_cmd_table[] = {
    {1, DATA_DIR_WRITE, SCSI_WRITE6,        ocs_ramd_write6},
    {1, DATA_DIR_WRITE, SCSI_WRITE10,       ocs_ramd_write10},
    {1, DATA_DIR_WRITE, SCSI_WRITE12,       ocs_ramd_write12},
    {1, DATA_DIR_WRITE, SCSI_WRITE16,       ocs_ramd_write16},
    {1, DATA_DIR_WRITE, SCSI_WRITE_LONG10,      ocs_ramd_write_long10},
    /* WRITE 32 is a Variable Length CDB */
    {1, DATA_DIR_WRITE, SCSI_WRITE_AND_VERIFY10,    ocs_ramd_write10},
    {1, DATA_DIR_WRITE, SCSI_WRITE_AND_VERIFY12,    ocs_ramd_write12},
    {1, DATA_DIR_WRITE, SCSI_WRITE_AND_VERIFY16,    ocs_ramd_write16},
    {1, DATA_DIR_WRITE, SCSI_WRITE_SAME10,      ocs_ramd_write_same10},
    {1, DATA_DIR_WRITE, SCSI_WRITE_SAME16,      ocs_ramd_write_same16},
    {1, DATA_DIR_READ, SCSI_READ6,          ocs_ramd_read6},
    {1, DATA_DIR_READ, SCSI_READ10,     ocs_ramd_read10},
    {1, DATA_DIR_READ, SCSI_READ12,     ocs_ramd_read12},
    {1, DATA_DIR_READ, SCSI_READ16,     ocs_ramd_read16},
    {1, DATA_DIR_READ, SCSI_READ_LONG10,        ocs_ramd_read_long10},
    /* READ 32 is a Variable Length CDB */
    {1, DATA_DIR_READ, SCSI_READ_CAPACITY10,    ocs_ramd_read_capacity10},
    /* READ CAPACITY 16 is a SERVICE ACTION */
    {0, DATA_DIR_READ, SCSI_INQUIRY,        ocs_ramd_inquiry},
    {1, DATA_DIR_NONE, SCSI_TEST_UNIT_READY,    ocs_ramd_test_unit_ready},
    {1, DATA_DIR_NONE, SCSI_RESERVE6,       ocs_ramd_reserve_release},
    {1, DATA_DIR_NONE, SCSI_RELEASE6,       ocs_ramd_reserve_release},
    {1, DATA_DIR_READ, SCSI_REPORT_LUNS,        ocs_ramd_report_luns},
    {1, DATA_DIR_READ, SCSI_MODE_SENSE6,        ocs_ramd_mode_sense6},
    {1, DATA_DIR_READ, SCSI_MODE_SENSE10,       ocs_ramd_mode_sense10},
    {1, DATA_DIR_WRITE, SCSI_FORMAT_UNIT,       ocs_ramd_format_unit},
    {1, DATA_DIR_WRITE, SCSI_MODE_SELECT6,      ocs_ramd_mode_select},
    {1, DATA_DIR_WRITE, SCSI_MODE_SELECT10,     ocs_ramd_mode_select},
    /* VERIFY and WRITE_AND_VERIFY commands intentionally omitted */
    {1, DATA_DIR_READ, SCSI_REQUEST_SENSE,      ocs_ramd_request_sense},
};

static scsi_cmd_table_t scsi_cmd_table_svc_in_action16[] = {
    {1, DATA_DIR_READ, SCSI_SVC_ACTION16_READ_CAPACITY, ocs_ramd_read_capacity16},
    {1, DATA_DIR_READ, SCSI_SVC_ACTION16_READ_LONG, ocs_ramd_read_long16},
    };

static scsi_cmd_table_t scsi_cmd_table_svc_out_action16[] = {
    {1, DATA_DIR_WRITE, SCSI_SVC_ACTION16_WRITE_LONG, ocs_ramd_write_long16},
    };

static scsi_cmd_table_t scsi_cmd_table_variable_len_cdb[] = {
    {1, DATA_DIR_READ, SCSI_VAR_CMD_SVC_ACT_READ32, ocs_ramd_read32},
    {1, DATA_DIR_WRITE, SCSI_VAR_CMD_SVC_ACT_WRITE32,   ocs_ramd_write32},
    {1, DATA_DIR_WRITE, SCSI_VAR_CMD_SVC_ACT_WRITE_VERIFY32, ocs_ramd_write32},
    {1, DATA_DIR_WRITE, SCSI_VAR_CMD_SVC_ACT_WRITE_SAME32, ocs_ramd_write_same32},
};

/* Management API */
void ocs_mgmt_ramd_list(ocs_textbuf_t *textbuf, void *object);
void ocs_mgmt_ramd_get_all(ocs_textbuf_t *textbuf, void *object);
int ocs_mgmt_ramd_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object);
int ocs_mgmt_ramd_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
        void *arg_out, uint32_t arg_out_length, void *object);
ocs_mgmt_functions_t ramd_mgmt_functions = {
    .get_list_handler = ocs_mgmt_ramd_list,
    .get_handler = ocs_mgmt_ramd_get,
    .get_all_handler = ocs_mgmt_ramd_get_all,
    .exec_handler = ocs_mgmt_ramd_exec,
};

/**
 * @brief Ignore abort event.
 *
 * @param evt Abort event to be ignored.
 * @param func The calling function name.
 * @param io Pointer to the IO context that received the abort
 *           event.
 * @param tmfio Pointer to the TMF IO context (if ABTS).
 *
 * @return None.
 */
static void
ocs_ignore_abort_evt(ocs_sm_event_t evt, const char *func,
                 ocs_io_t *io, ocs_io_t *tmfio)
{
    io_printf(io, "%s: ignore evt: %-20s\n", func, ocs_sm_event_name(evt));

    if (tmfio) {
        /* Acknowledge the abort event */
        ocs_sm_post_event(&tmfio->tgt_io.sm, OCS_EVT_IO_ABORT_IGNORED, NULL);
    }
}

/**
 * @ingroup scsi_api_target
 * @brief Driver-wide initialization for the target-server.
 *
 * @par Description
 * Called by the OS initialization prior to the PCI device discovery.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_driver_init(void)
{
    uint32_t i;
    scsi_cmd_table_t *pcmd;
    uint32_t ramd_threading = 0;
    uint32_t thread_cmds = 0;
    char buf[32];

    ocs_lock_init(NULL, &ramd_lock, "RAM disc alloc lock");

    /* Build scsi cmd lookup */
    ocs_memset(scsi_cmd_lookup, 0, sizeof(scsi_cmd_lookup));
    for (i = 0, pcmd = scsi_cmd_table; i < ARRAY_SIZE(scsi_cmd_table); i++, pcmd++) {
        scsi_cmd_lookup[pcmd->scsi_cmd] = pcmd;
    }

    if (ocs_get_property("ramd_threading", buf, sizeof(buf)) == 0) {
        ramd_threading = ocs_strtoul(buf, 0, 0);
        ocs_log_debug(NULL, "ramd_threading: %d\n", ramd_threading);
    }

    if (ocs_get_property("thread_cmds", buf, sizeof(buf)) == 0) {
        thread_cmds = ocs_strtoul(buf, 0, 0);
        ocs_log_debug(NULL, "thread_cmds: %d\n", thread_cmds);
    }

    if (thread_cmds && !ramd_threading) {
        ocs_log_test(NULL, "Can't thread_cmds without enabling ramd_threading\n");
        return -1;
    }

    /* Start a bunch of server threads */
    ocs_ramd_start_threads(ramd_threading, thread_cmds);

    return 0;
}

/**
 * @ingroup scsi_api_target
 * @brief Driver-wide clean-up for the target-server.
 *
 * @par Description
 * Called by the OS driver-wide exit/clean-up.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_driver_exit(void)
{
    ocs_ramd_stop_threads();
    return 0;
}

/**
 * @brief Set SCST IO state
 *
 * @param io pointer to SCSI IO object
 * @param state to be set
 *
 * @return TGT iostate
 */
uint32_t ocs_scsi_tgt_io_state(ocs_io_t *io)
{
    return 0;
}

/**
 * @brief Initialize SCSI IO.
 *
 * @par Description
 * Initialize SCSI IO, this function is called once per IO during IO pool
 * allocation so that the target server may initialize any of its own private
 * data.
 *
 * @param io Pointer to SCSI IO object.
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
int32_t
ocs_scsi_tgt_io_init(ocs_io_t *io)
{
    ocs_lock_init(io->ocs, &io->tgt_io.sm_lock, "iosmlock:%p", io);
    return 0;
}

/**
 * @brief Un-initialize SCSI IO.
 *
 * @par Description
 * Un-initialize target server private data in a SCSI io object.
 *
 * @param io Pointer to SCSI IO object.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_io_exit(ocs_io_t *io)
{
    ocs_lock_free(&io->tgt_io.sm_lock);
    return 0;
}

/**
 * @brief Given an IO and a LUN number, return the ramdisc to which the IO is directed.
 *
 * @par Description
 * From the IO, get the ocs, then the target private area for the ocs.
 * Check if a global RAMD (one RAMD for all SLI Ports) is used. If
 * so, then find the RAMD in the target private area. If not, then go from
 * IO to node to SLI Port to find the SLI Port's list of ramdiscs.
 *
 * @param io Pointer to the IO context.
 * @param lun LUN for the command.
 *
 * @return Returns a pointer to the ramdisc, or NULL if @c lun is not valid.
 */
ocs_ramdisc_t *
ocs_ramd_lookup(ocs_io_t *io, uint32_t lun)
{
    ocs_t *ocs = io->ocs;
    ocs_ramdisc_t *rval = NULL;

    if (ocs->tgt_ocs.use_global_ramd) {
        if (lun < ocs->tgt_ocs.rdisc_count) {
            rval = ocs->tgt_ocs.rdisc[lun];
        }
    } else {
        ocs_node_t *node = io->node;

        if (node != NULL) {
            ocs_sport_t *sport = node->sport;
            if (sport != NULL) {

                if (lun < sport->tgt_sport.rdisc_count) {
                    rval = sport->tgt_sport.rdisc[lun];
                }
            }
        }
    }
    return rval;
}

/**
 * @brief Given an TGT number and a LUN number, return the corresponding ramdisc
 *
 *@par Description
 * This function is used by the mgmt interface to access ramdisc data out-of-band
 * rather than through a SCSI IO.  The TGT number is assumed to correspond to
 * a sport on the first domain.  TGT 0 is domain[1]/sport[1], TGT 1 is
 * domain[1]/sport[2], etc.
 * @n @n
 * If the global RAMD is being used then the TGT number must be 0.
 * In this case the ramdisc for LUN n is at ocs->tgt_ocs.rdisc[n].
 *
 * If per-port RAMD is being used then the TGT number is used to
 * find the correct sport, then LUN n is at sport->tgt_sport.rdisc[n].
 *
 * @param ocs Pointer to the ocs.
 * @param tgt TGT number, 0..n.
 * @param lun LUN number, 0..n.
 *
 * @return Returns a pointer to a ramdisc structure on success, or
 *         NULL on failure.
 */
ocs_ramdisc_t *
ocs_ramd_lookup_by_tgt(ocs_t *ocs, uint32_t tgt, uint32_t lun)
{
    ocs_ramdisc_t *rval = NULL;

    if (ocs->tgt_ocs.use_global_ramd) {
        if (tgt == 0) {
            if (lun < ocs->tgt_ocs.rdisc_count) {
                rval = ocs->tgt_ocs.rdisc[lun];
            }
        }
    } else {
        ocs_domain_t *domain = ocs_domain_get_instance(ocs, 1);
        if (domain != NULL) {
            ocs_sport_t *sport = ocs_sport_get_instance(domain, tgt+1);
            if (sport != NULL) {
                if (lun < sport->tgt_sport.rdisc_count) {
                    rval = sport->tgt_sport.rdisc[lun];
                }
            }
        }
    }
    return rval;
}

/**
 * @brief Create a RAMD (target) based on the property parameter values.
 *
 * @param ocs Pointer to the ocs.
 * @param rdisc Pointer to the ramdisc to allocate.
 * @param rdisc_count Pointer to the number of ramdiscs (LUNs) allocated.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_scsi_ramd_create(ocs_t *ocs, ocs_ramdisc_t ***rdisc, uint32_t *rdisc_count)
{
    char prop_buf[32];
    uint32_t num_luns = 1;
    uint32_t ramdisc_blocksize = 512;
    uint64_t ramdisc_size = 50*1024*1024;
    uint64_t ramdisc_blockcount = 0;
    uint32_t max_sge_size;
    uint32_t i;
    int32_t rc = 0;
    uint8_t p_type = 0;
    uint8_t prot_en = 0;
    uint8_t dif_separate = 0;
    uint8_t external_dif = 0;
    char t10_vendor_id[8] = { 0 };
    uint32_t dif_capable;

    // Obtain device's DIF capability
    dif_capable = ocs_scsi_get_property(ocs, OCS_SCSI_DIF_CAPABLE);

    if (ocs_get_property("ramdisc_size", prop_buf, sizeof(prop_buf)) == 0) {
        char *p;
        ramdisc_size = ocs_strtoul(prop_buf, &p, 0);
        switch(*p) {
        case 'g': case 'G':
            ramdisc_size *= 1024;
            /* fallthrough */
        case 'm': case 'M':
            ramdisc_size *= 1024;
            /* fallthrough */
        case 'k': case 'K':
            ramdisc_size *= 1024;
            break;
        }
        if (ramdisc_size < OCS_RAMD_MIN_SIZE) {
            ocs_log_warn(ocs, "Ramdisc size %s (%" PRIu64 ") too small. Min size %u.\n",
                    prop_buf, ramdisc_size, OCS_RAMD_MIN_SIZE);
            return -1;
        }
    }
    if (ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf)) == 0) {
        ramdisc_blocksize = ocs_strtoul(prop_buf, 0, 0);
    }
    if (ocs_get_property("num_luns", prop_buf, sizeof(prop_buf)) == 0) {
        num_luns = ocs_strtoul(prop_buf, 0, 0);
    }
    if (ocs_get_property("p_type", prop_buf, sizeof(prop_buf)) == 0) {
        p_type = ocs_strtoul(prop_buf, 0, 0);
        if (p_type != 0) {
            // Enable only if the device is capable of DIF
            if (dif_capable) {
                prot_en = 1;
            } else {
                ocs_log_warn(ocs, "WARNING: RAMD: Cannot initialize with DIF, port is not DIF capable\n");
                prot_en = 0;
                p_type = 0;
            }
        }
    }
    /* User provided "external_dif" parameter will implicitly enables DIF processing.
     * So it is necessary to verify the SLI port is capable of supporting DIF.
     */
    if (ocs_get_property("external_dif", prop_buf, sizeof(prop_buf)) == 0) {
        if (dif_capable) {
            external_dif = ocs_strlen(prop_buf) > 0;
            if (external_dif) {
                if (ocs_strlen(prop_buf) > sizeof(t10_vendor_id)) {
                    ocs_log_err(ocs,"External dif vendor ID size exceeded the MAX size. Max size is : %lu\n",
                    sizeof(t10_vendor_id));
                }

                ocs_strncpy(t10_vendor_id, prop_buf, sizeof(t10_vendor_id));
                prot_en = 1;
                if (p_type == 0) {
                    p_type = 1;
                }
            }
        } else {
            ocs_log_err(ocs,"Device does not support DIF, ignoring user's external dif request.\n");
        }
    }

    if (ocs_get_property("dif_separate", prop_buf, sizeof(prop_buf)) == 0) {
        dif_separate = ocs_strtoul(prop_buf, 0, 0);
    }

    ramdisc_blockcount = ramdisc_size / ramdisc_blocksize;
    ocs_log_debug(ocs, "Ramdisc: num_luns:%d blocksize:%d blockcount:%" PRIu64 " (%" PRIu64 " mb)\n",
        num_luns, ramdisc_blocksize, ramdisc_blockcount, (ramdisc_blocksize*ramdisc_blockcount) / (1024*1024));

    *rdisc = ocs_malloc(ocs, sizeof(ocs_ramdisc_t*) * num_luns, OCS_M_NOWAIT | OCS_M_ZERO);
    ocs_assert(*rdisc, -1);
    *rdisc_count = num_luns;

    max_sge_size = ocs->tgt_ocs.max_sge;
    if (max_sge_size > OCS_MAX_DMA_ALLOC)
        max_sge_size = OCS_MAX_DMA_ALLOC;

    for (i = 0; i < num_luns; i ++) {
        if (i) {
            /**
             * In case we need to allocate multiple ramdiscs in huge sizes, this entire loop
             * might take more than '21' secs to execute. As a result, 'rcu_sched' can detect
             * a stall and send an NMI. To avoid such scenarios, yield the CPU.
             */
            ocs_thread_yield(NULL);
        }

        (*rdisc)[i] = (ocs_ramdisc_t*) ocs_malloc(ocs, sizeof(ocs_ramdisc_t), OCS_M_NOWAIT | OCS_M_ZERO);
        if ((*rdisc)[i] == NULL) {
            ocs_log_err(ocs, "Error: ocs_malloc rdisc[%d] failed\n", i);

            /* If we failed to allocate part of the LUNs we need to tear down
             * the entire target.  When we return failure the caller will assume the
             * target wasn't created.
             */

            ocs_scsi_ramd_free(ocs, rdisc, rdisc_count);
            return -1;
        }
        rc = ocs_new_ramdisc(ocs, (*rdisc)[i], ramdisc_blocksize,
                     max_sge_size/ramdisc_blocksize, ramdisc_size / ramdisc_blocksize);
        if (rc) {
            ocs_log_err(ocs, "Error: ocs_new_ramdisc failed allocating LUN %d\n", i);

            /* If we failed to allocate part of the LUNs we need to tear down
             * the entire target.  When we return failure the caller will assume the
             * target wasn't created.
             */

            ocs_scsi_ramd_free(ocs, rdisc, rdisc_count);

            return -1;
        }

        (*rdisc)[i]->lun = i;

        /* Post a Unit Attention saying we were powered on or reset */
        ocs_ramd_post_ua(ocs, (*rdisc)[i],
            SCSI_ASC(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED),
            SCSI_ASCQ(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED), NULL);

        if (dif_separate) {
            ocs_log_debug(ocs, "Ramdisc: Enabling DIF separate\n");
            (*rdisc)[i]->force_dif_separate = TRUE;
        }

        if (external_dif) {
            ocs_log_debug(ocs, "Ramdisc: Enabling proprietary end-to-end protection\n");
            (*rdisc)[i]->external_dif = TRUE;
            ocs_strncpy((*rdisc)[i]->t10_vendor_id, t10_vendor_id, sizeof((*rdisc)[i]->t10_vendor_id));
        }

        ocs_format_ramdisc(ocs, (*rdisc)[i], ramdisc_blocksize, p_type, prot_en, dif_separate);
    }
    return 0;
}

/**
 * @brief Free the memory associate with a ramdisc.
 *
 * @param ocs Pointer to the ocs.
 * @param rdisc Pointer to the ramdisc to allocate.
 * @param rdisc_count Pointer to the number of ramdiscs (LUNs) allocated.
 */
static void
ocs_scsi_ramd_free(ocs_t *ocs, ocs_ramdisc_t ***rdisc, uint32_t *rdisc_count)
{
    uint32_t i;

    if (*rdisc == NULL) {
        return;
    }

    ocs_log_debug(ocs, "freeing ramd, count=%d\n", *rdisc_count);
    for (i = 0; i < *rdisc_count; i ++) {
        if ((*rdisc)[i] != NULL) {
            ocs_del_ramdisc(ocs, (*rdisc)[i]);
            ocs_free(ocs, (*rdisc)[i], sizeof(ocs_ramdisc_t));
        }
    }
    ocs_free(ocs, *rdisc, sizeof(ocs_ramdisc_t*) * (*rdisc_count));

    *rdisc = NULL;
    *rdisc_count = 0;
}


/**
 * @ingroup scsi_api_target
 * @brief Initializes any target fields on the ocs structure.
 *
 * @par Description
 * Called by the OS initialization code when a new device is discovered.
 *
 * @param ocs Pointer to the ocs.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_new_device(ocs_t *ocs)
{
    int32_t rc = 0;
    uint32_t total_ios;
    char prop_buf[32];

    ocs_assert(ocs, -1);
    api_trace();

    /* Get the max settings */
    ocs->tgt_ocs.max_sge = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGE);
    ocs->tgt_ocs.max_sgl = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGL);

    /* initialize IO watermark fields */
    total_ios = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
    ocs_log_debug(ocs, "total_ios=%d\n", total_ios);
    ocs->tgt_ocs.watermark_min = (total_ios * OCS_WATERMARK_LOW_PCT) / 100;
    ocs->tgt_ocs.watermark_max = (total_ios * OCS_WATERMARK_HIGH_PCT) / 100;
    ocs_atomic_init(&ocs->tgt_ocs.io_high_watermark, ocs->tgt_ocs.watermark_max);
    ocs_atomic_init(&ocs->tgt_ocs.watermark_hit, 0);
    ocs_atomic_init(&ocs->tgt_ocs.initiator_count, 0);

    /* See if we are using the global ramdisk */
    ocs->tgt_ocs.use_global_ramd = TRUE;
    if (ocs_get_property("global_ramdisc", prop_buf, sizeof(prop_buf)) == 0) {
        ocs->tgt_ocs.use_global_ramd = ocs_strtoul(prop_buf, NULL, 0);
    }

#if defined(OCS_INCLUDE_FC)
    ocs->fc_type = FC_TYPE_FCP;
#endif

    if (ocs->tgt_ocs.use_global_ramd) {
        /*
         * initialize RAM disk; will only do this once and all
         * other PCI functions will use the same RAM Disk
         */
        ocs_lock(&ramd_lock);
        if (ramd_ref_cnt) {
            ocs_log_debug(ocs, "initialized subsequent RAM disk\n");
            ocs->tgt_ocs.rdisc = ocs_ramd;
            ocs->tgt_ocs.rdisc_count = ocs_ramd_count;
            ramd_ref_cnt++;
            ocs_unlock(&ramd_lock);
            return 0;
        }
        rc = ocs_scsi_ramd_create(ocs, &ocs->tgt_ocs.rdisc, &ocs->tgt_ocs.rdisc_count);

        if (rc == 0) {
            ocs_log_debug(ocs, "initialized first RAM disk count=%d\n", ocs->tgt_ocs.rdisc_count);
            ocs_ramd = ocs->tgt_ocs.rdisc;
            ocs_ramd_count = ocs->tgt_ocs.rdisc_count;
            ramd_ref_cnt++;
        }
        ocs_unlock(&ramd_lock);
    }

    ocs->tgt_mgmt_functions = &ramd_mgmt_functions;

    ocs->tgt_ocs.enable_task_set_full = ocs_scsi_get_property(ocs, OCS_SCSI_ENABLE_TASK_SET_FULL);
    ocs_log_debug(ocs, "Ramdisc: task set full processing is %s\n",
        ocs->tgt_ocs.enable_task_set_full ? "enabled" : "disabled");

    ocs_port_rdisc_init(ocs);

    /* Register a bounce callback even if not needed */
    ocs_scsi_register_bounce(ocs, ocs_ramd_tgt_bounce);

    return rc;
}

/**
 * @ingroup scsi_api_target
 * @brief Tears down the target members of the ocs structure.
 *
 * @par Description
 * Called by the OS code when the device is removed.
 *
 * @param ocs Pointer to the ocs.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_del_device(ocs_t *ocs)
{
    api_trace();

    ocs_assert(ocs, -1);

    if (ocs->tgt_ocs.use_global_ramd && ocs->tgt_ocs.rdisc) {
        ocs_lock(&ramd_lock);
        if (--ramd_ref_cnt) {
            ocs_unlock(&ramd_lock);
            /* still other devices using RAM disk, just exit */
            ocs_log_debug(ocs, "decremented ramd ref count %d\n",
                      ramd_ref_cnt);
        } else {
            ocs_ramd = NULL;
            ocs_ramd_count = 0;
            ocs_unlock(&ramd_lock);
            ocs_scsi_ramd_free(ocs, &ocs->tgt_ocs.rdisc, &ocs->tgt_ocs.rdisc_count);
        }
    } else if (!ocs->tgt_ocs.use_global_ramd) {
        ocs_port_rdisc_free(ocs);
    }
    return 0;
}

/**
 * @ingroup scsi_api_target
 * @brief Accept a new domain notification.
 *
 * @par Description
 * Called by the base driver when a new domain is discovered. A target-server
 * uses this call to prepare for the new remote node notifications
 * coming from the ocs_scsi_new_initiator().
 * The domain context has the ocs_scsi_tgt_domain_t structure, which is
 * declared by the target-server code and used for target-server private data.<br><br>
 * @b Note: This function will only be called if the base driver has been enabled for target
 * capability. For initiator-client back-ends, the ocs_scsi_ini_new_domain()
 * function is called.
 *
 * @param domain Pointer to the domain.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_tgt_new_domain(ocs_domain_t *domain)
{
    int32_t rc = 0;
    api_trace();
    return rc;
}

/**
 * @ingroup scsi_api_target
 * @brief Accept a domain lost notification.
 *
 * @par Description
 * Called by the base driver when a domain goes away. A target-server
 * uses this call to clean up all domain-scoped resources.<br><br>
 * @b Note: For initiator-client back-ends, the ocs_scsi_ini_del_domain()
 * function is called.
 *
 * @param domain Pointer to the domain.
 *
 * @return None.
 */
void
ocs_scsi_tgt_del_domain(ocs_domain_t *domain)
{
    api_trace();
    ocs_assert(domain);
}

/**
 * @ingroup scsi_api_target
 * @brief Accept a new SLI Port notification.
 *
 * @par Description
 * Called by the base driver when a new SLI Port (sport) is discovered. A target-server
 * uses this call to prepare for new remote node notifications
 * arising from ocs_scsi_new_initiator().<br><br>
 * @b Note: This function will only be called if the base driver has been enabled for
 * target capability. For initiator-client backends, the ocs_scsi_ini_new_sport()
 * function is called.
 *
 * @param sport Pointer to the sport.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t ocs_scsi_tgt_new_sport(ocs_sport_t *sport)
{
    ocs_t *ocs = sport->ocs;
    int32_t rc = 0;

    ocs_log_debug(ocs, "targ: New SPORT: %s\n", sport->display_name);

    /* initialize sPort RAM disk if this feature is enabled */
    if (!ocs->tgt_ocs.use_global_ramd) {
        ocs_sport_lock(sport);
            /* If a ramdisc matching the tgt_id is found, then use it, otherwise allocate a
             * new one.
             */
            rc = ocs_port_rdisc_find(sport->ocs, sport->tgt_id, &sport->tgt_sport.rdisc,
                         &sport->tgt_sport.rdisc_count);
            if (rc < 0) { /* not found */
                rc = ocs_scsi_ramd_create(ocs, &sport->tgt_sport.rdisc, &sport->tgt_sport.rdisc_count);

                if (rc == 0) {
                    ocs_log_debug(ocs, "initialized sport RAM disk count=%d\n",
                              sport->tgt_sport.rdisc_count);
                }

                rc = ocs_port_rdisc_save(ocs, sport->tgt_id, sport->tgt_sport.rdisc,
                             sport->tgt_sport.rdisc_count);
                if (rc < 0) {
                    ocs_log_test(ocs, "ocs_port_rdisc_save failed\n");
                }
            }
        ocs_sport_unlock(sport);
    }

    return rc;
}

/**
 * @ingroup scsi_api_target
 * @brief Accept a SLI Port gone notification.
 *
 * @par Description
 * Called by the base driver when a sport goes away. A target-server
 * uses this call to clean up all sport-scoped resources.<br><br>
 * @b Note: For initiator-client backends, the ocs_scsi_ini_del_sport()
 * function is called.
 *
 * @param sport Pointer to the sport structure.
 *
 * @return None.
 */
void
ocs_scsi_tgt_del_sport(ocs_sport_t *sport)
{
    ocs_t *ocs = sport->ocs;

    ocs_assert(ocs);

    ocs_log_debug(sport->ocs, "Del SPORT: %s\n", sport->display_name);

}

/**
 * @ingroup scsi_api_target
 * @brief Validate a new initiator.
 *
 * @par Description
 * Sent by the base driver to validate a remote initiatiator. The target-server
 * returns TRUE if this initiator should be accepted.<br><br>
 * @b Note: This function is only to be called
 * if the base driver is enabled for target capability.
 *
 * @param node Pointer to the remote initiator node to validate.
 *
 * @return Returns TRUE if the initiator should be accepted, or FALSE if the
 * initiator should be rejected.
 *
 * @note
 */
int32_t
ocs_scsi_validate_initiator(ocs_node_t *node)
{
    return 1;
}

/**
 * @ingroup scsi_api_target
 * @brief Receive notification of a new SCSI initiator node.
 *
 * @par Description
 * Sent by the base driver to notify a target-server of the presence of a new
 * remote initiator. The target-server may use this call to prepare for
 * an inbound IO from this node.
 * The ocs_node_t structure has an element of type ocs_scsi_tgt_node_t named
 * tgt_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 to a new remote initiator node.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 *
 * @note
 */
int32_t
ocs_scsi_new_initiator(ocs_node_t *node)
{
    ocs_t *ocs;
    int num_luns = 0;
    int i;
    int32_t initiator_count;
    int32_t watermark;

    api_trace();
    ocs_assert(node, -1);
    ocs = node->ocs;

    /*
     * update IO watermark: increment initiator count
     */
    initiator_count = ocs_atomic_add_return(&ocs->tgt_ocs.initiator_count, 1) + 1;
    watermark = OCS_MAX(ocs->tgt_ocs.watermark_min,
        ocs->tgt_ocs.watermark_max - initiator_count*OCS_IO_WATERMARK_PER_INITIATOR);
    ocs_atomic_set(&ocs->tgt_ocs.io_high_watermark, watermark);

    if (ocs->tgt_ocs.use_global_ramd) {
        num_luns = ocs->tgt_ocs.rdisc_count;
    } else if (node->sport != NULL) {
        num_luns = node->sport->tgt_sport.rdisc_count;
    }
    if (num_luns == 0) {
        ocs_log_warn(ocs, "0 luns found");
        return -1;
    }

    /* Create Unit Attention queues, one per LUN */
    node->tgt_node.ua_queues = ocs_malloc(ocs, num_luns * sizeof(ocs_ramdisc_ua_queue_t),
            OCS_M_NOWAIT | OCS_M_ZERO);
    if (node->tgt_node.ua_queues == NULL) {
        node->tgt_node.num_ua_queues = 0;
    } else {
        node->tgt_node.num_ua_queues = num_luns;
        for (i=0; i<num_luns; i++) {
            ocs_lock_init(node->ocs, &node->tgt_node.ua_queues[i].ua_queue_lock, "ua queue lock");
            node->tgt_node.ua_queues[i].num_entries = 0;
            ocs_list_init(&node->tgt_node.ua_queues[i].entry_list, ocs_ramdisc_ua_t, link);
        }
    }

    return 0;
}

/**
 * @ingroup scsi_api_target
 * @brief Delete a SCSI initiator node.
 *
 * @par Description
 * Sent by the base driver to notify a target-server that a remote initiator is now gone.
 * The base driver has terminated all outstanding IOs, and the target-server will
 * receive the appropriate completions.
 * @n @n @b Note: This function is only called if the base driver is enabled for target capability.
 *
 * @param node Pointer to the node being deleted.
 * @param reason This is the reason that the initiator was removed and 
 * will be one of the following enumeration types: 
 * OCS_SCSI_INITIATOR_DELETED or OS_SCSI_INITIATOR_MISSING. 
 *
 * @return Returns OCS_SCSI_CALL_COMPLETE to indicate that all work completed.
 */
int32_t
ocs_scsi_del_initiator(ocs_node_t *node, ocs_scsi_del_initiator_reason_e reason)
{
    ocs_t *ocs;
    uint32_t num_luns = 0;
    int32_t initiator_count;
    int32_t watermark;

    /*
     * initiator is missing, return OCS_SCSI_CALL_COMPLETE to let the transport
     * dispose of the node.
     */
    if (reason == OCS_SCSI_INITIATOR_MISSING) {
        return OCS_SCSI_CALL_COMPLETE;
    }

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

    /*
     * update IO watermark: decrement initiator count
     */
    initiator_count = ocs_atomic_sub_return(&ocs->tgt_ocs.initiator_count, 1) - 1;
    watermark = OCS_MAX(ocs->tgt_ocs.watermark_min,
        ocs->tgt_ocs.watermark_max - initiator_count*OCS_IO_WATERMARK_PER_INITIATOR);
    ocs_atomic_set(&ocs->tgt_ocs.io_high_watermark, watermark);

    /* Remove the Unit Attention queues */
    if (ocs->tgt_ocs.use_global_ramd) {
        num_luns = ocs->tgt_ocs.rdisc_count;
    } else if (node->sport != NULL) {
        num_luns = node->sport->tgt_sport.rdisc_count;
    }

    if (node->tgt_node.ua_queues != NULL) {
        uint32_t i;

        for (i=0; i<num_luns; i++) {
            ocs_lock_free(&node->tgt_node.ua_queues[i].ua_queue_lock);
        }
        ocs_free(ocs, node->tgt_node.ua_queues, num_luns * sizeof(ocs_ramdisc_ua_queue_t));
        node->tgt_node.ua_queues = NULL;
    }
    node->tgt_node.num_ua_queues = 0;

    return OCS_SCSI_CALL_COMPLETE;
}

/**
 * @brief Perform ramd IO free.
 *
 * @par Description
 * Frees an ocs_ramd-managed IO object.
 *
 * @param io Pointer to the IO context.
 *
 * @return None.
 */
static void
ocs_ramd_io_free(ocs_io_t *io)
{
    ocs_assert(!io->tgt_io.tmfio);
    ocs_dma_free(io->ocs, &io->tgt_io.payload);
    /* kill the state machine */
    ocs_sm_disable(&io->tgt_io.sm);
    /* Call down to free base context resources, but only if the IO is still active */
    if (ocs_io_busy(io)) {
        io->tgt_io.thr = NULL;
        ocs_scsi_io_complete(io);
    }
}

/**
 * @brief Defines the standard sense response bits per the SCSI <i>SPC specification</i>.
 *
 */
typedef struct {
    uint8_t response_code:7,
        :1;
    uint8_t :8;
    uint8_t sense_key:4,
        :1,
        ili:1,
        eom:1,
        filemark:1;
    uint8_t information[4];
    uint8_t additional_sense_length;
    uint8_t command_specific_information[4];
    uint8_t asc;
    uint8_t ascq;
    uint8_t fru_code;
    uint8_t sense_key_specific_hi:7,
        sksv:1;
    uint8_t sense_key_specific_lo[2];
} fixed_sense_data_t;

/**
 * @ingroup scsi_api_target
 * @brief Receive an FCP SCSI command.
 *
 * @par Description
 * Called by the base driver when a new SCSI command has been received. The
 * target-server processes the command, and issues data phase and/or response phase
 * requests to the base driver.
 * The IO context (ocs_io_t) structure has an element of type ocs_scsi_tgt_io_t named
 * tgt_io that is declared and used by a target-server for private information.
 *
 * @param io Pointer to the IO context.
 * @param lun LUN for this IO.
 * @param cdb Pointer to the SCSI CDB.
 * @param cdb_len Length of the CDB, in bytes.
 * @param flags Command flags.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
_ocs_scsi_recv_cmd(ocs_io_t *io, uint32_t lun, uint8_t *cdb, uint32_t cdb_len, uint32_t flags)
{
    return ocs_scsi_recv_cmd_common(io, lun, cdb, cdb_len, flags, FALSE, NULL, 0);
}

/**
 * @ingroup scsi_api_target
 * @brief Receive an FCP SCSI command with the first burst data.
 *
 * @par Description
 * Receive a new FCP SCSI command from the base driver with the first burst data.
 *
 * @param io Pointer to the IO context.
 * @param lun LUN for this IO.
 * @param cdb Pointer to the SCSI CDB.
 * @param cdb_len Length of CDB, in bytes.
 * @param flags Command flags.
 * @param first_burst_buffers First burst buffers.
 * @param first_burst_bytes The number of bytes received in the first burst.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_recv_cmd_first_burst(ocs_io_t *io, uint32_t lun, uint8_t *cdb, uint32_t cdb_len, uint32_t flags,
                  ocs_dma_t first_burst_buffers[], uint32_t first_burst_bytes)
{
    int32_t rc = -1;

    if (cdb != NULL) {
        rc =  ocs_scsi_recv_cmd_common(io, lun, cdb, cdb_len, flags, TRUE, first_burst_buffers, first_burst_bytes);
    } else {
        /* Post buffers to the IO state machine */
        if (flags & OCS_SCSI_FIRST_BURST_ERR) {
            rc = ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_FIRST_BURST_ERR, NULL);
        } else if (flags & OCS_SCSI_FIRST_BURST_ABORTED) {
            rc = ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_FIRST_BURST_ABORTED, NULL);
        } else {
            io->tgt_io.first_burst_bytes = first_burst_bytes;
            io->tgt_io.first_burst_buffers = first_burst_buffers;
            rc = ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_FIRST_BURST, NULL);
        }
    }

    return rc;
}

/**
 * @brief Return address of data and DIF data given a block in the target
 *
 * @par Description
 * The virtual addresses of the data block and DIF block are returned for a given
 * lba in the target.
 *
 * @param io Pointer to the IO context.
 * @param blocknumber The SCSI logical block address.
 * @param addrlen Array of address length pairs.
 * @param max_addrlen Maximum number of addrlen pairs to return.
 * @param dif_vaddr Pointer to location to store virtual address of DIF block.
 *
 * @return Returns number of addrlen pairs returned, or a negative value for error.
 */
int32_t
ocs_scsi_get_block_vaddr(ocs_io_t *io, uint64_t blocknumber, ocs_scsi_vaddr_len_t addrlen[],
             uint32_t max_addrlen, void **dif_vaddr)
{
    int32_t rc = -1;

    if (max_addrlen >= 1) {
        addrlen[0].vaddr = (void*) ocs_ramdisc_lba_address(io->tgt_io.ramdisc, blocknumber);
        addrlen[0].length = io->tgt_io.ramdisc->data_block_size;
        *dif_vaddr = (void*) ocs_ramdisc_dif_address(io->tgt_io.ramdisc, blocknumber);
        rc = 1;
    }

    return rc;
}

/**
 * @brief Common code used by ocs_scsi_recv_cmd() and ocs_scsi_recv_cmd_first_burst().
 *
 * @par Description
 * Receive a new FCP SCSI command from the base driver, possibly with the first burst data.
 *
 * @param io Pointer to the IO context.
 * @param lun LUN for this IO.
 * @param cdb Pointer to the SCSI CDB.
 * @param cdb_len Length of the CDB, in bytes.
 * @param flags Command flags.
 * @param has_first_burst TRUE if the command has first burst data.
 * @param first_burst_buffers First burst buffer.
 * @param first_burst_bytes The number of bytes received in the first burst.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_recv_cmd_common(ocs_io_t *io, uint32_t lun, uint8_t *cdb, uint32_t cdb_len, uint32_t flags,
             uint8_t has_first_burst,
             ocs_dma_t first_burst_buffers[], uint32_t first_burst_bytes)
{
    int32_t rc = 0;
    uint32_t i;
    ocs_t *ocs = io->ocs;
    scsi_cmd_table_t *pcmd;
    int32_t active_io_count;

    api_trace();

    ocs_assert(cdb, -1);

    if (ENABLE_CMD_TRACE) {
        io_printf(io, "cdb: ");
        for (i = 0; i < cdb_len; i ++)
            ocs_log_debug(NULL, "%02X ", cdb[i]);
        ocs_log_debug(NULL, "\n");
    }


    /* Save calling arguments */
    io->tgt_io.flags = flags;
    io->tgt_io.first_burst_buffers = first_burst_buffers;
    io->tgt_io.first_burst_bytes   = first_burst_bytes;
    io->tgt_io.tmfio = NULL;

    /* Get a copy of the tgt domain context */
    io->tgt_io.lun = lun;
    io->tgt_io.sm.app = io;

    /* Clear block IO state */
    io->tgt_io.io_block_count = 0;
    io->tgt_io.acc_block_count = 0;
    io->tgt_io.cur_lba = 0;
    io->tgt_io.cur_block_count = 0;

    io->tgt_io.sgl_phys = 0;

    io->tgt_io.ramdisc = ocs_ramd_lookup(io, lun);

    /* Set flag indicating whether the LUN is defined for this target */
    io->tgt_io.lun_is_valid = (io->tgt_io.ramdisc != NULL);
    active_io_count = ACTIVE_IO_COUNT(ocs);

    /* set target timeout */
    io->timeout = ocs->target_io_timer_sec;

    /* set treceive wqe timeout */
    io->trecv_wqe_timer = ocs->tgt_wqe_timer;

    /* Take lock */
    ocs_lock(&io->tgt_io.sm_lock);

    /* Check for task set full */
    if (ocs->tgt_ocs.enable_task_set_full &&
        (active_io_count >= ocs_atomic_read(&ocs->tgt_ocs.io_high_watermark))) {
        ocs_atomic_add_return(&ocs->tgt_ocs.watermark_hit, 1);
        /* If this is a first burst command, then defer sending task set full */
        if (has_first_burst) {
            io->tgt_io.send_task_set_full = TRUE;
            ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_first_burst_send_resp, NULL);
        } else {
            if (ocs_ramd_task_set_full_or_busy(io) == SCSI_HANDLER_RESP_STARTED) {
                ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
            } else {
                ocs_ramd_io_free(io);
            }
        }
        ocs_unlock(&io->tgt_io.sm_lock);
        return -1;
    }

    /* Find a matching command */
    pcmd = NULL;
    if (cdb[0] == SCSI_SERVICE_ACTION_IN16) {
        uint32_t svc_action = cdb[1] & 0x1F;

        for (i = 0; i < ARRAY_SIZE(scsi_cmd_table_svc_in_action16); i ++) {
            if (scsi_cmd_table_svc_in_action16[i].scsi_cmd == svc_action) {
                pcmd = &scsi_cmd_table_svc_in_action16[i];
                break;
            }
        }
    } else if (cdb[0] == SCSI_SERVICE_ACTION_OUT16) {
        uint32_t svc_action = cdb[1] & 0x1F;

        for (i = 0; i < ARRAY_SIZE(scsi_cmd_table_svc_out_action16); i ++) {
            if (scsi_cmd_table_svc_out_action16[i].scsi_cmd == svc_action) {
                pcmd = &scsi_cmd_table_svc_out_action16[i];
                break;
            }
        }
    } else if (cdb[0] == SCSI_VARIABLE_LEN_CDB) {
        uint16_t svc_action =   (cdb[8] << 8) |
                    (cdb[9] << 0);
        for (i = 0; i < ARRAY_SIZE(scsi_cmd_table_variable_len_cdb); i ++) {
            if (scsi_cmd_table_variable_len_cdb[i].scsi_cmd == svc_action) {
                pcmd = &scsi_cmd_table_variable_len_cdb[i];
                break;
            }
        }

    } else {
        pcmd = scsi_cmd_lookup[cdb[0]];
    }

    /* Save cdb, pointer to command */
    io->tgt_io.pcmd = pcmd;
    io->tgt_io.cdb_len = cdb_len;
    ocs_memcpy(io->tgt_io.cdb, cdb, MIN(cdb_len, ARRAY_SIZE(io->tgt_io.cdb)));

    /* Note whether first burst */
    io->tgt_io.has_first_burst = has_first_burst;

    if (ocs->err_injection != NO_ERR_INJECT) {
        ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_init_err_injection, NULL);
    } else {
        /* Start the state machine */
        ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_init, NULL);
    }

    ocs_unlock(&io->tgt_io.sm_lock);

    return rc;
}

/**
 * @ingroup io_sm
 * @brief State: Initial IO state with error injection enabled.
 *
 * @par Description
 * The initial IO state processes error injection options for the received command.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_init_err_injection(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;
    scsi_cmd_table_t *pcmd = io->tgt_io.pcmd;
    int32_t rc;

    switch (evt) {
    case OCS_EVT_ENTER: {
        switch (ocs->err_injection) {
        case INJECT_DROP_CMD:
            if (ocs->cmd_err_inject != 0 && ocs->cmd_err_inject == pcmd->scsi_cmd) {
                io_printf(io, "Err-injection test: drop command\n");
                return NULL;
            }
            break;
        case INJECT_FREE_DROPPED:
            if (ocs->cmd_err_inject != 0 && ocs->cmd_err_inject == pcmd->scsi_cmd) {
                io_printf(io, "Err-injection test: free dropped command\n");
                ocs_ramd_io_free(io);
                return NULL;
            }
            break;
        case INJECT_DELAY_CMD:
            if (ocs->cmd_err_inject != 0 && ocs->cmd_err_inject == pcmd->scsi_cmd) {
                io_printf(io, "Err-injection test: delay command\n");
                ocs_msleep(ocs->delay_value_msec);
            }
            break;
        case INJECT_DROP_DATA:
            /* drop_data is handled in __ocs_ramd_io_wait_first_burst */
        case INJECT_DROP_RESP:
            /* drop_resp is handled in dataphase states */
        default:
            break;
        }
        /* Start the state machine */
        ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_init, NULL);
        break;
    }

    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP:
        /* Abort the I/O in progress */
        io_printf(io, "%-20s evt=%s\n", __func__, ocs_sm_event_name(evt));

        /* for abort_io event, will send completion event after abort
         * for abort_io_no_resp event, no such completion will be generated
         */
        if (evt == OCS_EVT_ABORT_IO) {
            ocs_assert(arg, NULL);
            io->tgt_io.tmfio = (ocs_io_t *)arg;
        } else {
            io->tgt_io.tmfio = NULL;
        }

        /* transition to state where we wait for completions
         * we would only be in this state if the command was dropped,
         * we won't be getting an IO cmpl
         */
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting_wait_abort_cmpl, NULL);

        rc = ocs_scsi_tgt_abort_io(io, false, ocs_ramd_abort_tgt_cb, NULL);
        if (rc != 0) {
            io_printf(io, "Failed to abort IO\n");
        }
        break;

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

/**
 * @brief Function to call the command handler for a CDB.
 *
 * @par Description
 * After a command and its first burst data is received, this function is called
 * to call the actual command handler function.
 *
 * @param io Pointer to the SCSI IO object.
 *
 * @return The command handler status.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_call_cmd_handler(ocs_io_t *io)
{
    ocs_sm_ctx_t *ctx = &io->tgt_io.sm;
    uint8_t *cdb = io->tgt_io.cdb;
    scsi_cmd_table_t *pcmd = io->tgt_io.pcmd;
    ocs_ramd_hndlr_rtn_e rc;

    ocs_assert(pcmd, SCSI_HANDLER_NOT_STARTED);

    rc = pcmd->handler(io, cdb);

    switch(rc) {
    case SCSI_CMD_NOT_SUPPORTED:
        if (ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0) == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(ctx, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
        break;
    case SCSI_HANDLER_DATAPHASE_STARTED:
        ocs_sm_transition(ctx, __ocs_ramd_io_wait_dataphase_compl, NULL);
        break;
    case SCSI_HANDLER_RESP_STARTED:
        ocs_sm_transition(ctx, __ocs_ramd_io_wait_resp_compl, NULL);
        break;
    case SCSI_HANDLER_VALIDATED_DATAPHASE_STARTED:
        ocs_sm_transition(ctx, __ocs_ramd_io_wait_and_validate_dataphase, NULL);
        break;
    case SCSI_HANDLER_WRITE_SAME_DATAPHASE_STARTED:
        ocs_sm_transition(ctx, __ocs_ramd_io_wait_and_complete_writesame_dataphase, NULL);
        break;
    case SCSI_HANDLER_NOT_STARTED:
        ocs_ramd_io_free(io);
        break;

    default:
        break;
    }

    return rc;
}

/**
 * @ingroup io_sm
 * @brief State: Initial IO state.
 *
 * @par Description
 * The initial IO state invokes a SCSI command processing function, which may be a
 * data phase or a response for the received command.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_INIT;

    switch(evt) {
    case OCS_EVT_ENTER: {
        scsi_cmd_table_t *pcmd;
        ocs_node_t *node = io->node;
        uint8_t asc;
        uint8_t ascq;
        uint32_t lun = io->tgt_io.lun;
        uint8_t  direction = 0;

        /*
         * If the command has first burst which has not been received,
         * then wait for the data before calling the command handler.
         */
        if (io->tgt_io.has_first_burst &&
            (io->tgt_io.first_burst_bytes == 0 ||
             io->tgt_io.first_burst_buffers == NULL)) {
            ocs_sm_transition(ctx, __ocs_ramd_io_wait_first_burst, NULL);
            break;
        }

        pcmd = io->tgt_io.pcmd;

        /* Check to see whether we found a supported command. If not send Check Condition. */
        if (pcmd == NULL) {
            io_printf(io, "No cmd handler\n");
            if (ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0) == SCSI_HANDLER_RESP_STARTED) {
                ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
            } else {
                ocs_ramd_io_free(io);
            }
            break;
        }

        /* Check data direction validity, return a chack condition on failure */
        direction = ((io->tgt_io.flags & OCS_SCSI_CMD_DIR_IN) ? DATA_DIR_WRITE : 0) |
                ((io->tgt_io.flags & OCS_SCSI_CMD_DIR_OUT) ? DATA_DIR_READ : 0);

        if ((io->exp_xfer_len > 0) && ((pcmd->data_dir != direction) || (direction == DATA_DIR_NONE))) {
            if (ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CMDIU, SNSCODEQUAL_INV_CMDIU) ==
                SCSI_HANDLER_RESP_STARTED) {
                ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
            } else {
                ocs_ramd_io_free(io);
            }

            break;
        }

        /* Check for valid lun */
        if (pcmd->check_lun && !io->tgt_io.lun_is_valid) {
            io_printf(io, "lun %d out of range\n", io->tgt_io.lun);
            if (ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SCSI_ASC(SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED), 0) == SCSI_HANDLER_RESP_STARTED) {
                ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
            } else {
                ocs_ramd_io_free(io);
            }
            break;
        }

        /* Check for Unit Attention */
        if (ocs_ramd_get_ua(ocs, node, io->tgt_io.lun, &asc, &ascq)) {
            switch (io->tgt_io.cdb[0]) {
            case SCSI_INQUIRY:
                /*
                 * Allow the command
                 * Don't clear any unit attentions
                 */
                break;
            case SCSI_REQUEST_SENSE:
                /*
                 * Report the Unit Attention
                 * Clear the Unit Attention
                 */
                ocs_ramd_clear_ua(ocs, node, lun, asc, ascq);
                if (ocs_ramd_check_cond(io, SNS_UNIT_ATTENTION, asc, ascq) == SCSI_HANDLER_RESP_STARTED) {
                    ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
                } else {
                    ocs_ramd_io_free(io);
                }
                return NULL;
            case SCSI_REPORT_LUNS:
                /*
                 * Allow the command
                 * Clear any REPORTED LUNS DATA HAS CHANGED unit attentions
                 */
                ocs_ramd_clear_ua(ocs, node, lun, SCSI_ASC(SCSI_ASC_REPORTED_LUNS_DATA_HAS_CHANGED),
                        SCSI_ASCQ(SCSI_ASC_REPORTED_LUNS_DATA_HAS_CHANGED));
                break;
            default:
                /*
                 * If there's a current Unit Attention return that instead
                 * of processing the command.
                 */
                ocs_ramd_clear_ua(ocs, node, lun, asc, ascq);
                if (ocs_ramd_check_cond(io, SNS_UNIT_ATTENTION, asc, ascq) == SCSI_HANDLER_RESP_STARTED) {
                    ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
                } else {
                    ocs_ramd_io_free(io);
                }
                return NULL;
            }
        }
        ocs_ramd_call_cmd_handler(io);
        break;
    }

    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;

}

/**
 * @ingroup io_sm
 * @brief State: Waiting for first burst data.
 *
 * @par Description
 * Waits for the first burst data on an IO.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_first_burst(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_FIRST_BURST;

    switch(evt) {
    case OCS_EVT_IO_FIRST_BURST:
        /*
         * If the command has first burst which has not been received,
         * then wait for the data before calling the command handler.
         */
        if (io->tgt_io.has_first_burst &&
            (io->tgt_io.first_burst_bytes == 0 ||
             io->tgt_io.first_burst_buffers == NULL)) {
            /* Wait for the first burst data */
        } else {
            if (ocs->err_injection == INJECT_DROP_DATA) {
                io_printf(io, "Err-injection test: First burst data dropped\n");
                break;
            }
            ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_init, NULL);
        }
        break;

    case OCS_EVT_IO_FIRST_BURST_ERR:
        /* first burst has encountered an error before receiving all of it,
           send generic check condition */
        io_printf(io, "first burst/auto-xfr-rdy error encountered\n");
                ocs_ramd_io_error(io, OCS_SCSI_STATUS_ERROR);
        break;

    case OCS_EVT_IO_FIRST_BURST_ABORTED:
        /* first burst has been aborted before receiving all of it, free io */
        io_printf(io, "first burst/auto-xfr-rdy aborted encountered\n");
        ocs_ramd_io_free(io);
        break;

    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        int32_t rc;

        /* Abort the I/O in progress */
        io_printf(io, "evt=%s\n", ocs_sm_event_name(evt));

        /* for abort_io event, will send completion event after abort
         * for abort_io_no_resp event, no such completion will be generated
         */
        if (evt == OCS_EVT_ABORT_IO) {
            ocs_assert(arg, NULL);
            io->tgt_io.tmfio = (ocs_io_t *)arg;
        } else {
            io->tgt_io.tmfio = NULL;
        }

        /* we haven't issued a command to the chip, so we won't be expecting
         * an IO completion (only abort completion)
         */
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting_wait_abort_cmpl, NULL);
        rc = ocs_scsi_tgt_abort_io(io, false, ocs_ramd_abort_tgt_cb, NULL);
        if (rc != 0) {
            io_printf(io, "Failed to abort IO\n");
        }
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @brief Command abort callback.
 *
 * @par Description
 * This function is called with a command abort request to the base driver SCSI API completes.
 *
 * @param io Pointer to the IO context.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_abort_tgt_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{
    ocs_lock(&io->tgt_io.sm_lock);
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_ABORT_CMPL, NULL);
    ocs_unlock(&io->tgt_io.sm_lock);
    return 0;
}

static int32_t
ocs_ramd_io_error(ocs_io_t *io, ocs_scsi_io_status_e scsi_status)
{
    uint8_t asc;
    uint8_t ascq;
    uint8_t check_cond = TRUE;

    switch (scsi_status) {
    case OCS_SCSI_STATUS_NO_IO:
    case OCS_SCSI_STATUS_ABORTED:
    case OCS_SCSI_STATUS_NEXUS_LOST:
    case OCS_SCSI_STATUS_TIMEDOUT_AND_ABORTED:
    case OCS_SCSI_STATUS_SHUTDOWN:
        /*
         * For these status codes, no use sending a check condition,
         * just free the IO.
         */
        io_printf(io, "status=%d, freeing io\n", scsi_status);
        check_cond = FALSE;
        break;
    case OCS_SCSI_STATUS_DIF_GUARD_ERROR:
        asc = SNSCODE_DIF_ERR;
        ascq = 0x01;
        break;
    case OCS_SCSI_STATUS_DIF_APP_TAG_ERROR:
        asc = SNSCODE_DIF_ERR;
        ascq = 0x02;
        break;
    case OCS_SCSI_STATUS_DIF_REF_TAG_ERROR:
        asc = SNSCODE_DIF_ERR;
        ascq = 0x03;
        break;
    case OCS_SCSI_STATUS_DIF_UNKNOWN_ERROR:
        asc = SNSCODE_DIF_ERR;
        ascq = 0x01;
        break;
    case OCS_SCSI_STATUS_PROTOCOL_CRC_ERROR:
        asc = SNSCODE_ABORTED_CMD;
        ascq = 0x05;
        break;
    default:
        asc = SNSCODE_OFF_ERR;
        ascq = 0x00;
        break;
    }

    if (check_cond) {
        if (ocs_ramd_check_cond(io, SNS_ABORTED_CMD, asc, ascq) == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
    } else {
        ocs_ramd_io_free(io);
    }
    return 0;
}

/**
 * @ingroup io_sm
 * @brief State: Wait for the data phase to complete.
 *
 * @par Description
 * Wait for data phase to complete. If done, send a response.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_dataphase_compl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_DATAPHASE_COMPL;

    switch(evt) {
    case OCS_EVT_IO_CMPL:
        if (ocs->err_injection == INJECT_DROP_RESP) {
            io_printf(io, "Err-injection test: drop response lun x%x\n", io->tgt_io.lun);
            break;
        }
        if (ocs_ramd_good_status(io) == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(ctx, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
        break;

    case OCS_EVT_IO_CMPL_ERRORS: {
                ocs_scsi_io_status_e scsi_status;

                scsi_status = *((ocs_scsi_io_status_e*) arg);
                ocs_ramd_io_error(io, scsi_status);
                break;
        }

    case OCS_EVT_RESP_CMPL:
        ocs_ramd_io_free(io);
        break;

    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Wait for the data phase to complete, then validate the received data.
 *
 * @par Description
 * Wait for data phase to complete. If done, send a response.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_and_validate_dataphase(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    int32_t (*validate)(ocs_io_t *io);
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;
    uint32_t result;
    ocs_ramd_hndlr_rtn_e rc;

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_AND_VALIDATE_DATAPHASE;

    switch(evt) {
    case OCS_EVT_IO_CMPL:
        if (ocs->err_injection == INJECT_DROP_RESP) {
            io_printf(io, "Err-injection test: drop response lun x%x\n", io->tgt_io.lun);
            break;
        }

        result = 0;
        if (arg != NULL) {
            validate =  arg;
            result = validate(io);
        }

        if (result == 0) {
            rc = ocs_ramd_good_status(io);
        } else {
            rc = ocs_ramd_check_cond(io, ((result & 0xff0000) >> 16), ((result & 0xff00) >> 8),
                         result & 0xff);
        }

        if (rc == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(ctx, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
        break;

    case OCS_EVT_IO_CMPL_ERRORS: {
        ocs_scsi_io_status_e scsi_status;

        scsi_status = *((ocs_scsi_io_status_e*) arg);
        ocs_ramd_io_error(io, scsi_status);
        break;
    }

    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Wait for the data phase to complete following a WRITE SAME command.
 *
 * @par Description
 * Wait for the data phase to complete. If done, complete the WRITE SAME command.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_and_complete_writesame_dataphase(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    ocs_t *ocs = io->ocs;
    ocs_ramd_hndlr_rtn_e rc;

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_AND_COMPLETE_WRITESAME_DATAPHASE;

    switch(evt) {
    case OCS_EVT_IO_CMPL:
        if (ocs->err_injection == INJECT_DROP_RESP) {
            io_printf(io, "Err-injection test: drop response lun x%x\n", io->tgt_io.lun);
            break;
        }

        /* At this point we've completed the data phase for the WRITE SAME command
         * so we've transfered the one block to memory. Now we need to complete the
         * command by copying that block to other blocks, possibly with modifications
         * along the way
         */

        rc = ocs_ramd_complete_write_same(io);


        if (rc == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(ctx, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
        break;

    case OCS_EVT_IO_CMPL_ERRORS: {
        ocs_scsi_io_status_e scsi_status;

        scsi_status = *((ocs_scsi_io_status_e*) arg);
        ocs_ramd_io_error(io, scsi_status);
        break;
    }

    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Wait on first burst then send response.
 *
 * @par Description
 * Wait for first burst to complete, then send a SCSI response.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_first_burst_send_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io;
    ocs_ramd_hndlr_rtn_e rc = 0;

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    io = ctx->app;
    ocs_assert(io->node, NULL);
    ocs_assert(io->ocs, NULL);

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_FIRST_BURST_SEND_RESP;

    switch(evt) {
    case OCS_EVT_ENTER:
        ocs_assert(io->tgt_io.send_task_set_full || io->tgt_io.send_check_cond, NULL);
        break;

    case OCS_EVT_IO_FIRST_BURST:
        if (io->tgt_io.send_task_set_full) {
            rc = ocs_ramd_task_set_full_or_busy(io);
        } else if (io->tgt_io.send_check_cond) {
            rc = ocs_ramd_check_cond(io, io->tgt_io.send_sense_key,
                         io->tgt_io.send_asc,
                         io->tgt_io.send_ascq);
        }
        if (rc == SCSI_HANDLER_RESP_STARTED) {
            ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_resp_compl, NULL);
        } else {
            ocs_ramd_io_free(io);
        }
        break;
    case OCS_EVT_IO_FIRST_BURST_ERR:
        /* first burst has encountered an error before receiving all of it,
           send generic check condition */
        io_printf(io, "first burst/auto-xfr-rdy error encountered\n");
                ocs_ramd_io_error(io, OCS_SCSI_STATUS_ERROR);
        break;

    case OCS_EVT_IO_FIRST_BURST_ABORTED:
        /* first burst has been aborted before receiving all of it, free io */
        io_printf(io, "first burst/auto-xfr-rdy aborted encountered\n");
        ocs_ramd_io_free(io);
        break;

    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        int32_t rc;

        /* Abort the I/O in progress */
        io_printf(io, "evt=%s\n", ocs_sm_event_name(evt));

        /* for abort_io event, will send completion event after abort
         * for abort_io_no_resp event, no such completion will be generated
         */
        if (evt == OCS_EVT_ABORT_IO) {
            ocs_assert(arg, NULL);
            io->tgt_io.tmfio = (ocs_io_t *)arg;
        } else {
            io->tgt_io.tmfio = NULL;
        }

        /* we haven't issued a command to the chip, so we won't be expecting
         * an IO completion (only abort completion)
         */
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting_wait_abort_cmpl, NULL);
        rc = ocs_scsi_tgt_abort_io(io, false, ocs_ramd_abort_tgt_cb, NULL);
        if (rc != 0) {
            io_printf(io, "Failed to abort IO\n");
        }
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Wait for the response to complete.
 *
 * @par Description
 * Wait for a SCSI response phase to complete. Upon completion, free the IO context.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_wait_resp_compl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io;

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    io = ctx->app;
    ocs_assert(io->node, NULL);
    ocs_assert(io->ocs, NULL);

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_WAIT_RESP_COMPL;

    switch(evt) {
    case OCS_EVT_RESP_CMPL:
        ocs_ramd_io_free(io);
        break;
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Wait for the TMF response to complete.
 *
 * @par Description
 * Wait for a TMF response phase to complete. Upon completion,
 * free the IO context.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_tmf_wait_resp_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *tmfio;

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    tmfio = ctx->app;
    ocs_assert(tmfio->node, NULL);
    ocs_assert(tmfio->ocs, NULL);

    tmfio_sm_trace();
    tmfio->tgt_io.current_state = __OCS_RAMD_TMF_WAIT_RESP_CMPL;

    switch(evt) {
    case OCS_EVT_RESP_CMPL:
        ocs_ramd_io_free(tmfio);
        break;
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        ocs_ignore_abort_evt(evt, __func__, tmfio, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @brief Abort response callback.
 *
 * @par Description
 * When an IO abort operation has completed, this callback is invoked.
 *
 * @param io Pointer to the context.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_tgt_abort_rsp_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{
    if (scsi_status != OCS_SCSI_STATUS_GOOD) {
        io_printf(io, "abort failed, status=%d\n", scsi_status);
    }
    ocs_lock(&io->tgt_io.sm_lock);
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_RESP_CMPL, NULL);
    ocs_unlock(&io->tgt_io.sm_lock);
    return 0;
}

/**
 * @brief State: Aborting IO.
 *
 * @par Description
 * IO abort has been started. Wait for IO or abort 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_ramd_io_aborting(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io; /* 'io' here is IO being aborted */

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    io = ctx->app;
    ocs_assert(io->node, NULL);
    ocs_assert(io->ocs, NULL);

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_ABORTING;

    switch(evt) {
    case OCS_EVT_IO_CMPL:
    case OCS_EVT_IO_CMPL_ERRORS:
    case OCS_EVT_RESP_CMPL:
        /* IO has completed first. Transition to wait for abort to complete */
        io_printf(io, "IO cmpl evt=%s\n", ocs_sm_event_name(evt));
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting_wait_abort_cmpl, NULL);
        break;

    case OCS_EVT_ABORT_CMPL: {
        /* Abort has completed first. Transition to wait for abort to complete */
        io_printf(io, "IO abort cmpl evt=%s\n", ocs_sm_event_name(evt));
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting_wait_io_cmpl, NULL);
        break;
    }
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        ocs_ignore_abort_evt(evt, __func__, io, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @brief State: Cleanup aborted IO.
 *
 * @par Description
 * Cleanup IO that has been aborted.
 *
 * @param io Aborted IO.
 *
 * @return None.
 */
static void
ocs_ramd_abort_cleanup(ocs_io_t *io)
{
    ocs_io_t *tmfio = io->tgt_io.tmfio;

    if (tmfio) {
        /* post event to TMF IO to indicate that this IO has been aborted */
        ocs_sm_post_event(&tmfio->tgt_io.sm, OCS_EVT_IO_ABORTED_BY_TMF, NULL);
        io->tgt_io.tmfio = NULL;
    }

    /* Free the aborted IO */
    ocs_ramd_io_free(io);
}

/**
 * @brief State: Aborting IO.
 *
 * @par Description
 * IO abort has been started and IO has completed. Wait for the
 * abort to complete and then free IO.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */

static void *
__ocs_ramd_io_aborting_wait_abort_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io; /* 'io' here is IO being aborted */

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    io = ctx->app;
    ocs_assert(io->node, NULL);
    ocs_assert(io->ocs, NULL);

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_ABORTING_WAIT_ABORT_CMPL;

    switch(evt) {
    case OCS_EVT_ABORT_CMPL: {
        io_printf(io, "IO abort cmpl evt=%s\n", ocs_sm_event_name(evt));
        ocs_ramd_abort_cleanup(io);
        break;
    }
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        ocs_ignore_abort_evt(evt, __func__, io, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @brief State: Aborting IO.
 *
 * @par Description
 * IO abort has been started and Abort has completed. Wait for
 * the IO to complete and then free IO.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_io_aborting_wait_io_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io; /* 'io' here is IO being aborted */

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    io = ctx->app;
    ocs_assert(io->node, NULL);
    ocs_assert(io->ocs, NULL);

    io_sm_trace();
    io->tgt_io.current_state = __OCS_RAMD_IO_ABORTING_WAIT_IO_CMPL;

    switch(evt) {
    case OCS_EVT_IO_CMPL:
    case OCS_EVT_IO_CMPL_ERRORS:
    case OCS_EVT_RESP_CMPL:
        io_printf(io, "IO cmpl evt=%s\n", ocs_sm_event_name(evt));
        ocs_ramd_abort_cleanup(io);
        break;
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        ocs_ignore_abort_evt(evt, __func__, io, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: Common IO event handler.
 *
 * @par Description
 * Handles events common to all states.
 *
 * @param funcname Calling function name string.
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */

static void *
__ocs_ramd_io_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *io = ctx->app;
    int32_t rc;

    switch(evt) {
    case OCS_EVT_ENTER:
    case OCS_EVT_REENTER:
    case OCS_EVT_EXIT:
        break;
    case OCS_EVT_SHUTDOWN:
        break;
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP:
        /* Abort the I/O in progress */
        io_printf(io, "%-20s evt=%s\n", funcname, ocs_sm_event_name(evt));

        /* for abort_io event, will send completion event after abort
         * for abort_io_no_resp event, no such completion will be generated
         */
        if (evt == OCS_EVT_ABORT_IO) {
            ocs_assert(arg, NULL);
            io->tgt_io.tmfio = (ocs_io_t *)arg;
        } else {
            io->tgt_io.tmfio = NULL;
        }

        /* transition to state where we wait for completions */
        ocs_sm_transition(ctx, __ocs_ramd_io_aborting, NULL);
        rc = ocs_scsi_tgt_abort_io(io, false, ocs_ramd_abort_tgt_cb, NULL);
        if (rc != 0) {
            io_printf(io, "Failed to abort IO\n");
        }
        break;

    case OCS_EVT_IO_FIRST_BURST:
    case OCS_EVT_IO_FIRST_BURST_ERR:
    case OCS_EVT_IO_FIRST_BURST_ABORTED:
        io_printf(io, "%-20s ignoring evt %-20s\n", funcname, ocs_sm_event_name(evt));
        break;
    default:
        io_printf(io, "%-20s %-20s not handled\n", funcname, ocs_sm_event_name(evt));
        break;
    }
    return NULL;
}

/**
 * @ingroup scsi_cmd
 * @brief Send a good SCSI status.
 *
 * @par Description
 * A good SCSI status is sent to the initiator associated with the IO.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns SCSI_HANDLER_RESP_STARTED on success, or
 * SCSI_HANDLER_NOT_STARTED on error.
 */

ocs_ramd_hndlr_rtn_e
ocs_ramd_good_status(ocs_io_t *io)
{
    ocs_ramd_hndlr_rtn_e rc;

    /* Send the response */
    if (ocs_scsi_send_resp(io, 0, NULL, scsi_io_cb, NULL) == 0) {
        rc = SCSI_HANDLER_RESP_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }

    return rc;
}

/**
 * @ingroup scsi_cmd
 * @brief Send a SCSI check condition.
 *
 * @par Description
 * A SCSI check condition response is sent to the initiator associated with the
 * IO.
 *
 * @param io Pointer to the IO context.
 * @param sense_key SCSI response sense key.
 * @param asc SCSI response ASC value.
 * @param ascq SCSI response ASCA value.
 *
 * @return Returns SCSI_HANDLER_RESP_STARTED on success, or
 * SCSI_HANDLER_NOT_STARTED on error.
 */

ocs_ramd_hndlr_rtn_e
ocs_ramd_check_cond(ocs_io_t *io, uint8_t sense_key, uint8_t asc, uint8_t ascq)
{
    ocs_ramd_hndlr_rtn_e rc;
    ocs_scsi_cmd_resp_t rsp;
    fixed_sense_data_t sense;

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

    rsp.scsi_status = 2;
    rsp.sense_data = (uint8_t*) &sense;
    rsp.sense_data_length = sizeof(sense);
    
#if defined(OCS_INCLUDE_FC)
    rsp.residual = io->exp_xfer_len - io->transferred;
#endif

    /* populate sense data with a check condition */
    sense.response_code = 0x70;
    sense.sense_key = sense_key;    /* sense key */
    sense.asc = asc;        /* logical unit not ready */
    sense.ascq = ascq;      /* cause not reportable */
    sense.additional_sense_length = sizeof (sense) - 8;

    /* Send the response */
    if (ocs_scsi_send_resp(io, 0, &rsp, scsi_io_cb, NULL) == 0) {
        rc = SCSI_HANDLER_RESP_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }

    return rc;
}

/**
 * @ingroup scsi_cmd
 * @brief Send a SCSI task set full or busy status.
 *
 * @par Description
 * A SCSI task set full or busy response is sent, depending on whether
 * another IO is already active on the LUN.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns SCSI_HANDLER_RESP_STARTED on success or
 * SCSI_HANDLER_NOT_STARTED on error.
 */
ocs_ramd_hndlr_rtn_e
ocs_ramd_task_set_full_or_busy(ocs_io_t *io)
{
    int32_t rc;
    ocs_scsi_cmd_resp_t rsp;
    ocs_io_t *ioloop;
    ocs_io_t *ionext;
    ocs_t *ocs = io->ocs;

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

    /*
     * If there is another command for the LUN, then send task set full,
     * if this is the first one, then send the busy status.
     */
    rsp.scsi_status = SCSI_STATUS_BUSY; /* Busy */
    ocs_lock(&io->node->active_ios_lock);
        if (!ocs_list_empty(&io->node->active_ios)) {
            ocs_list_foreach_safe(&io->node->active_ios, ioloop, ionext) {
                if (ioloop != io &&
                    ioloop->tgt_io.lun == io->tgt_io.lun) {
                    rsp.scsi_status = SCSI_STATUS_TASK_SET_FULL; /* Task set full */
                    break;
                }
            }
        }
    ocs_unlock(&io->node->active_ios_lock);

    /* Log a message here indicating a busy or task set full state */
    if (OCS_LOG_ENABLE_Q_FULL_BUSY_MSG(ocs)) {
        /* Log Task Set Full */
        if (rsp.scsi_status == SCSI_STATUS_TASK_SET_FULL) {
            /* Task Set Full Message */
            ocs_log_info(ocs, "OCS RAMD TASK SET FULL. Tasks >= %d\n", ocs_atomic_read(&ocs->tgt_ocs.io_high_watermark));
        }
        else if (rsp.scsi_status == SCSI_STATUS_BUSY) {
            /* Log Busy Message */
            ocs_log_info(ocs, "OCS RAMD SCSI BUSY\n");
        }
    }

    /* Send the repsponse on low latency queue, using WQ CLASS 1 */
    if (ocs_scsi_send_resp(io, OCS_SCSI_LOW_LATENCY | OCS_SCSI_WQ_CLASS(1), &rsp, scsi_io_cb, NULL) == 0) {
        rc = SCSI_HANDLER_RESP_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }
    return rc;
}

/**
 * @ingroup scsi_api_target
 * @brief Receive a TMF command IO.
 *
 * @par Description
 * Called by the base driver when a SCSI TMF command has been received. The
 * target-server processes the command, aborting commands as needed, and posts
 * a response using ocs_scsi_send_resp().
 * The IO context (ocs_io_t) structure has an element of type ocs_scsi_tgt_io_t, named
 * tgt_io that is declared and used by a target-server for private information.
 * @n @n @b Notes: 
 * -If the target-server walks the nodes active_ios linked list, and starts IO
 * abort processing, the code <i>must not</i> abort the IO passed into the
 * ocs_scsi_recv_tmf() command.
 * - This io_to_abort is guaranteed not to be freed during
 * this function's scope. Since ocs_scsi_tgt_abort_io() takes a
 * reference on the io_to_abort, if ocs_scsi_tgt_abort_io() is
 * called within this function's scope, another reference is not
 * needed. If ocs_scsi_tgt_abort_io() isn't called in this
 * context and the io_to_abort pointer needs to be used beyond
 * this function's scope, use ocs_ref_get() to take another
 * reference.
 *
 * @param tmfio Pointer to the IO context.
 * @param lun Logical unit value.
 * @param cmd Command request.
 * @param io_to_abort Pointer to the IO object to abort for
 * TASK_ABORT (NULL for all other TMF).
 *
 * @param flags Flags.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_scsi_recv_tmf(ocs_io_t *tmfio, uint32_t lun, ocs_scsi_tmf_cmd_e cmd, ocs_io_t *io_to_abort, uint32_t flags)
{
    ocs_node_t *node;
    ocs_t *ocs;
    ocs_sport_t *sport;
    ocs_scsi_tmf_resp_e rspcode = OCS_SCSI_TMF_FUNCTION_COMPLETE;
    int32_t rc;

    ocs_assert(tmfio, -1);
    ocs_assert(tmfio->node, -1);
    ocs_assert(tmfio->ocs, -1);

    node = tmfio->node;
    ocs = tmfio->ocs;
    sport = node->sport;

    tmfio->tgt_io.lun = lun;

    api_trace();

    /* No watermark checks for task management */

    tmfio->tgt_io.ramdisc = ocs_ramd_lookup(tmfio, lun);
    if(tmfio->tgt_io.ramdisc == NULL) {
        io_printf(tmfio, "Invalid lun specified, cmd=%d, lun=%d\n", cmd, lun);
        rc = ocs_scsi_send_tmf_resp(tmfio, OCS_SCSI_TMF_INCORRECT_LOGICAL_UNIT_NUMBER,
                        NULL, scsi_io_cb, NULL);
        if (rc == 0) {
            tmfio->tgt_io.sm.app = tmfio;
            ocs_sm_transition(&tmfio->tgt_io.sm, __ocs_ramd_tmf_wait_resp_cmpl, NULL);
        }
        return rc;
    }

    switch(cmd) {
    case OCS_SCSI_TMF_QUERY_TASK_SET:
    case OCS_SCSI_TMF_CLEAR_ACA:
    case OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT:
        io_printf(tmfio, "unsupported TMF=%d\n", cmd);
        break;

    /*
     * Post ABORT_IO event to the IO, the IO state machine will call ocs_scsi_send_tmf_resp()
     * when complete, so we return now.
     */
    case OCS_SCSI_TMF_ABORT_TASK: {
        /* save the task management IO object in the IO that is being aborted */
        io_printf(tmfio, "abort task: aborting " IOFMT "\n", IOFMT_ARGS(io_to_abort));

        /*
         * Move tmfio to wait for IO abort where response will be sent, then
         * send ABORT event to io_to_abort state machine
         */
        tmfio->tgt_io.sm.app = tmfio;
        ocs_sm_transition(&tmfio->tgt_io.sm, __ocs_ramd_abts_wait_io_abort_resp, NULL);

        /*
         * Taking a reference on io_to_abort is not needed since the ABORT_IO
         * event immediately results in a call to ocs_scsi_tgt_abort_io()
         */
        if (ocs_sm_post_event(&io_to_abort->tgt_io.sm, OCS_EVT_ABORT_IO, tmfio)) {
            ocs_assert(FALSE, -1);
        }
        return 0;
    }

    case OCS_SCSI_TMF_ABORT_TASK_SET: {
        /* Abort all tasks for this node */
        ocs_log_debug(ocs, "[%s] abort_task_set\n", node->display_name);
        ocs_ramd_abort_node_tasks_lun(node, tmfio->tgt_io.lun, tmfio);
        break;
    }
    case OCS_SCSI_TMF_CLEAR_TASK_SET: {
        ocs_node_t *n;
        ocs_node_t *np;

        ocs_log_debug(ocs, "[%s] clear_task_set\n", node->display_name);

        /* Abort all I/Os */
        ocs_sport_lock(sport);
            ocs_list_foreach_safe(&sport->node_list, n, np) {
                ocs_ramd_abort_node_tasks_lun(n, tmfio->tgt_io.lun, tmfio);
            }
        ocs_sport_unlock(sport);
        break;
    }
    case OCS_SCSI_TMF_LOGICAL_UNIT_RESET: {
        ocs_node_t *n;
        ocs_node_t *np;

        ocs_log_debug(ocs, "[%s] logical unit reset, lun x%x\n", node->display_name, tmfio->tgt_io.lun);

        /* Abort all I/Os */
        ocs_sport_lock(sport);
            ocs_list_foreach_safe(&sport->node_list, n, np) {
                ocs_ramd_abort_node_tasks_lun(n, tmfio->tgt_io.lun, tmfio);
            }
        ocs_sport_unlock(sport);

        ocs_ramd_post_ua(ocs, tmfio->tgt_io.ramdisc,
                SCSI_ASC(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED),
                SCSI_ASCQ(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED),
                NULL);
        break;
    }

    case OCS_SCSI_TMF_TARGET_RESET: {
        ocs_node_t *n;
        ocs_node_t *np;
        uint32_t lun;
        uint32_t lun_count;

        /* get lun count */
        if (ocs->tgt_ocs.use_global_ramd) {
            lun_count = ocs->tgt_ocs.rdisc_count;
        } else {
            lun_count = sport->tgt_sport.rdisc_count;
        }

        /* perform lun reset on each LUN */
        ocs_log_debug(ocs, "[%s] target reset: lun count=%d\n",
            node->display_name, lun_count);

        /* abort IOs on all nodes on all LUNs */
        ocs_sport_lock(sport);
            ocs_list_foreach_safe(&sport->node_list, n, np) {
                ocs_ramd_abort_node_tasks(n, tmfio);
            }
        ocs_sport_unlock(sport);

        /* establish UA for all LUNs */
        for (lun = 0; lun < lun_count; lun++) {
            ocs_ramd_post_ua(ocs, tmfio->tgt_io.ramdisc,
                     SCSI_ASC(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED),
                     SCSI_ASCQ(SCSI_ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED),
                     NULL);
        }
        break;
    }

    }

    rc = ocs_scsi_send_tmf_resp(tmfio, rspcode, NULL, scsi_io_cb, NULL);
    if (rc == 0) {
        tmfio->tgt_io.sm.app = tmfio;
        ocs_sm_transition(&tmfio->tgt_io.sm, __ocs_ramd_tmf_wait_resp_cmpl, NULL);
    }
    return rc;
}

/**
 * @brief Response phase callback.
 *
 * @par Description
 * This function is called when the response phase for an IO completes.
 *
 * @param io Pointer to the IO structure.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
_scsi_io_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{
    api_trace();

    ocs_assert(io, -1);

    /* for debugging state machines, send RESP_CMPL event instead of directly freeing */
    ocs_lock(&io->tgt_io.sm_lock);
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_RESP_CMPL, NULL);
    ocs_unlock(&io->tgt_io.sm_lock);

    return 0;
}

/**
 * @brief Command data phase callback
 *
 * @par Description
 * This function is called when the SCSI command data phase has completed.
 *
 * @param io Pointer to the IO structure.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */

int32_t
_scsi_dataphase_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{
    api_trace();

    ocs_assert(io, -1);
    ocs_assert(io->ocs, -1);

    ocs_lock(&io->tgt_io.sm_lock);

#if ENABLE_BUFFER_DUMP==1
#if defined(OCS_INCLUDE_DEBUG)
    /* Dump buffers if enabled for write commands */
    if (io->tgt_io.is_read == FALSE) {
        ocs_t *ocs = io->ocs;
        ocs_ramdisc_sgl_t sgl[64];
        uint32_t max_sgl = (ocs->tgt_ocs.max_sgl < ARRAY_SIZE(sgl) ? ocs->tgt_ocs.max_sgl : ARRAY_SIZE(sgl));
        uint32_t blk_count = io->tgt_io.cur_block_count;
        uint32_t sgl_count;
        uint64_t lba;
        uint32_t sgl_flags = 0;

        if (io->tgt_io.sgl_phys) {
            sgl_flags |= SGL_REQ_FLAGS_PHYS;
        }

        lba = io->tgt_io.io_lba + io->tgt_io.acc_block_count;
        sgl_count = ocs_ramdisc_sgl(ocs, io->tgt_io.ramdisc, sgl, max_sgl, ocs->tgt_ocs.max_sge,
            lba, &blk_count, sgl_flags, TRUE);
    }
#endif
#endif

    switch (scsi_status) {
    case OCS_SCSI_STATUS_GOOD:
    {
        int32_t rc;
        io->tgt_io.acc_block_count += io->tgt_io.cur_block_count;

        if (io->tgt_io.acc_block_count < io->tgt_io.io_block_count) {
            io->tgt_io.dif_info.ref_tag += io->tgt_io.cur_block_count;

            rc = ocs_ramd_data_phase_start(io);
            /* Errors here are not expected.
             * If there is no error, code will fall through to bottom
             */
            if (rc != 0) {
                const char *fn = strrchr(__FILE__, '/'); \
                ocs_log_err(io->ocs, "%s(%d) assertion (rc == 0) failed\n", (fn ? fn + 1 : __FILE__), __LINE__);
                ocs_unlock(&io->tgt_io.sm_lock);
                return rc;
            }
        } else if (flags & OCS_SCSI_IO_CMPL) {
#if ENABLE_DIF_VERIFICATION == 1
            if (!io->tgt_io.is_read) {
                if (ocs_ramdisc_dif_verify(io->ocs, io->tgt_io.ramdisc, io->tgt_io.io_lba,
                    io->tgt_io.io_block_count) != 0) {
                    ocs_log_test(io->ocs, "Write DIF IO at LBA 0x%"
                             PRIx64 " for %d blocks with bad data in RAM\n",
                             io->tgt_io.io_lba, io->tgt_io.io_block_count);
                }
            }
#endif
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_CMPL, NULL);
        }
        else if (flags & OCS_SCSI_IO_CMPL_RSP_SENT) {
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_RESP_CMPL, NULL);
        }
        break;
    }
    default:
        io_printf(io, "dataphase error %d\n", scsi_status);
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_CMPL_ERRORS, &scsi_status);
        break;
    }

    ocs_unlock(&io->tgt_io.sm_lock);
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE (6) command.
 *
 * @par Description
 * The SCSI WRITE (6) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write6(ocs_io_t *io, uint8_t cdb[]) {
    uint64_t lba;
    uint32_t block_count;
    uint8_t wrprotect;

    /* Validate the CDB */
    ocs_assert(cdb[0] == SCSI_WRITE6, -1);

    /* Extract LBA */
    lba =   ((cdb[1] & 0x1f) << 16) |
        (cdb[2] <<  8) |
        (cdb[3] <<  0);

    /* Extract Block Count */
    block_count = cdb[4];

    /* SBC-3 states that a transfer length of 0
     * specifies that 256 logical blocks shall be written.
     */
    if (block_count == 0){
        block_count = 256;
    }

    /* WRITE6 has no way to specify WRPROTECT - and in fact WRITE6
     * is deprecated in SBC-3 so there's really no definition that
     * covers what should be done here.
     * If we have protection enabled we'll set WRPROTECT to 3 which
     * is passthrough with no checking. If protection is not enabled
     * we'll set it to 0.
     */
    if (io->tgt_io.ramdisc->prot_en == 0) {
        wrprotect = 0;
    } else {
        wrprotect = 3;
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_common(io, lba, block_count, wrprotect, INVALID_APP_TAG, lba&0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE (10) command.
 *
 * @par Description
 * The SCSI WRITE (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write10(ocs_io_t *io, uint8_t cdb[]) {
    uint64_t lba;
    uint32_t block_count;
    uint8_t wrprotect;

    ocs_assert((cdb[0] == SCSI_WRITE10) || (cdb[0] == SCSI_WRITE_AND_VERIFY10), -1);

    /* Extract LBA */
    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));

    /* Extract Block Count */
    block_count =
        (cdb[7] << 8) |
        (cdb[8] << 0);

    /* Extract WRPROTECT */
    wrprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (wrprotect != 0)) {
        /* Write10 not supported with prot type 2 and non-zero wrprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_common(io, lba, block_count, wrprotect, INVALID_APP_TAG, lba&0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE (12) command.
 *
 * @par Description
 * The SCSI WRITE (12) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write12(ocs_io_t *io, uint8_t cdb[]) {
    uint64_t lba;
    uint32_t block_count;
    uint8_t wrprotect;

    ocs_assert((cdb[0] == SCSI_WRITE12) || (cdb[0] == SCSI_WRITE_AND_VERIFY12), -1);

    /* Extract LBA */
    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));

    /* Extract Block Count */
    block_count =
        ((uint32_t)(cdb[6] << 24)) |
        ((uint32_t)(cdb[7] << 16)) |
        ((uint32_t)(cdb[8] <<  8)) |
        ((uint32_t)(cdb[9] <<  0));

    /* Extract WRPROTECT */
    wrprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (wrprotect != 0)) {
        /* Write12 not supported with prot type 2 and non-zero wrprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_common(io, lba, block_count, wrprotect, INVALID_APP_TAG, lba&0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE (16) command.
 *
 * @par Description
 * The SCSI WRITE (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write16(ocs_io_t *io, uint8_t cdb[]) {
    uint64_t lba;
    uint32_t block_count;
    uint8_t wrprotect;

    ocs_assert((cdb[0] == SCSI_WRITE16) || (cdb[0] == SCSI_WRITE_AND_VERIFY16), -1);

    /* Extract LBA */
    lba =   ((uint64_t)cdb[2] << 56) |
        ((uint64_t)cdb[3] << 48) |
        ((uint64_t)cdb[4] << 40) |
        ((uint64_t)cdb[5] << 32) |
        ((uint64_t)cdb[6] << 24) |
        ((uint64_t)cdb[7] << 16) |
        ((uint64_t)cdb[8] <<  8) |
        ((uint64_t)cdb[9] <<  0);

    /* Extract Block Count */
    block_count =
        (cdb[10] << 24) |
        (cdb[11] << 16) |
        (cdb[12] <<  8) |
        (cdb[13] <<  0);

    /* Extract WRPROTECT */
    wrprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (wrprotect != 0)) {
        /* Write16 not supported with prot type 2 and non-zero wrprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_common(io, lba, block_count, wrprotect, INVALID_APP_TAG, lba&0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE (32) command.
 *
 * @par Description
 * The SCSI WRITE (32) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write32(ocs_io_t *io, uint8_t cdb[]) {
    uint64_t lba;
    uint32_t block_count;
    uint8_t wrprotect;
    uint32_t ref_tag;
    uint32_t app_tag;

    /* Validate the CDB */
    ocs_assert(cdb[0] == SCSI_VARIABLE_LEN_CDB, -1);
    ocs_assert((cdb[9] == SCSI_VAR_CMD_SVC_ACT_WRITE32) ||
           (cdb[9] == SCSI_VAR_CMD_SVC_ACT_WRITE_VERIFY32), -1);


    /* Extract LBA */
    lba =   ((uint64_t)cdb[12] << 56) |
        ((uint64_t)cdb[13] << 48) |
        ((uint64_t)cdb[14] << 40) |
        ((uint64_t)cdb[15] << 32) |
        ((uint64_t)cdb[16] << 24) |
        ((uint64_t)cdb[17] << 16) |
        ((uint64_t)cdb[18] <<  8) |
        ((uint64_t)cdb[19] <<  0);

    /* Extract Block Count */
    block_count =
        (cdb[28] << 24) |
        (cdb[29] << 16) |
        (cdb[30] <<  8) |
        (cdb[31] <<  0);

    /* Extract WRPROTECT */
    wrprotect = ((cdb[10] & 0xe0) >> 5);

    /* Extract Ref Tag */
    ref_tag =   (cdb[20] << 24) |
            (cdb[21] << 16) |
            (cdb[22] <<  8) |
            (cdb[23] <<  0);

    /* Extract App Tag */
    app_tag =   (cdb[24] <<  8) |
            (cdb[25] <<  0);

    if (io->tgt_io.ramdisc->prot_en == 0) {
        if (wrprotect != 0) {
            /* SBC 4.21.2.2: If type 0 protection is enabled and the wrprotect field is
             * non-zero ...  ILLEGAL REQUEST / INVALID FIELD IN CDB
             */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        } else {
            /* If type 0 protection is enabled and the wrprotect field is set to a zero
             * value ...  ILLEGAL REQUEST / INVALID COMMAND OPERATION CODE
             */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
        }
    }

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type != 2)) {
        /* SBC 4.21.2.3: If type 1 protection is enabled, then the following medium commands
         * are invalid ... ILLEGAL_REQUEST / INVALID_COMMAND_OPERATION_CODE
        */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_common(io, lba, block_count, wrprotect, app_tag, ref_tag);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE LONG (10) command.
 *
 * @par Description
 * The SCSI WRITE LONG (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_long10(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t xfer_len;
    uint8_t cor_dis, wr_uncor, pblock;

    /* Validate the CDB */
    ocs_assert((cdb[0] == SCSI_WRITE_LONG10), -1);

    cor_dis = (cdb[1] >> 7) & 1;
    wr_uncor = (cdb[1] >> 6) & 1;
    pblock = (cdb[1] >> 5) & 1;

    /* Extract LBA */
    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));

    xfer_len =  (cdb[7] <<  8) |
            (cdb[8] <<  0);

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now. unless the wr_uncor is set.
     */
    if ((xfer_len == 0) && (!wr_uncor)) {
        return(ocs_ramd_good_status(io));
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_long_common(io, lba, xfer_len, cor_dis, wr_uncor, pblock);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE LONG (16) command.
 *
 * @par Description
 * The SCSI WRITE LONG (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_long16(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t xfer_len;
    uint8_t cor_dis, wr_uncor, pblock;

    /* Validate the CDB */
    ocs_assert(cdb[0] == SCSI_SERVICE_ACTION_OUT16, -1);
    ocs_assert(((cdb[1] & 0x1F) == SCSI_SVC_ACTION16_READ_LONG), -1);

    cor_dis = (cdb[1] >> 7) & 1;
    wr_uncor = (cdb[1] >> 6) & 1;
    pblock = (cdb[1] >> 5) & 1;

    /* Extract LBA */
    lba =   ((uint64_t)cdb[2] << 56) |
        ((uint64_t)cdb[3] << 48) |
        ((uint64_t)cdb[4] << 40) |
        ((uint64_t)cdb[5] << 32) |
        ((uint64_t)cdb[6] << 24) |
        ((uint64_t)cdb[7] << 16) |
        ((uint64_t)cdb[8] <<  8) |
        ((uint64_t)cdb[9] <<  0);

    xfer_len =  (cdb[12] <<  8) |
            (cdb[13] <<  0);

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now. unless the wr_uncor is set.
     */
    if ((xfer_len == 0) && (!wr_uncor)) {
        return(ocs_ramd_good_status(io));
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_long_common(io, lba, xfer_len, cor_dis, wr_uncor, pblock);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE SAME (10) command.
 *
 * @par Description
 * The SCSI WRITE SAME (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_same10(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t num_blocks;
    uint8_t wrprotect;
    uint8_t pbdata;
    uint8_t lbdata;

    /* Validate the CDB */
    ocs_assert((cdb[0] == SCSI_WRITE_SAME10), -1);

    wrprotect = (cdb[1] & 0xe0) >> 5;
    pbdata = (cdb[1] & 0x04) >> 2;
    lbdata = (cdb[1] & 0x02) >> 1;

    /* Extract LBA */
    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));

    num_blocks =    (cdb[7] <<  8) |
            (cdb[8] <<  0);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (wrprotect != 0)) {
        /* WRITE SAME(10) not supported with prot type 2 and non-zero wrprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_same_common(io, lba, num_blocks, wrprotect, pbdata, lbdata, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE SAME (16) command
 *
 * @par Description
 * The SCSI WRITE SAME (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_same16(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t num_blocks;
    uint8_t wrprotect;
    uint8_t pbdata;
    uint8_t lbdata;

    /* Validate the CDB */
    ocs_assert((cdb[0] == SCSI_WRITE_SAME16), -1);

    wrprotect = (cdb[1] & 0xe0) >> 5;
    pbdata = (cdb[1] & 0x04) >> 2;
    lbdata = (cdb[1] & 0x02) >> 1;

    /* Extract LBA */
    lba =   ((uint64_t)cdb[2] << 56) |
        ((uint64_t)cdb[3] << 48) |
        ((uint64_t)cdb[4] << 40) |
        ((uint64_t)cdb[5] << 32) |
        ((uint64_t)cdb[6] << 24) |
        ((uint64_t)cdb[7] << 16) |
        ((uint64_t)cdb[8] <<  8) |
        ((uint64_t)cdb[9] <<  0);

    num_blocks =    ((uint64_t)cdb[10] << 24) |
            ((uint64_t)cdb[11] << 16) |
            ((uint64_t)cdb[12] <<  8) |
            ((uint64_t)cdb[13] <<  0);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (wrprotect != 0)) {
        /* WRITE SAME(16) not supported with prot type 2 and non-zero wrprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_same_common(io, lba, num_blocks, wrprotect, pbdata, lbdata, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI WRITE SAME (32) command
 *
 * @par Description
 * The SCSI WRITE SAME (32) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_same32(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t num_blocks;
    uint8_t wrprotect;
    uint8_t pbdata;
    uint8_t lbdata;
    uint32_t expected_ref_tag;
    uint16_t expected_app_tag;

    /* Validate the CDB */
    ocs_assert(cdb[0] == SCSI_VARIABLE_LEN_CDB, -1);
    ocs_assert(cdb[9] == SCSI_VAR_CMD_SVC_ACT_WRITE_SAME32, -1);

    wrprotect = (cdb[10] & 0xe0) >> 5;
    pbdata = (cdb[10] & 0x04) >> 2;
    lbdata = (cdb[10] & 0x02) >> 1;

    /* Extract LBA */
    lba =   ((uint64_t)cdb[12] << 56) |
        ((uint64_t)cdb[13] << 48) |
        ((uint64_t)cdb[14] << 40) |
        ((uint64_t)cdb[15] << 32) |
        ((uint64_t)cdb[16] << 24) |
        ((uint64_t)cdb[17] << 16) |
        ((uint64_t)cdb[18] <<  8) |
        ((uint64_t)cdb[19] <<  0);

    expected_ref_tag =  ((uint64_t)cdb[20] << 24) |
                ((uint64_t)cdb[21] << 16) |
                ((uint64_t)cdb[22] <<  8) |
                ((uint64_t)cdb[23] <<  0);

    expected_app_tag =  ((uint64_t)cdb[24] <<  8) |
                ((uint64_t)cdb[25] <<  0);

    num_blocks =    ((uint64_t)cdb[28] << 24) |
            ((uint64_t)cdb[29] << 16) |
            ((uint64_t)cdb[30] <<  8) |
            ((uint64_t)cdb[31] <<  0);

    if (io->tgt_io.ramdisc->prot_en == 0) {
        if (wrprotect != 0) {
            /* SBC 4.21.2.2: If type 0 protection is enabled and the wrprotect field is
             * non-zero ...  ILLEGAL REQUEST / INVALID FIELD IN CDB
             */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        } else {
            /* If type 0 protection is enabled and the wrprotect field is set to a zero
             * value ...  ILLEGAL REQUEST / INVALID COMMAND OPERATION CODE
             */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
        }
    }

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type != 2)) {
        /* SBC 4.21.2.3: If type 1 protection is enabled, then the following medum commands
         * are invalid ... ILLEGAL_REQUEST / INVALID_COMMAND_OPERATION_CODE
         */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    /* Call common function to do the I/O */
    return ocs_ramd_write_same_common(io, lba, num_blocks, wrprotect, pbdata, lbdata,
            expected_app_tag, expected_ref_tag);
}

/**
 * @ingroup scsi_cmd
 * @brief Process first burst data into the IO DMA memory.
 *
 * @param io Pointer to the IO context.
 * @param bytes_left The number of first burst bytes received.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_first_burst_local(ocs_io_t *io, uint32_t bytes_left)
{
    uint32_t offset = 0;
    uint32_t buf_index = 0;
    uint32_t buffer_size;

    while (bytes_left > 0) {
        buffer_size = (bytes_left > io->tgt_io.first_burst_buffers[buf_index].size ?
                   io->tgt_io.first_burst_buffers[buf_index].size : bytes_left);
        /* copy the data to the allocated buffer */
        ocs_memcpy((uint8_t *)io->tgt_io.payload.virt + offset,
               io->tgt_io.first_burst_buffers[buf_index].virt,
               buffer_size);
        buf_index++;
        bytes_left -= buffer_size;
        offset += buffer_size;
    }
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the first burst data without any DIF information.
 *
 * @param io Pointer to the IO context.
 * @param ramdisc Pointer to the ramdisc structure.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_first_burst_no_dif(ocs_io_t *io, ocs_ramdisc_t *ramdisc)
{
    uint32_t blocksize = ramdisc->phys_block_size;
    uint32_t buf_index = 0;
    uint64_t lba = io->tgt_io.io_lba;
    uint32_t bytes_left;

    uint8_t *src;
    uint32_t src_remaining;
    uint8_t *dst;
    uint32_t dst_remaining;
    uint32_t n;

    /*
     * Since the ramdisk does not handle partial data blocks,
     * truncate the immediate data to a block boundary.
     */
    bytes_left = (io->tgt_io.first_burst_bytes - (io->tgt_io.first_burst_bytes % blocksize));

    src = io->tgt_io.first_burst_buffers[buf_index].virt;
    src_remaining = io->tgt_io.first_burst_buffers[buf_index++].size;

#if defined(OCS_INCLUDE_FC)
        if (io->ocs->esoc) {
            uint64_t lba_offset;
            /* adjust for HP offset */
            lba_offset = (lba % 32) * blocksize;
            src += lba_offset;
        }
#endif

    dst = ocs_ramdisc_lba_address(ramdisc, lba++);
    dst_remaining = blocksize;

    while (bytes_left > 0) {

        n = MIN(bytes_left, MIN(dst_remaining, src_remaining));

        ocs_memcpy(dst, src, n);
        src += n;
        src_remaining -= n;
        dst += n;
        dst_remaining -= n;
        bytes_left -= n;

        if (src_remaining == 0) {
            src = io->tgt_io.first_burst_buffers[buf_index].virt;
            src_remaining = io->tgt_io.first_burst_buffers[buf_index++].size;
        }
        if (dst_remaining == 0) {
            dst = ocs_ramdisc_lba_address(ramdisc, lba++);
            dst_remaining = blocksize;
        }
    }

    io->tgt_io.acc_block_count += io->tgt_io.first_burst_bytes / ramdisc->phys_block_size;
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Set the Disable App and reference fields based on the protection type.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc structure.
 * @param dif_info Pointer to the DIF information structure for an IO.
 */
static void
ocs_ramd_set_dif_prot_type_fields(ocs_t *ocs,
                  ocs_ramdisc_t *ramdisc,
                  ocs_scsi_dif_info_t *dif_info)
{
    if (ramdisc->prot_en) {
        if (ocs->ctrlmask & OCS_CTRLMASK_TGT_ALWAYS_VERIFY_DIF) {
            dif_info->disable_app_ffff = 0;
            dif_info->disable_app_ref_ffff = 0;
        } else {
            switch(ramdisc->p_type) {
            case 0:
                dif_info->disable_app_ffff = 0;
                dif_info->disable_app_ref_ffff = 0;
                break;
            case 1:
                dif_info->disable_app_ffff = 1;
                dif_info->disable_app_ref_ffff = 0;
                break;
            case 2:
                dif_info->disable_app_ffff = 1;
                dif_info->disable_app_ref_ffff = 0;
                break;
            case 3:
                dif_info->disable_app_ffff = 0;
                dif_info->disable_app_ref_ffff = 1;
                break;
            default:
                dif_info->disable_app_ffff = 0;
                dif_info->disable_app_ref_ffff = 0;
                break;
            }
        }
    }
}


/**
 * @ingroup scsi_cmd
 * @brief Process the first burst data by adding/verifying/stripping DIF information.
 *
 * @param io Pointer to the IO context.
 * @param ramdisc Pointer to the ramdisc structure.
 * @param data_blk_size Size of the block without any DIF.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_first_burst_with_dif(ocs_io_t *io,
                  ocs_ramdisc_t *ramdisc,
                  uint32_t data_blk_size)
{
    ocs_scsi_dif_info_t *dif_info = &(io->tgt_io.dif_info);
    uint32_t blocksize;
    uint32_t bytes_left;
    uint32_t buf_index = 0;
    uint32_t blk_count = 0;
    uint64_t lba = io->tgt_io.io_lba;
    uint16_t crc;
    dif_t difdata;
    uint16_t recv_crc;
    uint16_t recv_apptag;
    uint32_t recv_reftag;

    uint8_t *src;
    uint32_t src_remaining;
    uint8_t *dst;
    uint32_t dst_remaining;
    uint32_t n;

    if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_DISABLED) {
        blocksize = ramdisc->phys_block_size;
    } else {
        blocksize = ocs_scsi_dif_wire_blocksize(dif_info, !io->tgt_io.is_read);
    }

    /*
     * Since the adapter does not handle partial data blocks and DIF,
     * truncate the immediate data to a block boundary.
     */
    bytes_left = (io->tgt_io.first_burst_bytes -
              (io->tgt_io.first_burst_bytes % blocksize));

    /* Update io->transferred */
    ocs_scsi_update_first_burst_transferred(io, bytes_left);

    /*
     * First copy the data block into the ramdisc while calculating the
     * block guard (CRC). Once the data is copied, we will verify the T10_PI
     * data if required, insert or strip as required. If a mis-compare
     * occurs then this routine will send the appropriate response.
     */
    src = io->tgt_io.first_burst_buffers[buf_index].virt;
    src_remaining = io->tgt_io.first_burst_buffers[buf_index++].size;

#if defined(OCS_INCLUDE_FC)
        if (io->ocs->esoc) {
            uint64_t lba_offset;
            /* adjust for HP offset */
            lba_offset = (lba % 32) * blocksize;
            src += lba_offset;

        }
#endif

    while (bytes_left > 0) {

        dst = ocs_ramdisc_lba_address(ramdisc, lba);
        dst_remaining = data_blk_size;
        crc = 0;

        /* Copy one block */
        while (dst_remaining > 0) {
            n = MIN(bytes_left, MIN(dst_remaining, src_remaining));
            ocs_memcpy(dst, src, n);
            crc = ocs_scsi_dif_calc_crc(dst, n, crc);
            src += n;
            src_remaining -= n;
            dst += n;
            dst_remaining -= n;
            bytes_left -= n;
            if (src_remaining == 0) {
                src = io->tgt_io.first_burst_buffers[buf_index].virt;
                src_remaining = io->tgt_io.first_burst_buffers[buf_index++].size;
            }
        }

        /*
         * If we are verifying or stripping, we have to grab the T10 PI
         * data from the first burst stream.
         */
        if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_PASS_THRU ||
            dif_info->dif_oper == OCS_SCSI_DIF_OPER_STRIP) {
            dst = (uint8_t*) &difdata;
            dst_remaining = sizeof(difdata);
            while (dst_remaining > 0) {
                n = MIN(bytes_left, MIN(dst_remaining, src_remaining));
                ocs_memcpy(dst, src, n);
                src += n;
                src_remaining -= n;
                dst += n;
                dst_remaining -= n;
                bytes_left -= n;
                if (src_remaining == 0) {
                    src = io->tgt_io.first_burst_buffers[buf_index].virt;
                    src_remaining = io->tgt_io.first_burst_buffers[buf_index++].size;
                }
            }

            /* verify the CRC */
            recv_crc = ocs_be16toh(difdata.crc);

            if (dif_info->check_guard && crc != recv_crc) {
                io_printf(io, "%s: miscompare (CRC) received 0x%x but "
                      "expected 0x%x\n",
                      __func__,
                      recv_crc,
                      crc);
                return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, 0x10, 1);
            }

            /* verify the app tag */
            recv_apptag = ocs_be16toh(difdata.app_tag);
            if (dif_info->check_app_tag &&
                dif_info->app_tag != recv_apptag) {
                io_printf(io, "%s: miscompare (app_tag) received 0x%x but "
                      "expected 0x%x\n",
                      __func__,
                      recv_apptag,
                      dif_info->app_tag);
                return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, 0x10, 2);
            }

            /* verify the ref tag */
            recv_reftag = ocs_be32toh(difdata.ref_tag);
            if (dif_info->check_ref_tag &&
                dif_info->ref_tag + blk_count != recv_reftag) {
                io_printf(io, "%s: miscompare (ref_tag) received 0x%x but "
                      "expected 0x%x\n",
                      __func__,
                      recv_reftag,
                      dif_info->ref_tag + blk_count);
                ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, 0x10, 3);
                return -1;
            }
        }

        /* build the T10 PI data for the insert case */
        if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_INSERT) {
            uint32_t blkCount = dif_info->ref_tag + blk_count;

            difdata.crc = ocs_htobe16(crc);
            difdata.app_tag = ocs_htobe16(dif_info->app_tag);
            difdata.ref_tag = ocs_htobe32(blkCount);
        }

        /* Copy the DIF data to the ramdisc */
        if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_PASS_THRU ||
            dif_info->dif_oper == OCS_SCSI_DIF_OPER_INSERT) {
            dif_t *dif = ocs_ramdisc_dif_address(ramdisc, lba);

            if (dif != NULL) {
                ocs_memcpy(dif, &difdata, sizeof(*dif));
            }
        }
        blk_count++;
        lba++;
    }
    io->tgt_io.acc_block_count = blk_count;
    return 0;
}
static ocs_ramd_hndlr_rtn_e
ocs_ramd_init_write_dif(ocs_io_t *io, ocs_scsi_dif_info_t *dif_info, uint8_t wrprotect, uint32_t app_tag, uint32_t ref_tag)
{
    int32_t rc;
    int app_tag_valid = app_tag != INVALID_APP_TAG;

    if (io->tgt_io.ramdisc->prot_en) {
        rc = ocs_scsi_dif_set_blocksize(dif_info, io->tgt_io.ramdisc->data_block_size);
        /* This should never happen, consider it more of an assertion */
        if (rc) {
            ocs_log_err(io->ocs, "Unsupported write DIF block size: %d\n",
                    io->tgt_io.ramdisc->data_block_size);
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
    }

    dif_info->ref_tag = ref_tag;

    /* SBC3 Table 101, note h:
     *
     * For wrprotect = 0
     * If the ATO bit is set to one in the Control mode page (see @e SPC-4)
     * then the device server shall write FFFFh into each LOGICAL BLOCK
     * APPLICATION TAG field.
     *
     * This only applies to WRPROTECT 0, but that's handled later in
     * ocs_scsi_convert_dif_info because it only uses this app_tag
     * if we're doing an INSERT operation.
     */

    dif_info->app_tag = (app_tag_valid ? app_tag : (wrprotect == 0 ? 0xffff : RAMD_APP_TAG));
    dif_info->dif_separate = io->tgt_io.ramdisc->dif_separate;

    /* Set the AT and ATRT bits */
    ocs_ramd_set_dif_prot_type_fields(io->ocs, io->tgt_io.ramdisc, dif_info);

    /* Set DIF parameters based on wrprotect
     * SBC says that if RWWP in Mode Page 0a is 0 (which it is) then we MAY
     * check the application tag.  Further, except for a WRITE32, we would check
     * the application tag against a list tags specified on mode page 0a subpage 02,
     * the APPLICATION TAG MODE PAGE.  Since we don't yet support that mode page the
     * code currently chooses not to check the app tag except on WRITE32 where the
     * expected tag is in the CDB.  A future enhancement might be to implement that
     * mode page and enable checking here.
     */

    switch (wrprotect) {
    case 0:
        /* If protection is enabled insert DIF info */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 0;
            dif_info->check_ref_tag = 0;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_INSERT;
        } else {
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_DISABLED;
        }

        break;
    case 1:
        /* If protection is enabled check all guard and ref */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;

    case 2:
        /* If protection is enabled check only ref */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 0;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 3:
        /* If protection is enabled don't check any fields */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 0;
            dif_info->check_ref_tag = 0;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 4:
        /* If protection is enabled check only the guard field */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 0;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 5:
        /* If protection is enabled check guard and ref */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    default:
        /* Unsupported
         * Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB
         */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Common code for all SCSI WRITE commands.
 *
 * @par Description
 * The SCSI WRITE command is processed.
 *
 * @param io Pointer to the IO context.
 * @param lba Starting LBA for the transfer.
 * @param block_count Number of blocks to transfer.
 * @param wrprotect Value of the WRPROTECT field in the CDB.
 * @param ref_tag Value of the REFERENCE TAG to write for the first block.
 * @param app_tag Value of the APPLICATION TAG to write.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_common(ocs_io_t *io, uint64_t lba, uint32_t block_count, uint8_t wrprotect,
              uint32_t app_tag, uint32_t ref_tag)
{
    ocs_ramd_hndlr_rtn_e rc;
//TODO: use scsi property "max number of SGE's per SGL"
    ocs_scsi_dif_info_t *dif_info;

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now.
     */
    if (block_count == 0) {
        return ocs_ramd_good_status(io);
    } else if (io->exp_xfer_len == 0) {
        /* mis-match between the FCP_DL and Block count in scsi CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CMDIU, 0);
    }

    dif_info = &(io->tgt_io.dif_info);

    /* If protection type is 0 (ramdisc->prot_en == 0) then wrprotect must
     * be 0.  Non-zero rdprotect should return INVALID FIELD IN CDB
     */
    if ((io->tgt_io.ramdisc->prot_en == 0) && (wrprotect != 0)) {
        /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* to put in the disk block, which is the ramdisc block_size */
    io->tgt_io.is_read = FALSE;
    io->tgt_io.io_lba = lba;
    io->tgt_io.io_block_count = block_count;
    io->tgt_io.acc_block_count = 0;
    io->tgt_io.cur_lba = 0;
    io->tgt_io.cur_block_count = 0;

    cmd_trace(io, "lba x%" PRIx64 " count x%x\n", lba, block_count);

    ocs_memset((void *)dif_info, 0, sizeof(ocs_scsi_dif_info_t));

    if ((rc = ocs_ramd_init_write_dif(io, dif_info, wrprotect, app_tag, ref_tag))) {
        return rc;
    }
    /* save LBA for DIF error recovery */
    dif_info->lba = lba;

    /* Process the first burst data */
    if (io->tgt_io.first_burst_bytes) {
        if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_DISABLED) {
            rc = ocs_ramd_first_burst_no_dif(io, io->tgt_io.ramdisc);
        } else {
            rc = ocs_ramd_first_burst_with_dif(io, io->tgt_io.ramdisc, io->tgt_io.ramdisc->data_block_size);
        }

        if (rc != 0) {
            return SCSI_HANDLER_NOT_STARTED;
        }

        /* Check to see if the IO is complete */
        if (io->tgt_io.acc_block_count == io->tgt_io.io_block_count) {
            return ocs_ramd_good_status(io);
        }
    }

    if (ocs_ramd_data_phase_start(io) == 0) {
        rc = SCSI_HANDLER_DATAPHASE_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }

    return rc;
}

/**
 * @ingroup scsi_cmd
 * @brief Common code for all SCSI WRITE LONG commands.
 *
 * @par Description
 * The SCSI WRITE LONG command is processed.
 *
 * @param io Pointer to the IO context.
 * @param lba Starting LBA for the transfer.
 * @param xfer_len Transfer length, in bytes.
 * @param cor_dis Correction disabled bit from the CDB.
 * @param wr_uncor Write uncorrectable bit from the CDB.
 * @param pblock Physical block bit from the CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_long_common(ocs_io_t *io, uint64_t lba, uint16_t xfer_len,
               uint8_t cor_dis, uint8_t wr_uncor, uint8_t pblock)
{
    ocs_ramd_hndlr_rtn_e rc;
    ocs_scsi_dif_info_t *dif_info;

    if (pblock == 1) {
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    if (wr_uncor == 1 || cor_dis == 1) {
        /* just send response */
        return ocs_ramd_good_status(io);
    }

    /* to put in the disk block, which is the ramdisc block_size */
    io->tgt_io.is_read = FALSE;
    io->tgt_io.io_lba = lba;
    io->tgt_io.io_block_count = xfer_len / io->tgt_io.ramdisc->data_block_size;

    cmd_trace(io, "lba x%" PRIx64 "\n", lba);

    dif_info = &(io->tgt_io.dif_info);
    memset((void *)dif_info, 0, sizeof(ocs_scsi_dif_info_t));
    dif_info->dif_oper = OCS_SCSI_DIF_OPER_DISABLED;

    /* Process the first burst data */
    if (io->tgt_io.first_burst_bytes) {
        if (ocs_ramd_first_burst_no_dif(io, io->tgt_io.ramdisc) != 0) {
            return SCSI_HANDLER_NOT_STARTED;
        }

        /* Check to see if the IO is complete */
        if (io->tgt_io.acc_block_count == io->tgt_io.io_block_count) {
            return ocs_ramd_good_status(io);
        }
    }

    io->tgt_io.sgl_phys = 1;

    if (ocs_ramd_data_phase_start(io) == 0) {
        rc = SCSI_HANDLER_DATAPHASE_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }

    return rc;
}


/**
 * @ingroup scsi_cmd
 * @brief Common code for all SCSI WRITE SAME commands.
 *
 * @par Description
 * The SCSI WRITE SAME command is processed.
 *
 * @param io Pointer to the IO context.
 * @param lba Starting LBA for the transfer.
 * @param block_count Number of blocks to be written to the media.
 * @param wrprotect WRPROTECT value from the CDB.
 * @param pbdata PBDATA bit from the CDB.
 * @param lbdata LBDATA bit from the CDB.
 * @param ref_tag Value of the REFERENCE TAG to write for the first block.
 * @param app_tag Value of the APPLICATION TAG to write.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_write_same_common(ocs_io_t *io, uint64_t lba, uint32_t block_count,
               uint8_t wrprotect, uint8_t pbdata, uint8_t lbdata,
               uint32_t app_tag, uint32_t ref_tag)
{
    ocs_ramd_hndlr_rtn_e rc;
    ocs_scsi_dif_info_t *dif_info;

    api_trace();

    /* If protection type is 0 (ramdisc->prot_en == 0) then wrprotect must
     * be 0.  Non-zero rdprotect should return INVALID FIELD IN CDB
     */
    if ((io->tgt_io.ramdisc->prot_en == 0) && (wrprotect != 0)) {
        /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* Save wrprotect, pbdata, lbdata, and block_count in the io.  We'll need them later */
    io->tgt_io.wrprotect = wrprotect;
    io->tgt_io.pbdata = pbdata;
    io->tgt_io.lbdata = lbdata;
    io->tgt_io.num_blocks = block_count;

    /* Validate the CDB parameters */
    if ((pbdata == 1) && (lbdata == 1)) {
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* Make sure lba plus block_count doesn't fall off the end of the disk */
    if ((lba + block_count) > io->tgt_io.ramdisc->block_count) {
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_LBA_OOR, 0);
    }
//TODO: use normal write path(factoring is needed)

    /* The following is similar to (and copied from) ocs_ramd_write_common.
     * The difference is that we want to do a single block of I/O regardless
     * of the block count.  Then after that block of I/O has completed we'll
     * copy the data, possibly with modifications, into other blocks.
     */

    dif_info = &(io->tgt_io.dif_info);

    /* Change block_count to 1.  From here on down block_count is the number of blocks on the wire */
    block_count = 1;

    /* to put in the disk block, which is the ramdisc block_size */
    io->tgt_io.is_read = FALSE;
    io->tgt_io.io_lba = lba;
    io->tgt_io.io_block_count = block_count;

    cmd_trace(io, "lba x%" PRIx64 " count x%x\n", lba, block_count);

    memset((void *)dif_info, 0, sizeof(ocs_scsi_dif_info_t));

    if ((rc = ocs_ramd_init_write_dif(io, dif_info, wrprotect, app_tag, ref_tag))) {
        return rc;
    }

    /* Process the first burst data */
    if (io->tgt_io.first_burst_bytes) {
        if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_DISABLED) {
            rc = ocs_ramd_first_burst_no_dif(io, io->tgt_io.ramdisc);
        } else {
            rc = ocs_ramd_first_burst_with_dif(io, io->tgt_io.ramdisc, io->tgt_io.ramdisc->data_block_size);
        }

        if (rc != 0) {
            return SCSI_HANDLER_NOT_STARTED;
        }

        /* Check to see if the IO is complete */
        if (io->tgt_io.acc_block_count == io->tgt_io.io_block_count) {
            return ocs_ramd_complete_write_same(io);
        }
    }

    /* We don't want auto response because we need time to process the
     * command after the data phase completes.
     */
    io->tgt_io.supress_auto_response = 1;

    if (ocs_ramd_data_phase_start(io) == 0) {
        rc = SCSI_HANDLER_WRITE_SAME_DATAPHASE_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }



    return rc;
}

/**
 * @ingroup scsi_cmd
 * @brief Command completion for the SCSI WRITE SAME command.
 *
 * @par Description
 * This function is called when the data phase for the WRITE SAME command has
 * completed. At this point, a single block has been transfered to the target
 * and written to the ramdisc. The remaining actions involve copying that
 * block, possibly with modifications, to other blocks on the ramdisc.<br><br>
 * @b Note: This function must call either ocs_ramd_check_cond or ocs_ramd_status_good.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns SCSI_HANDLER_NOT_STARTED if an error occurs, or
 * SCSI_HANDLER_RESP_STARTED if a response (either STATUS GOOD or
 * CHECK CONDITION) has been sent.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_complete_write_same(ocs_io_t *io)
{
    uint64_t start_lba = io->tgt_io.io_lba;
    uint32_t block_count = io->tgt_io.num_blocks;
    uint32_t i;
    uint8_t *src;
    uint8_t *dest;
    uint32_t ref_tag;
    uint64_t phys_addr;
    dif_t *src_dif;
    dif_t *dst_dif;

    api_trace();

    /* If the block count is zero that means "the rest of the disc" */
    if (block_count == 0) {
        block_count = io->tgt_io.ramdisc->block_count - start_lba;
    }

    src = ocs_ramdisc_lba_address(io->tgt_io.ramdisc, start_lba);

    /* Handle the three possible values for pbdata and lbdata (they can't both be 1) */
    if ((io->tgt_io.lbdata == 0) && (io->tgt_io.pbdata == 0)) {
        if (io->tgt_io.ramdisc->prot_en == 0) {
            /* Protection type is 0.  Just copy the one block to all the others */
            for (i=1; i<block_count; i++) {
                dest = ocs_ramdisc_lba_address(io->tgt_io.ramdisc, start_lba + i);
                ocs_memcpy(dest, src, io->tgt_io.ramdisc->phys_block_size);
            }
        } else {
            src_dif = ocs_ramdisc_dif_address(io->tgt_io.ramdisc, start_lba);
            ref_tag = ocs_be32toh(src_dif->ref_tag);
            src_dif->crc = ocs_htobe16(ocs_scsi_dif_calc_crc(src, io->tgt_io.ramdisc->data_block_size, 0));

            /* Start with block 1 */
            for (i=1; i<block_count; i++) {
                dest = ocs_ramdisc_lba_address(io->tgt_io.ramdisc, start_lba + i);
                ocs_memcpy(dest, src, io->tgt_io.ramdisc->phys_block_size);

                dst_dif = ocs_ramdisc_dif_address(io->tgt_io.ramdisc, start_lba + i);

                dst_dif->crc = src_dif->crc;
                dst_dif->app_tag = src_dif->app_tag;
                dst_dif->ref_tag = ocs_htobe32(ref_tag + i);
            }
        }

    } else if ((io->tgt_io.lbdata == 0) && (io->tgt_io.pbdata == 1)) {
        /* Copy the block to all the others, replacing the first 8
         * bytes of each block with the physical sector address.
         * Since we don't have cylinders, heads, and sectors this
         * will be the same as the LBA
         */
        for (i=0; i<block_count; i++) {
            dest = ocs_ramdisc_lba_address(io->tgt_io.ramdisc, start_lba + i);
            ocs_memcpy(dest, src, io->tgt_io.ramdisc->phys_block_size);
            phys_addr = ocs_htobe64(start_lba + i);
            ocs_memcpy(dest, &phys_addr, 8);
        }

    } else if ((io->tgt_io.lbdata == 1) && (io->tgt_io.pbdata == 0)) {
        /* Copy the block to all the others, replacing the first 4 bytes
         * with the LBA of the block
         */
        for (i=0; i<block_count; i++) {
            dest = ocs_ramdisc_lba_address(io->tgt_io.ramdisc, start_lba + i);
            ocs_memcpy(dest, src, io->tgt_io.ramdisc->phys_block_size);
            ref_tag = ocs_htobe32(start_lba + i);
            ocs_memcpy(dest, &ref_tag, 4);
        }

    } else {
        ocs_assert(0, SCSI_HANDLER_NOT_STARTED);
    }


    return ocs_ramd_good_status(io);

}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ (6) command.
 *
 * @par Description
 * The SCSI READ (6) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read6(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint32_t block_count;
    uint8_t rdprotect;

    ocs_assert(cdb[0] == SCSI_READ6, -1);

    lba =   ((cdb[1] & 0x1f) << 16) |
        (cdb[2] <<  8) |
        (cdb[3] <<  0);
    block_count = cdb[4];

    /* SBC-3 states that a transfer length of 0
     * specifies that 256 logical blocks shall be read.
     */
    if (block_count == 0){
        block_count = 256;
    }


    /* BZ 208104: As per SBC-3 rev 22, Table 50, the protection information is never
     * transmitted on the wire, hence always set rdprotect to 0 . The following revisions 
     * of SBC-3 completed deprecated this command.
     */
    rdprotect = 0;

    return ocs_ramd_read_common(io, lba, block_count, rdprotect, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ (10) command.
 *
 * @par Description
 * The SCSI READ (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read10(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint32_t block_count;
    uint8_t rdprotect;

    ocs_assert(cdb[0] == SCSI_READ10, -1);

    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));
    block_count =
        (cdb[7] << 8) |
        (cdb[8] << 0);
    rdprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (rdprotect != 0)) {
        /* Read10 not supported with prot type 2 and non-zero rdprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    return ocs_ramd_read_common(io, lba, block_count, rdprotect, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ (12) command.
 *
 * @par Description
 * The SCSI READ (12) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read12(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint32_t block_count;
    uint8_t rdprotect;

    ocs_assert(cdb[0] == SCSI_READ12, -1);

    lba =   (cdb[2] << 24) |
        (cdb[3] << 16) |
        (cdb[4] <<  8) |
        (cdb[5] <<  0);
    block_count =   ((uint32_t)(cdb[6] << 24)) |
            ((uint32_t)(cdb[7] << 16)) |
            ((uint32_t)(cdb[8] <<  8)) |
            ((uint32_t)(cdb[9] <<  0));
    rdprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (rdprotect != 0)) {
        /* Read12 not supported with prot type 2 and non-zero rdprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    return ocs_ramd_read_common(io, lba, block_count, rdprotect, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ (16) command.
 *
 * @par Description
 * The SCSI READ (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */

static ocs_ramd_hndlr_rtn_e ocs_ramd_read16(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint32_t block_count;
    uint8_t rdprotect;

    ocs_assert(cdb[0] == SCSI_READ16, -1);

    lba =   ((uint64_t)cdb[2] << 56) |
        ((uint64_t)cdb[3] << 48) |
        ((uint64_t)cdb[4] << 40) |
        ((uint64_t)cdb[5] << 32) |
        ((uint64_t)cdb[6] << 24) |
        ((uint64_t)cdb[7] << 16) |
        ((uint64_t)cdb[8] <<  8) |
        ((uint64_t)cdb[9] <<  0);
    block_count =   (cdb[10] << 24) |
            (cdb[11] << 16) |
            (cdb[12] <<  8) |
            (cdb[13] <<  0);
    rdprotect = ((cdb[1] & 0xe0) >> 5);

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type == 2) && (rdprotect != 0)) {
        /* Read16 not supported with prot type 2 and non-zero rdprotect */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    return ocs_ramd_read_common(io, lba, block_count, rdprotect, INVALID_APP_TAG, lba & 0xffffffff);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ (32) command.
 *
 * @par Description
 * The SCSI READ (32) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read32(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint32_t block_count;
    uint8_t rdprotect;
    uint32_t ref_tag;
    uint32_t app_tag;

    ocs_assert(cdb[0] == SCSI_VARIABLE_LEN_CDB, -1);
    ocs_assert(cdb[9] == SCSI_VAR_CMD_SVC_ACT_READ32, -1);

    lba =   ((uint64_t)cdb[12] << 56) |
        ((uint64_t)cdb[13] << 48) |
        ((uint64_t)cdb[14] << 40) |
        ((uint64_t)cdb[15] << 32) |
        ((uint64_t)cdb[16] << 24) |
        ((uint64_t)cdb[17] << 16) |
        ((uint64_t)cdb[18] <<  8) |
        ((uint64_t)cdb[19] <<  0);
    block_count =   (cdb[28] << 24) |
            (cdb[29] << 16) |
            (cdb[30] <<  8) |
            (cdb[31] <<  0);
    rdprotect = ((cdb[10] & 0xe0) >> 5);
    ref_tag =   (cdb[20] << 24) |
            (cdb[21] << 16) |
            (cdb[22] <<  8) |
            (cdb[23] <<  0);
    app_tag =   (cdb[24] <<  8) |
            (cdb[25] <<  0);

    if (io->tgt_io.ramdisc->prot_en == 0) {
        if (rdprotect != 0) {
            /* SBC 4.21.2.2: If type 0 protection is enabled and the rdprotect field is */
            /* non-zero ...  ILLEGAL REQUEST / INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        } else {
            /* If type 0 protection is enabled and the rdprotect field is set to a zero
             * value ...  ILLEGAL REQUEST / INVALID COMMAND OPERATION CODE
             */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
        }
    }

    if ((io->tgt_io.ramdisc->prot_en == 1) && (io->tgt_io.ramdisc->p_type != 2)) {
        /* SBC 4.21.2.3: If type 1 protection is enabled, then the following medum commands
         * are invalid ... ILLEGAL_REQUEST / INVALID_COMMAND_OPERATION_CODE
        */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_BAD_CMD, 0);
    }

    return ocs_ramd_read_common(io, lba, block_count, rdprotect, app_tag, ref_tag);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ LONG (10) command.
 *
 * @par Description
 * The SCSI READ LONG (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_long10(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t xfer_len;
    uint8_t pblock, corrct;

    ocs_assert(cdb[0] == SCSI_READ_LONG10, -1);

    pblock = (cdb[1] >> 2) & 1;
    corrct = (cdb[1] >> 1) & 1;

    lba =   ((uint32_t)(cdb[2] << 24)) |
        ((uint32_t)(cdb[3] << 16)) |
        ((uint32_t)(cdb[4] <<  8)) |
        ((uint32_t)(cdb[5] <<  0));

    xfer_len =
        (cdb[7] << 8) |
        (cdb[8] << 0);

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now.
     */
    if (xfer_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    return ocs_ramd_read_long_common(io, lba, xfer_len, pblock, corrct);
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ LONG (16) command.
 *
 * @par Description
 * The SCSI READ LONG (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_long16(ocs_io_t *io, uint8_t cdb[])
{
    uint64_t lba;
    uint16_t xfer_len;
    uint8_t pblock, corrct;

    ocs_assert(cdb[0] == SCSI_SERVICE_ACTION_IN16, -1);
    ocs_assert(((cdb[1] & 0x1F) == SCSI_SVC_ACTION16_READ_LONG), -1);

    lba =   ((uint64_t)cdb[2] << 56) |
        ((uint64_t)cdb[3] << 48) |
        ((uint64_t)cdb[4] << 40) |
        ((uint64_t)cdb[5] << 32) |
        ((uint64_t)cdb[6] << 24) |
        ((uint64_t)cdb[7] << 16) |
        ((uint64_t)cdb[8] <<  8) |
        ((uint64_t)cdb[9] <<  0);

    xfer_len =
        (cdb[12] << 8) |
        (cdb[13] << 0);

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now.
     */
    if (xfer_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    pblock = (cdb[14] >> 1) & 1;
    corrct = cdb[14] & 1;

    return ocs_ramd_read_long_common(io, lba, xfer_len, pblock, corrct);
}

/**
 * @ingroup scsi_cmd
 * @brief Common code to start a SCSI data phase once the IO has been set up.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_data_phase_start(ocs_io_t *io)
{
    ocs_t *ocs = io->ocs;
    uint32_t blocksize;
    ocs_scsi_dif_info_t *dif_info = &io->tgt_io.dif_info;
    uint32_t rc;
    uint64_t lba;
    uint32_t max_sgl;
    uint32_t flags = 0;
    uint32_t sgl_flags = 0;
    uint64_t xfer_len;
    int sgl_status;

    max_sgl = MIN(ocs->tgt_ocs.max_sgl, io->sgl_allocated);

    if (dif_info->dif_oper == OCS_SCSI_DIF_OPER_DISABLED) {
        dif_info = NULL;
        blocksize = io->tgt_io.ramdisc->phys_block_size;
    } else {
        blocksize = ocs_scsi_dif_wire_blocksize(dif_info, !io->tgt_io.is_read);
    }

    if (io->tgt_io.sgl_phys) {
        sgl_flags |= SGL_REQ_FLAGS_PHYS;
    }

    lba = io->tgt_io.io_lba + io->tgt_io.acc_block_count;

    /*
     * Calculate the remaining blocks in the IO. This is passed to the SGL
     * building function to indicate how many blocks are requested.
     *
     * We need to adjust the value to not exceed the max transfer size
     * requested by the transport for this node.
     */
    io->tgt_io.cur_block_count = io->tgt_io.io_block_count - io->tgt_io.acc_block_count;
    if (!io->tgt_io.is_read &&
        (io->tgt_io.cur_block_count * blocksize) > io->node->max_wr_xfer_size) {
        io->tgt_io.cur_block_count = io->node->max_wr_xfer_size / blocksize;
    }

    /* build an SGL */
    sgl_status = ocs_ramdisc_sgl(io->ocs, io->tgt_io.ramdisc, (ocs_ramdisc_sgl_t*) io->sgl, max_sgl,
                     ocs->tgt_ocs.max_sge,
        lba, &io->tgt_io.cur_block_count, sgl_flags, ENABLE_BUFFER_DUMP);
    if (sgl_status < 0) {
        ocs_log_err(io->ocs, "Failed building SGLs\n");
        return sgl_status;
    }
    io->sgl_count = sgl_status;

    if (dif_info != NULL) {
        /*
         * Note: This calculation assumes that the values returned by
         *       ocs_ramdisc_sgl() are block aligned.
         */
//TODO: need something here
    }

    if (ocs->err_injection != INJECT_DROP_RESP &&
        (io->tgt_io.io_block_count == (io->tgt_io.acc_block_count + io->tgt_io.cur_block_count))) {
        flags |= OCS_SCSI_LAST_DATAPHASE;
    }

    if (io->tgt_io.supress_auto_response) {
        flags |= OCS_SCSI_NO_AUTO_RESPONSE;
    }

    xfer_len = (io->tgt_io.cur_block_count * (uint64_t)blocksize);

    if (io->tgt_io.is_read) {
#if ENABLE_DIF_VERIFICATION == 1
        if (ocs_ramdisc_dif_verify(ocs, io->tgt_io.ramdisc, lba, io->tgt_io.cur_block_count) != 0) {
            ocs_log_test(io->ocs, "Read DIF IO at LBA 0x%" PRIx64
                     " for %d blocks with bad data in RAM\n",
                     lba, io->tgt_io.cur_block_count);
        }
#endif
        rc = ocs_scsi_send_rd_data(io, flags, dif_info, io->sgl, io->sgl_count,
            xfer_len, scsi_dataphase_cb, NULL);
    } else {
        rc = ocs_scsi_recv_wr_data(io, flags, dif_info, io->sgl, io->sgl_count,
            xfer_len, scsi_dataphase_cb, NULL);
    }

    return rc;
}

/**
 * @ingroup scsi_cmd
 * @brief Common code used for all SCSI READ commands.
 *
 * @par Description
 * The SCSI READ command is processed.
 *
 * @param io Pointer to the IO context.
 * @param lba Starting LBA for the transfer.
 * @param block_count Number of blocks to transfer.
 * @param rdprotect Value of the RDPROTECT field in the CDB.
 * @param app_tag Value of the APPLICATION TAG to expect.
 * @param ref_tag Value of the REFERENCE TAG to expect for the first block.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_common(ocs_io_t *io, uint64_t lba, uint32_t block_count, uint8_t rdprotect,
             uint32_t app_tag, uint32_t ref_tag)
{
    int32_t rc;
    ocs_scsi_dif_info_t *dif_info;
    int app_tag_valid = (app_tag != INVALID_APP_TAG);

    /* As per SBC-3 a transfer length of 0 means no data transfer
     * so just return good status now.
     */
    if (block_count == 0) {
        return(ocs_ramd_good_status(io));
    } else if (io->exp_xfer_len == 0) {
        /* mis-match between the FCP_DL and Block count in scsi CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CMDIU, 0);
    }

    dif_info = &(io->tgt_io.dif_info);

    /* If protection type is 0 (ramdisc->prot_en == 0) then rdprotect must
     * be 0.  Non-zero rdprotect should return INVALID FIELD IN CDB
     */
    if ((io->tgt_io.ramdisc->prot_en == 0) && (rdprotect != 0)) {
        /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    io->tgt_io.io_lba = lba;
    io->tgt_io.io_block_count = block_count;
    io->tgt_io.acc_block_count = 0;
    io->tgt_io.cur_lba = 0;
    io->tgt_io.cur_block_count = 0;

    io->tgt_io.is_read = TRUE;

    cmd_trace(io, "lba x%" PRIx64 " count x%x io_len x%x\n", lba, block_count,
        io->tgt_io.io_block_count * io->tgt_io.ramdisc->phys_block_size);

    ocs_memset(dif_info, 0, sizeof(ocs_scsi_dif_info_t));

    dif_info->ref_tag = ref_tag;
    dif_info->app_tag = (app_tag == INVALID_APP_TAG) ? RAMD_APP_TAG : app_tag;

    dif_info->dif_separate = io->tgt_io.ramdisc->dif_separate;

    /* Set the AT and ATRT bits */
    ocs_ramd_set_dif_prot_type_fields(io->ocs, io->tgt_io.ramdisc, dif_info);

    /* save LBA for DIF error recovery */
    dif_info->lba = lba;

    /* Unsupported DIF blocksize */
    rc = ocs_scsi_dif_set_blocksize(dif_info, io->tgt_io.ramdisc->data_block_size);
    if (rc) {
        ocs_log_test(io->ocs, "Unsupported DIF read block size: %d\n",
                 io->tgt_io.ramdisc->data_block_size);
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    switch (rdprotect) {
    case 0:
        /* If protection is enabled check all three fields, strip the PI info */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = app_tag_valid;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_STRIP;
        } else {
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_DISABLED;
        }

        break;
    case 1:
    case 5:
        /* Codes 001b and 101b are identical on read
         * If protection is enabled check all three fields, don't strip
         */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = app_tag_valid;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 2:
        /* If protection is enabled check only app and ref, don't strip */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = app_tag_valid;
            dif_info->check_guard = 0;
            dif_info->check_ref_tag = 1;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 3:
        /* If protection is enabled don't check any fields, don't strip */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 0;
            dif_info->check_ref_tag = 0;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    case 4:
        /* If protection is enabled check only the guard field, don't strip */
        if (io->tgt_io.ramdisc->prot_en) {
            dif_info->check_app_tag = 0;
            dif_info->check_guard = 1;
            dif_info->check_ref_tag = 0;
            dif_info->dif_oper = OCS_SCSI_DIF_OPER_PASS_THRU;
        } else {
            /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }
        break;
    default:
        /* Unsupported */
        /* Check condition, ILLEGAL REQUEST, INVALID FIELD IN CDB */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    rc = ocs_ramd_data_phase_start(io);
    if (rc == -1) {
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_LBA_OOR, 0);
    }

    if (rc == 0) {
        return SCSI_HANDLER_DATAPHASE_STARTED;
    }

    return SCSI_HANDLER_NOT_STARTED;
}

/**
 * @ingroup scsi_cmd
 * @brief Common code used for all SCSI READ commands.
 *
 * @par Description
 * The SCSI READ command is processed.
 *
 * @param io Pointer to the IO context.
 * @param lba Starting LBA for the transfer.
 * @param xfer_len Transfer length, in bytes.
 * @param pblock Physical block bit from the CDB.
 * @param corrct Correction bit from the CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_long_common(ocs_io_t *io, uint64_t lba, uint16_t xfer_len, uint8_t pblock, uint8_t corrct)
{
    int32_t rc;
    ocs_scsi_dif_info_t *dif_info;

    io->tgt_io.is_read = TRUE;
    io->tgt_io.io_lba = lba;
    io->tgt_io.io_block_count = xfer_len / io->tgt_io.ramdisc->phys_block_size;

    cmd_trace(io, "lba x%" PRIx64 " io_len x%x\n", lba, io->tgt_io.io_block_count *
          io->tgt_io.ramdisc->phys_block_size);

    dif_info = &(io->tgt_io.dif_info);
    ocs_memset((void *)dif_info, 0, sizeof(ocs_scsi_dif_info_t));
    dif_info->dif_oper = OCS_SCSI_DIF_OPER_DISABLED;

    io->tgt_io.sgl_phys = 1;

    rc = ocs_ramd_data_phase_start(io);
    if (rc == -1) {
        /* Attempt to access off the end of the device */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_LBA_OOR, 0);
    }

    if (rc == 0) {
        return SCSI_HANDLER_DATAPHASE_STARTED;
    }

    return SCSI_HANDLER_NOT_STARTED;
}

/**
 * @ingroup scsi_cmd
 * @brief Validate a FORMAT UNIT parameter list.
 *
 * @par Description
 * Called after a FORMAT UNIT data out phase has completed. This function
 * validates the contents of the parameter list. If the parameter list is
 * valid, the function takes the appropriate action and returns 0. If the parameter
 * list is not valid, the function returns a sense key, code, and qualifier to be returned
 * to the initiator in a CHECK CONDITION.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns 0 for success; or a non-zero sense key, code, and qualifier for failure.
 */

static uint32_t
scsi_validate_format_unit(ocs_io_t *io) {
    uint8_t fmtpinfo;
    uint8_t protection_field_usage;
    uint8_t *payload;
    uint8_t p_type = 0;
    uint8_t prot_en = 0;
    uint8_t dif_separate;

    api_trace();

    /*payload_length = io->tgt_io.mem_io_len; */

    fmtpinfo = io->tgt_io.fmtpinfo;

    payload = io->tgt_io.payload.virt;

    protection_field_usage = payload[0] & 0x07;

    dif_separate = (payload[1] & 1) != 0;

    /*if (payload_length == 4) {
     *  protection_interval_exponent = 0;
     *} else {
     *  protection_interval_exponent = payload[3] & 0x0f;
     *}
     */

    /* Validate the long list of SPT / PROTECT / FMTPINFO / PROTECTION FIELD USAGE
     * combinations per table 34 in SBC
     */

    if (protection_field_usage != 0) {
        /* protection field usage must be 0 for the types we support (0, 1, and 2) */
        return scsi_pack_result(SNS_ILLEGAL_REQ, SNSCODE_INV_PRM, 0);
    }

    switch (fmtpinfo) {
    case 0:
        /* Type 0 protection */
        p_type = 0;
        prot_en = 0;
        break;
    case 1:
        /* fmtpinfo 1 is illegal */
        return scsi_pack_result(SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        break;
    case 2:
        /* Type 1 protection */
        p_type = 1;
        prot_en = 1;
        break;
    case 3:
        /* Type 2 protection */
        p_type = 2;
        prot_en = 1;
        break;
    default:
        /* This shouldn't happen - FMTPINFO is 2 bits */
        ocs_assert(0, -1);
    }

    /* If protection is enabled make sure the block size is one that's supported
     * in the DISEED SGE
     */
    if (prot_en) {
        /* Validate the requested block size.  Values supported by SLI4 in the DISEED SGE are
         * 512, 520, 1024, 2048, and 4096
         */
        int formatted_block_size;

        /* If pending_block_size is zero then this command is not changing the block size, so
         * the block size after formatting will be ramdisc->block_size (including DIF data).
         * In this case the size of the user data block will be ramdisc->block_size - 8 if
         * protection is already enabled, or ramdisc->block_size if protection is disabled.
         *
         * If pending_block_size is non-zero then this command is changing the block size, so
         * the block size after formatting will be ramdisc->pending_block_size (NOT including DIF data).
         * In this case the size of the user data block will be ramdisc->pending_block_size.
         */

        if (io->tgt_io.ramdisc->pending_block_size == 0) {
            if (io->tgt_io.ramdisc->prot_en) {
                formatted_block_size = io->tgt_io.ramdisc->phys_block_size - 8;
            } else {
                formatted_block_size = io->tgt_io.ramdisc->phys_block_size;
            }
        } else {
            formatted_block_size = io->tgt_io.ramdisc->pending_block_size;
        }

        switch(formatted_block_size) {
        case 512:
        case 520:
        case 1024:
        case 2048:
        case 4096:
        case 4104:
            break;
        default:
            ocs_log_test(io->ocs, "Failing format with protection enabled and block size of %d\n", formatted_block_size);
            return scsi_pack_result(SNS_ILLEGAL_REQ, SNSCODE_INV_PRM, 0);
        }
    }


    /* Ready to format the unit */

    if (ocs_format_ramdisc(io->ocs, io->tgt_io.ramdisc, io->tgt_io.ramdisc->pending_block_size, p_type,
                   prot_en, dif_separate)) {

        /*
         * Note:  According to SBC 4.10 the UA condition for CAPACITY DATA HAS CHANGED
         * should be established for all initiators except the one that generated the
         * command that caused the condition.
         */

        ocs_ramd_post_ua(io->ocs, io->tgt_io.ramdisc,
            SCSI_ASC(SCSI_ASC_CAPACITY_DATA_HAS_CHANGED), SCSI_ASCQ(SCSI_ASC_CAPACITY_DATA_HAS_CHANGED),
            io->node);
    }



    return 0;
}

/**
 * @brief Command data phase callback for the FORMAT UNIT command.
 *
 * @par Description
 * This function is called with the SCSI command data phase has completed following
 * a FORMAT UNIT command.
 *
 * @param io Pointer to the IO structure.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
scsi_format_unit_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{

    api_trace();

    ocs_assert(io, -1);
    ocs_assert(io->ocs, -1);

    ocs_lock(&io->tgt_io.sm_lock);
    if (scsi_status == OCS_SCSI_STATUS_GOOD) {
        if (flags & OCS_SCSI_IO_CMPL) {
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_CMPL, scsi_validate_format_unit);
        }
        else    if (flags & OCS_SCSI_IO_CMPL_RSP_SENT) {
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_RESP_CMPL, NULL);
        }
    }
    else {
        ocs_log_test(io->ocs, "dataphase completed with errors %d\n", scsi_status);
        ocs_unlock(&io->tgt_io.sm_lock);
        return -scsi_status;
    }

    ocs_unlock(&io->tgt_io.sm_lock);
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI FORMAT UNIT command.
 *
 * @par Description
 * The SCSI FORMAT UNIT command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_format_unit(ocs_io_t *io, uint8_t cdb[])
{
    uint8_t fmtpinfo;
    uint8_t longlist;
    uint8_t fmtdata;
    /*uint8_t cmplst; */
    /*uint8_t defect_list_format; */
    uint8_t parameter_list_header_length;
    uint32_t rc;
    ocs_scsi_sgl_t sgl;

    api_trace();

    fmtpinfo = (cdb[1] & 0xc0) >> 6;
    longlist = (cdb[1] & 0x20) >> 5;
    fmtdata = (cdb[1] & 0x10) >> 4;
    /*cmplst = (cdb[1] & 0x80) >> 3; */
    /*defect_list_format = (cdb[1] & 0x07); */

    if ((fmtpinfo != 0) && (fmtdata == 0)) {
        /* fmtdata indicates that format data will be sent
         * If the protection information is non-zero then format data is required.
         * It is an error to have non-zero protection information without format data
         */
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* If LUN is not DIF capable, fail (SBC 3r30, Table 34, note f) */
    if (fmtpinfo && !io->tgt_io.ramdisc->prot_capable) {
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* Save fmtpinfo - it will be used later when we validate the parameter list */
    io->tgt_io.fmtpinfo = fmtpinfo;

    if (fmtdata) {
        /* We need to initiate a DATA OUT phase to get the parameter list */
        if (longlist) {
            parameter_list_header_length = 8;
        } else {
            parameter_list_header_length = 4;
        }

        rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, parameter_list_header_length, 16);
        if (rc) {
            ocs_log_err(io->ocs, "ocs_scsi_dma_alloc failed\n");
            return SCSI_HANDLER_NOT_STARTED;
        }
        ocs_assert(io->tgt_io.payload.virt, -1);

        /*
         * If we have already received the data in the first burst, then
         * just copy the data in to payload buffer and advance the
         * io state machine.
         */
        if (io->tgt_io.first_burst_bytes >= parameter_list_header_length) {
            ocs_ramd_first_burst_local(io, parameter_list_header_length);
            ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_and_validate_dataphase, NULL);
            scsi_format_unit_cb(io, OCS_SCSI_STATUS_GOOD, OCS_SCSI_IO_CMPL, NULL);
            /* We should be in the response wait phase already,
             * so return that status again...
             */
            return SCSI_HANDLER_RESP_STARTED;
        }

        /* Build an SGL that points to our buffer */
        ocs_memset(&sgl, 0, sizeof(ocs_scsi_sgl_t));
        sgl.addr = io->tgt_io.payload.phys;
        sgl.len = parameter_list_header_length;

        rc = ocs_scsi_recv_wr_data(io, 0, NULL,
            &sgl, 1, parameter_list_header_length, scsi_format_unit_cb, NULL);

        if (rc == 0) {
            return SCSI_HANDLER_VALIDATED_DATAPHASE_STARTED;
        } else {
            ocs_log_test(io->ocs, "Failed to start data phase, rc is %d\n", rc);
            return SCSI_HANDLER_NOT_STARTED;
        }

    } else {
        /* No FMTDATA bit, so no dataout phase required
         * This can only happen if fmtpinfo is also 0, indicating p_type is 0 (No protection)
         */

        rc = ocs_format_ramdisc(io->ocs, io->tgt_io.ramdisc, io->tgt_io.ramdisc->pending_block_size,
                    0, 0, FALSE);
        if (rc) {
            /* Post UA */
            ocs_ramd_post_ua(io->ocs, io->tgt_io.ramdisc,
                SCSI_ASC(SCSI_ASC_CAPACITY_DATA_HAS_CHANGED),
                SCSI_ASCQ(SCSI_ASC_CAPACITY_DATA_HAS_CHANGED), io->node);
        }

        return ocs_ramd_good_status(io);
    }

    /* Should not be reached */
    return SCSI_HANDLER_NOT_STARTED;

}

/**
 * @brief A structure used to create the READ CAPACITY (10) parameter data.
 */
typedef struct {
    uint32_t returned_lba;
    uint32_t lba_length;
} read_capacity10_param_data_t;

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ CAPACITY (10) command.
 *
 * @par Description
 * The SCSI READ CAPACITY (10) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_capacity10(ocs_io_t *io, uint8_t cdb[])
{
    int32_t rc;
    ocs_ramdisc_sgl_t sgl[1];
    uint32_t lba;
    uint32_t pmi;
    uint32_t xfer_len;
    uint32_t block_size;
    read_capacity10_param_data_t *param;

    lba =   (cdb[2] << 24) |
        (cdb[3] << 16) |
        (cdb[4] <<  8) |
        (cdb[5] <<  0);
    pmi = (cdb[8] & 1) != 0;

    cmd_trace(io, "lba x%x cpmi x%x\n", lba, pmi);

    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, 256, 16);
    if (rc) {
        ocs_log_err(io->ocs, "ocs_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    param = io->tgt_io.payload.virt;
    memset(param, 0, sizeof(*param));

    /* we ignore pmi in this implementation */
    param->returned_lba = ocs_htobe32(io->tgt_io.ramdisc->block_count - 1);

    /* We want to return the size of the user data area of the block.  If protection
     * is enabled then this is 8 bytes less than the actual block size.
     */
    block_size = io->tgt_io.ramdisc->phys_block_size;
    if (io->tgt_io.ramdisc->prot_en) {
        block_size -= 8;
    }
    param->lba_length = ocs_htobe32(block_size);

    xfer_len = sizeof (*param);
    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = xfer_len;

    io->tgt_io.is_read = TRUE;

    /* Send read data */
    rc = ocs_scsi_send_rd_data(io, OCS_SCSI_LAST_DATAPHASE, NULL, (ocs_scsi_sgl_t*) sgl, 1,
        xfer_len, scsi_dataphase_cb, NULL);
    if (rc == 0)
        return SCSI_HANDLER_DATAPHASE_STARTED;

    return SCSI_HANDLER_NOT_STARTED;
}

/**
 * @brief A structure used to create READ CAPACITY (16) parameter data.
 */
typedef struct {
    uint64_t returned_lba;
    uint32_t lba_length;
    uint8_t prot_en : 1,
        p_type : 3,
        rsvd1 : 4;
    uint8_t lba_per_phys_blk:4,
        p_i_exponent:4;
    uint8_t lowest_aligned_lba_msb:6,
        lbprz:1,
        lbpme:1;
    uint8_t lowest_aligned_lba_lsb;
    uint8_t reserved[16];
} read_capacity16_param_data_t;

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI READ CAPACITY (16) command.
 *
 * @par Description
 * The SCSI READ CAPACITY (16) command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_read_capacity16(ocs_io_t *io, uint8_t cdb[])
{
    int32_t rc;
    ocs_ramdisc_sgl_t sgl[1];
    uint64_t lba;
    uint32_t allocation_len;
    uint32_t pmi;
    uint32_t block_size;
    uint32_t xfer_len;
    read_capacity16_param_data_t *param;

    lba =   (((uint64_t)cdb[2]) << 56) |
        (((uint64_t)cdb[3]) << 48) |
        (((uint64_t)cdb[4]) << 40) |
        (((uint64_t)cdb[5]) << 32) |
        (((uint64_t)cdb[6]) << 24) |
        (((uint64_t)cdb[7]) << 16) |
        (((uint64_t)cdb[8]) <<  8) |
        (((uint64_t)cdb[9]) <<  0);
    allocation_len =
        (cdb[10] << 24) |
        (cdb[11] << 16) |
        (cdb[12] <<  8) |
        (cdb[13] <<  0);

    /* As per SPC-4 an allocation length of 0 means no data transfer
     * so just return good status now.
     */
    if (allocation_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    pmi = (cdb[15] & 1) != 0;

    cmd_trace(io, "lba %" PRId64 " len %d pmi %d\n", lba, allocation_len, pmi);
    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, allocation_len, 16);
    if (rc) {
        ocs_log_err(NULL, "ocs_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    param = io->tgt_io.payload.virt;
    memset(param, 0, sizeof(*param));

    /* we ignore pmi in this implementation */
    param->returned_lba = ocs_htobe64(io->tgt_io.ramdisc->block_count - 1);

    /* We want to return the size of the user data area of the block.  If protection
     * is enabled then this is 8 bytes less than the actual block size.
     */
    block_size = io->tgt_io.ramdisc->phys_block_size;
    if (io->tgt_io.ramdisc->prot_en) {
        block_size -= 8;
    }
    param->lba_length = ocs_htobe32(block_size);

    if (io->tgt_io.ramdisc->prot_en == 0) {
        /* Protection off */
        param->prot_en = 0;
        param->p_type = 0;
    } else {
        param->prot_en = 1;
        param->p_type = io->tgt_io.ramdisc->p_type - 1;
    }

    param->p_i_exponent = 0;


    xfer_len = sizeof (*param);
    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = xfer_len;

    io->tgt_io.is_read = TRUE;

    /* Send read data */
    rc = ocs_scsi_send_rd_data(io, OCS_SCSI_LAST_DATAPHASE, NULL, (ocs_scsi_sgl_t*) sgl, 1,
        xfer_len, scsi_dataphase_cb, NULL);
    if (rc == 0)
        return SCSI_HANDLER_DATAPHASE_STARTED;

    return SCSI_HANDLER_NOT_STARTED;
}

#define INQ_VPD_SUPPORTED_PAGE_00       0x00
#define INQ_VPD_UNIT_SERIAL_NO_PAGE_80  0x80
#define INQ_VPD_DEVICE_ID_PAGE_83       0x83
#define INQ_VPD_EXT_INQ_DATA_PAGE_86    0x86
#define INQ_VPD_BLOCKS_LIMIT_PAGE_B0    0xB0
#define INQ_VPD_BLOCK_DEV_CHARS_PAGE_B1 0xB1

/**
 * VPD pages supported by the ramd driver
 * Adding a new VPD page must be inserted in correct
 * numerical oreder.
 */
uint8_t  supportedVPDPageList[] = {
    INQ_VPD_SUPPORTED_PAGE_00,
    INQ_VPD_UNIT_SERIAL_NO_PAGE_80,
    INQ_VPD_DEVICE_ID_PAGE_83,
    INQ_VPD_EXT_INQ_DATA_PAGE_86,
    INQ_VPD_BLOCKS_LIMIT_PAGE_B0,
    INQ_VPD_BLOCK_DEV_CHARS_PAGE_B1,
};

/**
 * @brief A structure used to create the standard inquiry data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t :7,
        rmb:1;
    uint8_t version;
    uint8_t response_data_format:4,
        hisup:1,
        norm_aca:1,
        :2;
    uint8_t additional_len;
    uint8_t protect:1,
        :2,
        pc:1,
        tpgs:2,
        acc:1,
        sccs:1;
    uint8_t addr16:1,
        :3,
        multip:1,
        vs:1,
        enc_serv:1,
        :1;
    uint8_t vs7:1,
        cmd_que:1,
        :2,
        sync:1,
        wbus16:1,
        :2;
    uint8_t t10_vendor_id[8];
    uint8_t product_id[16];
    uint8_t product_revision_level[4];
    uint8_t vendor_specific[20];
    uint8_t ius:1,
        qas:1,
        clocking:2,
        :4;
    uint8_t rsvd57;
    uint8_t version_descriptor_1[2];
    uint8_t version_descriptor_2[2];
    uint8_t version_descriptor_3[2];
    uint8_t version_descriptor_4[2];
    uint8_t version_descriptor_5[2];
    uint8_t version_descriptor_6[2];
    uint8_t version_descriptor_7[2];
    uint8_t version_descriptor_8[2];
    uint8_t rsvd74[22];
    uint8_t vendor_specific_parameters[0];
} scsi_std_inquiry_t;

/**
 * @brief Vendor specific inquiry data for External DIF
 */
typedef struct {
    uint8_t rsvd96[72];
    uint8_t protection_information_length;
    uint8_t data_format_version;
    uint8_t ato:1,
        ref_chk:1,
        app_chk:1,
        grd_chk:1,
        spt:3,
        protect:1;
    uint8_t rsvd171;
} scsi_extdif_inquiry_t;

/**
 * @brief A structure used to create the inquiry page 00 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint8_t :8;
    uint8_t page_length;
    uint8_t page_codes[0];
} scsi_supported_pages_vpd_page_t;

/**
 * @brief A structure used to create the inquiry page 80 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint8_t :8;
    uint8_t page_length;
    uint8_t product_serial_number[24];
} scsi_unit_serial_number_vpd_page_t;

/**
 * @brief A structure used to create the inquiry page 83 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint16_t page_length;
} scsi_device_identification_vpd_page_t;

/**
 * @brief A structure used to create the device ID data for inquiry page 83.
 */
typedef struct {
    uint8_t code_set:4,
        protocol_identifier:4;
    uint8_t designator_type:4,
        association:2,
        :1,
        piv:1;
    uint8_t :8;
    uint8_t designator_length;
} scsi_device_identification_vpd_desc_t;

/**
 * @brief The Designator used by inquiry page 83. This is an EUI-64
 * based 12-byte identifier.
 */
typedef struct {
    uint8_t company_id[3];
    uint8_t vendor_specific_extension_identifier[5];
    uint32_t directory_id;
} scsi_device_designator_t;

/**
 * @brief A structure used to create the inquiry page 86 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint16_t page_length;
    uint8_t ref_chk:1,
        app_chk:1,
        grd_chk:1,
        spt:3,
        active_microcode:2;
    uint8_t simpsup:1,
        ordsup:1,
        headsup:1,
        prior_sup:1,
        group_sup:1,
        uask_sup:1,
        :2;
    uint8_t v_sup:1,
        nv_sup:1,
        crd_sup:1,
        wu_sup:1,
        :4;
    uint8_t liuclr:1,
        :3,
        p_i_i_sup:1,
        :3;
    uint8_t cbcs:1,
        :3,
        r_sup:1,
        :3;
    uint8_t multi_io_nexus_microcode_download:4,
        :4;
    uint8_t rsvd[54];
} scsi_extended_inquiry_data_vpd_page_t;

/**
 * @brief A structure used to create the inquiry page B0 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint16_t page_length;
    uint8_t     wsnz:1,
            :7;
    uint8_t     maximum_compare_and_write_length;
    uint16_t    optimal_transfer_length_granularity;
    uint32_t    maximum_transfer_length;
    uint32_t    optimal_transfer_length;
    uint32_t    maximum_prefetch_xdread_xdwrite_transfer_length;
    uint32_t    maximum_unmap_lba_count;
    uint32_t    maximum_unmap_block_descriptor_count;
    uint32_t    optimal_unmap_granularity;
    uint32_t    unmap_granularity_alignment:31,
            ugavalid:1;
    uint32_t    maximum_write_same_length_hi;
    uint32_t    maximum_write_same_length_lo;
    uint8_t rsvd2[20];
} scsi_block_limits_vpd_page_t;

/**
 * @brief A structure used to create the inquiry page B1 data.
 */
typedef struct {
    uint8_t peripheral_device_type:5,
        peripheral_qualifier:3;
    uint8_t page_code;
    uint16_t page_length;
    uint16_t medium_rotation_rate;
    uint8_t rsvd1;
    uint8_t nominal_form_factor:4,
        :4;
    uint8_t rsvd2[56];
} scsi_block_device_characteristics_vpd_page_t;


/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI INQUIRY command.
 *
 * @par Description
 * The SCSI INQUIRY command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_inquiry(ocs_io_t *io, uint8_t cdb[])
{
    int32_t rc;
    ocs_scsi_sgl_t sgl[1];
    uint32_t evpd;
    uint32_t page_code;
    uint32_t allocation_len;
    uint32_t xfer_len = 0;
    ocs_t *ocs = io->ocs;

    cmd_trace(io, "");
    evpd = cdb[1] & 1;
    page_code = cdb[2];
    allocation_len = (cdb[3] << 8) | (cdb[4]);

    /* As per SPC-4 an allocation length of 0 means no data transfer
     * so just return good status now.
     */
    if (allocation_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, 256, 16);
    if (rc) {
        ocs_log_err(NULL, "ocs__dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    /* Check for an invalid LUN. SPC-5 6.5.1:
     * In response to an INQUIRY command received by an incorrect logical
     * unit, the SCSI target device shall return the INQUIRY data with the
     * peripheral qualifier set to the value defined in 6.5.2.
     *
     * SPC-5 Table 138:
     * Qualifier 011b is "An addressed logical unit is not accessible to
     * the task router (see SAM-5) contained in the SCSI target port that
     * received this INQUIRY command. If the task router sets the PERIPHERAL
     * QUALIFIER field to 011b, the task router shall set the PERIPHERAL
     * DEVICE TYPE field to 1Fh.
     *
     * Peripheral Device Type 1fh is "Unknown or no device type"
     *
     */

    if (!io->tgt_io.lun_is_valid) {
        if (evpd == 0) {
            scsi_std_inquiry_t *inq;

            inq = io->tgt_io.payload.virt;
            memset(inq, 0, sizeof(*inq));

            inq->peripheral_qualifier = 0x3;
            inq->peripheral_device_type = 0x1f;

            xfer_len = offsetof(scsi_std_inquiry_t, vendor_specific);
        } else {
            return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
        }

    } else {

        if (evpd == 0) {
            scsi_std_inquiry_t *inq;

            inq = io->tgt_io.payload.virt;
            memset(inq, 0, sizeof(*inq));

            inq->additional_len = 0x1f;
            inq->peripheral_device_type = 0;    /* SBC-3 */
            inq->version = 3;           /* SPC-3 */
            inq->hisup = 1;
            inq->response_data_format = 2;
            inq->protect = io->tgt_io.ramdisc->prot_capable;
            inq->cmd_que = 1;
            ocs_memcpy(inq->t10_vendor_id, "EMULEX  ", 8);
            ocs_memcpy(inq->product_id, "ocs-ramd        ", 16);
            ocs_memcpy(inq->product_revision_level, "0000", 4);

            /* compute the number of bytes to transfer */
            xfer_len = offsetof(scsi_std_inquiry_t, vendor_specific);

            if (io->tgt_io.ramdisc->external_dif) {
                scsi_extdif_inquiry_t *inqextdif = (scsi_extdif_inquiry_t *)inq->vendor_specific_parameters;

                ocs_memset(inqextdif, 0, sizeof(scsi_extdif_inquiry_t));
                ocs_memset(inq->t10_vendor_id, 0, sizeof(inq->t10_vendor_id));

                /* Proprietary End-to-end protection */
                inq->additional_len = 0xa7;
                inq->protect = 0;
                ocs_strncpy(inq->t10_vendor_id, io->tgt_io.ramdisc->t10_vendor_id,
                        MIN(sizeof(inq->t10_vendor_id), ocs_strlen(io->tgt_io.ramdisc->t10_vendor_id)));

                inqextdif->protection_information_length = 2;
                inqextdif->data_format_version = 1;

                inqextdif->protect = io->tgt_io.ramdisc->prot_capable;
                /* inqextdif->spt is 0x0 meaning Type 1 */
                inqextdif->grd_chk = 1;
                inqextdif->app_chk = 0;
                inqextdif->ref_chk = 1;
                /* inqextdif->ato is 0x0 meaning app tag is modified */

                xfer_len = sizeof(scsi_std_inquiry_t) + sizeof(scsi_extdif_inquiry_t);
            }
        } else {
            switch(page_code) {
            case 0x00: {
                scsi_supported_pages_vpd_page_t *inq;
                uint8_t *p;
                uint8_t  i;

                inq = io->tgt_io.payload.virt;
                memset(inq, 0, sizeof(*inq));

                p = inq->page_codes;
                for (i = 0; i < sizeof(supportedVPDPageList); i++) {
                    *p++ = supportedVPDPageList[i];
                }
                xfer_len = sizeof(*inq) + (p - inq->page_codes);
                inq->page_length = xfer_len - 4;
                break;
            }
            case 0x80: {
                scsi_unit_serial_number_vpd_page_t *inq;
                uint8_t *pserial;
                uint32_t len;
                uint64_t serial_id, serial_len;
                uint8_t serial_str[16];

                inq = io->tgt_io.payload.virt;
                memset(inq, 0, sizeof(*inq));

                inq->page_code = page_code;
                inq->page_length = sizeof(*inq) - 4;

                /* Fetch the serial number; it's a VPD segment, so it has a one byte
                 * length followed by the length number of bytes
                 */
                pserial = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_SERIALNUMBER);
                if (pserial) {
                    len = *pserial ++;
                    if (len > sizeof(inq->product_serial_number))
                        len = sizeof(inq->product_serial_number);

                    ocs_memcpy(inq->product_serial_number, pserial, len);

                    /* BZ 202760: Make the serial# unique for each lun on a given HBA */
                    serial_id = io->tgt_io.lun;

                    /* Place the sport index in the upper byte of the lower 32 bits */
                    if (!ocs->tgt_ocs.use_global_ramd) {
                        if (io->node && io->node->sport) {
                            serial_id |= (io->node->sport->instance_index << 24);
                        }
                    }

                    /* Place the OCS instance index in the upper 32 bits */
                    serial_id |= ((uint64_t)ocs->instance_index << 32);

                    /* Stringify the serial_id */
                    ocs_snprintf(serial_str, sizeof(serial_str), "%" PRIX64, serial_id);
                    serial_len = ocs_strlen(serial_str) + 1;

                    /* Append the serial_str at the end of VPD SN */
                    if (len > (sizeof(inq->product_serial_number) - serial_len)) {
                        len = (sizeof(inq->product_serial_number) - serial_len);
                    }

                    ocs_memcpy(&inq->product_serial_number[len], serial_str, serial_len);
                }

                /* compute the number of bytes to transfer */
                xfer_len = sizeof(*inq);

                break;
            }
            case 0x83: {
                uint8_t *wwnn;
                scsi_device_identification_vpd_page_t *inq = io->tgt_io.payload.virt;
                scsi_device_identification_vpd_desc_t *pd = (scsi_device_identification_vpd_desc_t*) (&inq[1]);
                scsi_device_designator_t *designator = (scsi_device_designator_t*) (&pd[1]);
                uint32_t directory_id;

                ocs_memset(inq, 0, sizeof(*inq));
                ocs_memset(pd, 0, sizeof(*pd));
                ocs_memset(designator, 0, sizeof(*designator));

                /*
                 * The SCSI device designator has to uniquely identify a LUN (ocs_ramdisc_t instance).
                 * If use_global_ramd is true then there is one ramd made up of 1 or more LUNs.  This
                 * ramd is shared between all target ports.
                 * If use_global_ramd is false then each sport has its own ramd, again made of 1 or more
                 * LUNs.
                 *
                 * The first 3 bytes of the designator are always the IEEE Company ID  (00 00 C9)
                 * Bytes 3-7 will be the WWNN of the port associated with the ramd.  In the case of
                 * a global ramdisc this is always the WWNN of the first port (OCS instance 0).
                 * For per-sport ramdiscs this is the WWNN from the OCS instance to which the sport
                 * belongs.
                 * Bytes 8-11 identify the LUN within the ramdisc.  For a per-sport ramdisc the
                 * index of the sport is placed in the upper byte.
                 *
                 *   Byte    Contents
                 *   0-2     Company OUI
                 *   3-7     WWNN
                 *    8      sport index
                 *   9-11    LUN
                 */
                directory_id = io->tgt_io.lun;
                if (!ocs->tgt_ocs.use_global_ramd) {
                    ocs_node_t *node = io->node;
                    if (node != NULL) {
                        ocs_sport_t *sport = node->sport;
                        if (sport != NULL) {
                            directory_id |= (sport->instance_index << 24);
                        }
                    }
                    wwnn = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWNN);
                } else {
                    ocs_t *first_ocs;

                    first_ocs = ocs_get_instance(0);
                    /* Added a check to verify that there is a first_ocs port,
                     * else grab the current port instance wwnn
                     */
                    if (first_ocs != NULL) {
                        wwnn = ocs_scsi_get_property_ptr(first_ocs, OCS_SCSI_WWNN);
                    } else {
                        wwnn = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWNN);
                    }
                }

                inq->page_code = page_code;
                pd->code_set = 1;  /* Code set 1 == Binary */
                pd->designator_type = 2;  /* Designator Type 2 == EUI-64 */

                ocs_memcpy(designator->vendor_specific_extension_identifier, &(wwnn[3]), 5);
                designator->company_id[2] = 0xc9;
                designator->directory_id = ocs_htobe32(directory_id);

                pd->designator_length = sizeof(*designator);
                inq->page_length = ocs_htobe16(sizeof(*pd) + sizeof(*designator));

                xfer_len = sizeof(*inq) + sizeof(*pd) + sizeof(*designator);
                break;
            }

            case 0x86: {
                scsi_extended_inquiry_data_vpd_page_t *inq = io->tgt_io.payload.virt;

                ocs_memset(inq, 0, sizeof(*inq));

                inq->page_code = page_code;
                inq->page_length = ocs_htobe16(sizeof(*inq) - 4);
                if (io->tgt_io.ramdisc->external_dif) {
                    inq->spt = 1;
                    inq->grd_chk = 1;
                    inq->app_chk = 1;
                    inq->ref_chk = 1;
                }

                xfer_len = sizeof(*inq);

                break;
            }

            case 0xB0: {
                scsi_block_limits_vpd_page_t *inq = io->tgt_io.payload.virt;

                ocs_memset(inq, 0, sizeof(*inq));

                inq->page_code = page_code;
                inq->page_length = ocs_htobe16(sizeof(*inq) - 4);

                inq->wsnz = 0;
                inq->maximum_compare_and_write_length = 0;  /* Not supported */
                inq->optimal_transfer_length_granularity = 0;   /* Not reported */
                inq->maximum_transfer_length = 0;       /* Not reported */
                inq->optimal_transfer_length = 0;       /* Not reported */
                inq->maximum_prefetch_xdread_xdwrite_transfer_length = 0;
                inq->maximum_unmap_lba_count = 0;       /* Not supported */
                inq->maximum_unmap_block_descriptor_count = 0;  /* Not supported */
                inq->optimal_unmap_granularity = 0;     /* Not specified */
                inq->ugavalid = 0;
                inq->unmap_granularity_alignment = 0;
                inq->maximum_write_same_length_hi = 0;
                inq->maximum_write_same_length_lo = 0;

                xfer_len = sizeof(*inq);

                break;
            }

            case 0xB1: {
                scsi_block_device_characteristics_vpd_page_t *inq = io->tgt_io.payload.virt;

                ocs_memset(inq, 0, sizeof(*inq));

                inq->page_code = page_code;
                inq->page_length = ocs_htobe16(sizeof(*inq) - 4);
                inq->medium_rotation_rate = ocs_htobe16(1); /* Non-rotating medium */
                inq->nominal_form_factor = 0; /* Nominal form factor is not reported */

                xfer_len = sizeof(*inq);

                break;
            }

            default:
                return SCSI_CMD_NOT_SUPPORTED;
            }
        }
    }

    if (xfer_len > allocation_len) {
        xfer_len = allocation_len;
    }

    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = xfer_len;

    /* Send read data */
    io->tgt_io.is_read = TRUE;

    rc = ocs_scsi_send_rd_data(io, OCS_SCSI_LAST_DATAPHASE, NULL,
            sgl, 1, xfer_len, scsi_dataphase_cb, NULL);
    if (rc == 0) {
        return SCSI_HANDLER_DATAPHASE_STARTED;
    }

    return SCSI_HANDLER_NOT_STARTED;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI REQUEST SENSE command.
 *
 * @par Description
 * The SCSI REQUEST SENSE command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_request_sense(ocs_io_t *io, uint8_t cdb[])
{
    uint8_t allocation_len;
    static char sense_data[] = {
        0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00,
    };
    int sense_data_len = 18;
    int32_t rc;
    ocs_scsi_sgl_t sgl[1];

    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, 256, 16);
    if (rc) {
        ocs_log_err(NULL, "ocs_scsi_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    allocation_len = cdb[4];

    /* As per SPC-4 an allocation length of 0 means no data transfer
     * so just return good status now.
     */
    if (allocation_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    if (allocation_len < sense_data_len) {
        sense_data_len = allocation_len;
    }

    ocs_memcpy(io->tgt_io.payload.virt, sense_data, sense_data_len);

    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = sense_data_len;

    io->tgt_io.is_read = TRUE;

    /* Send read data */
    rc = ocs_scsi_send_rd_data(io, 0, NULL, sgl, 1, sgl[0].len, scsi_dataphase_cb, NULL);

    if (rc == 0)
        return SCSI_HANDLER_DATAPHASE_STARTED;
    return SCSI_HANDLER_NOT_STARTED;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI TEST UNIT READY command
 *
 * @par Description
 * The SCSI TEST UNIT READY command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_test_unit_ready(ocs_io_t *io, uint8_t cdb[])
{
    cmd_trace(io, "");

    ocs_assert(cdb[0] == SCSI_TEST_UNIT_READY, -1);

    return ocs_ramd_good_status(io);
}


/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI RESERVE or RELEASE command
 *
 * @par Description
 * The SCSI RESERVE or RELEASE command is processed.
 * This is only a stub however and always returns a
 * good status with no actual reservation being made.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_CMD_NOT_SUPPORTED
 * is an error and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_reserve_release(ocs_io_t *io, uint8_t cdb[])
{
    char prop_buf[32];
    uint32_t stub_res6_rel6 = 0;
    cmd_trace(io, "");

    ocs_assert(cdb[0] == SCSI_RESERVE6 || cdb[0] == SCSI_RELEASE6, SCSI_CMD_NOT_SUPPORTED);

    if (ocs_get_property("stub_res6_rel6", prop_buf, sizeof(prop_buf)) == 0) {
         stub_res6_rel6 = ocs_strtoul(prop_buf, 0, 0);
    }

    if (stub_res6_rel6 == TRUE) {
        return ocs_ramd_good_status(io);
    }

    return SCSI_CMD_NOT_SUPPORTED;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI REPORT LUNS command.
 *
 * @par Description
 * The SCSI REPORT LUNS command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_report_luns(ocs_io_t *io, uint8_t cdb[])
{
    int32_t rc;
    uint32_t i;
    ocs_scsi_sgl_t sgl[1];

    /*uint32_t select_report; */
    uint32_t allocation_len;

    uint32_t *param;
    uint32_t lun_count = 0;
    uint32_t xfer_len = 0;


    /* grab the lun count based on whether we have a global ramdisc */
    if (io->ocs->tgt_ocs.use_global_ramd) {
        lun_count = io->ocs->tgt_ocs.rdisc_count;
    } else if (io->node != NULL && io->node->sport != NULL) {
        lun_count = io->node->sport->tgt_sport.rdisc_count;
    }

    /*select_report = cdb[2]; // Unused.  We return all luns. */

    allocation_len = (cdb[6] << 24) |
             (cdb[7] << 16) |
             (cdb[8] <<  8) |
             (cdb[9] <<  0);

    /* As per SPC-4 an allocation length of 0 means no data transfer
     * so just return good status now.
     */
    if (allocation_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    cmd_trace(io, "len x%x\n", allocation_len);

    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, allocation_len, 16);
    if (rc) {
        ocs_log_err(NULL, "ocs_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    param = io->tgt_io.payload.virt;

    *param++ = ocs_htobe32(lun_count*8);
    *param++ = 0;

    /*
     * Adjust the lun count if the allocated length does not allow the
     * entire list to be returned. This prevents us from writing past the
     * allocated memory.
     */
    if ((allocation_len - 8) / 8 < lun_count) {
        lun_count = (allocation_len - 8) / 8;
    }

    /* If there are a small number of LUNs, use this format */
    if (lun_count <= 256) {
        for (i = 0; i < lun_count; i ++) {
            uint8_t *p = (uint8_t*) param;
            ocs_memset(p, 0, 8);
            p[1] = i;
            param += 2;
        }
    }

    /*
     * For more than 256 LUNs, use the Flat Space LUN structure
     * See SCSI SAM spec, section 4.7 (This is table 12 in SAM-5)
     * Format:
     * byte 0: bits 7-6 01b (Address Method)
     * byte 0: bits 5-0 MSB of LUN
     * byte 1: LSB of LUN
     */
    else {
        for (i = 0; i < lun_count; i ++) {
            uint8_t *p = (uint8_t*) param;
            ocs_memset(p, 0, 8);
            p[0] = 0x01 << 6;
            p[0] |= (i & 0x3F00) >> 8;
            p[1] = i & 0xFF;
            param += 2;
        }
    }

    xfer_len = (param - ((uint32_t*)io->tgt_io.payload.virt))*sizeof(*param);

    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = xfer_len;

    io->tgt_io.is_read = TRUE;

    /* Send read data */
    rc = ocs_scsi_send_rd_data(io, OCS_SCSI_LAST_DATAPHASE, NULL,
            sgl, 1, xfer_len, scsi_dataphase_cb, NULL);
    if (rc == 0)
        return SCSI_HANDLER_DATAPHASE_STARTED;


    return SCSI_HANDLER_NOT_STARTED;

}

/**
 * @ingroup scsi_cmd
 * @brief Validate a MODE SELECT parameter list.
 *
 * @par Description
 * Called after a MODE SELECT data out phase has completed. This function
 * validates the contents of the parameter list. If the parameter list is
 * valid, it takes the appropriate action and returns 0. If the parameter
 * list is not valid, the function returns a sense key, code, and qualifier to be returned
 * to the initiator in a CHECK CONDITION.
 *
 * @param io Pointer to the IO context.
 *
 * @return Returns 0 on success; or a non-zero sense key, code, and qualifier on failure.
 */
static uint32_t
scsi_validate_mode_select(ocs_io_t *io) {
    /*uint8_t payload_length; */
    uint8_t *payload;
    uint32_t lun;
    ocs_ramdisc_t *ramdisc;
    /*uint16_t mode_data_length; */
    uint16_t block_descriptor_length;
    uint8_t longlba;
    uint32_t block_size = 0;

    api_trace();

    /*payload_length = io->tgt_io.mem_io_len; */
    payload = io->tgt_io.payload.virt;

    lun = io->tgt_io.lun;
    ramdisc = ocs_ramd_lookup(io, lun);

    if (io->tgt_io.mode_select_opcode == SCSI_MODE_SELECT6) {
        /*mode_data_length = payload[0]; */
        block_descriptor_length = payload[3];
        longlba = 0;
        payload += 4;
    } else {
        /*mode_data_length = (payload[0] << 8) | payload[1]; */
        block_descriptor_length = (payload[6] << 8) | payload[7];
        longlba = payload[4] & 0x01;
        payload += 8;
    }

    /*
     * Per the spec we can have block descriptor entries that are either
     * 8 or 16 bytes long, depending on the value of the LONGLBA flag,
     * and we can have more than one of them.  In practice we expect to
     * get exactly one 8-byte block descriptor.
     *
     * We'll support the following cases:
     *       LONGLBA   LENGTH    Contents
     *          0        0       No block descriptors
     *          0        8       One 8-byte block descriptor
     *          0       >8       Use the first 8-byte block descriptor, ignore the rest
     *          1        0       No block descriptors
     *          1       16       One 16-byte block descriptor
     *          1      >16       Use the first 16-byte block descriptor, ignore the rest
     *
     */

    if (block_descriptor_length != 0) {
        if (longlba) {
            /* Get one 16-byte block descriptor */
            block_size = (payload[12] << 24) | (payload[13] << 16)
                    | (payload[14] << 8) | payload[15];
        } else {
            /* Get one 8-byte block descriptor */
            block_size = (payload[5] << 16) | (payload[6] << 8) | payload[7];
        }



        ocs_set_ramdisc_blocksize(io->ocs, ramdisc, block_size);
    }

    payload += block_descriptor_length;

    /* This is the end of block descriptor processing.  Remaining code, TBD,
     * will do mode page processing.
     */



    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Command data phase callback for the MODE SELECT command.
 *
 * @par Description
 * This function is called when the SCSI command data phase has completed following a MODE SELECT
 * command.
 *
 * @param io Pointer to the IO structure.
 * @param scsi_status Completion status.
 * @param flags Flags.
 * @param arg Application-specified argument.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
scsi_mode_select_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
{

    api_trace();

    ocs_assert(io, -1);
    ocs_assert(io->ocs, -1);
    ocs_lock(&io->tgt_io.sm_lock);
    if (scsi_status == OCS_SCSI_STATUS_GOOD) {
        if (flags & OCS_SCSI_IO_CMPL) {
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_IO_CMPL, scsi_validate_mode_select);
        }
        else    if (flags & OCS_SCSI_IO_CMPL_RSP_SENT) {
            ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_RESP_CMPL, NULL);
        }
    }
    else {
        ocs_log_test(io->ocs, "dataphase completed with errors %d\n", scsi_status);
        ocs_unlock(&io->tgt_io.sm_lock);
        return -scsi_status;
    }
    ocs_unlock(&io->tgt_io.sm_lock);

    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Process the SCSI MODE SELECT command.
 *
 * @par Description
 * The SCSI MODE SELECT command is processed.
 *
 * @param io Pointer to the IO context.
 * @param cdb Pointer to the SCSI CDB.
 *
 * @return Returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 * and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */
static ocs_ramd_hndlr_rtn_e
ocs_ramd_mode_select(ocs_io_t *io, uint8_t cdb[])
{
    uint16_t parameter_list_length;
    uint32_t rc;
    ocs_scsi_sgl_t sgl;

    io->tgt_io.mode_select_opcode = cdb[0];

    if (cdb[0] == SCSI_MODE_SELECT6) {
        parameter_list_length = cdb[4];
    } else {
        parameter_list_length = (cdb[7] << 8) | cdb[8];
    }

    /* As per SPC-4 a parameter List length of 0 means no data transfer
     * so just return good status now.
     */
    if (parameter_list_length == 0) {
        return(ocs_ramd_good_status(io));
    }

    /* We need to initiate a DATA OUT phase to get the parameter list */

    /* Build an SGL that points to our buffer */
    rc = ocs_dma_alloc(io->ocs, &io->tgt_io.payload, parameter_list_length, 16);
    if (rc) {
        ocs_log_err(io->ocs, "ocs_scsi_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    ocs_memset(&sgl, 0, sizeof(ocs_scsi_sgl_t));
    sgl.addr = io->tgt_io.payload.phys;
    sgl.len = parameter_list_length;

    /*
     * If we have already received the data in the first burst, then
     * just copy the data in to payload buffer and advance the
     * io state machine.
     */
    if (io->tgt_io.first_burst_bytes >= parameter_list_length) {
        ocs_ramd_first_burst_local(io, parameter_list_length);
        ocs_sm_transition(&io->tgt_io.sm, __ocs_ramd_io_wait_and_validate_dataphase, NULL);
        scsi_mode_select_cb(io, OCS_SCSI_STATUS_GOOD, OCS_SCSI_IO_CMPL, NULL);
        /* We should be in the response wait phase already,
         * so return that status again...
         */
        return SCSI_HANDLER_RESP_STARTED;
    }

    rc = ocs_scsi_recv_wr_data(io, 0, NULL,
        &sgl, 1, parameter_list_length, scsi_mode_select_cb, NULL);

    if (rc == 0) {
        return SCSI_HANDLER_VALIDATED_DATAPHASE_STARTED;
    } else {
        ocs_log_test(io->ocs, "Failed to start data phase, rc is %d\n", rc);
        return SCSI_HANDLER_NOT_STARTED;
    }

}

/**
 * @ingroup scsi_cmd
 * @brief Abort all tasks associated with a node.
 *
 * @par Description
 * All the IOs associated with the @c node are aborted.
 *
 * @param node Pointer to the remote node.
 * @param myio Pointer to the IO requesting the abort.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_abort_node_tasks(ocs_node_t *node, ocs_io_t *myio)
{
    ocs_io_t *io;
    ocs_io_t *ionext;
    ocs_list_t tmf_abort_list;

    /* Add IOs to be aborted to this list and trigger state machine outside active_ios lock*/
    ocs_list_init(&tmf_abort_list, ocs_io_t, tmf_abort_link);

    ocs_lock(&node->active_ios_lock);
        if (!ocs_list_empty(&node->active_ios)) {
            ocs_log_debug(node->ocs, "[%s] aborting IO's\n", node->display_name);
            ocs_list_foreach_safe(&node->active_ios, io, ionext) {
                if (io == myio) {
                    continue;
                }
                if (!io->tmf_abort && ocs_ref_get_unless_zero(&io->ref)) {
                    /* Mark the IO to indicate tmf_abort in progress */
                    io->tmf_abort = TRUE;
                    ocs_list_add_tail(&tmf_abort_list, io);
                }
            }
        }
    ocs_unlock(&node->active_ios_lock);

    ocs_list_foreach_safe(&tmf_abort_list, io, ionext) {
        ocs_list_remove(&tmf_abort_list, io);
        if (myio != NULL) {
            io_printf(myio, "aborting " IOFMT "\n", IOFMT_ARGS(io));
        } else {
            io_printf(io, "getting aborted\n");
        }
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_ABORT_IO_NO_RESP, NULL);
        io->tmf_abort = FALSE;
        ocs_ref_put(&io->ref);
    }
    return 0;
}

/**
 * @ingroup scsi_cmd
 * @brief Abort tasks associated with a given node and LUN.
 *
 * @par Description
 * The tasks associated with a @c node and @c lun are aborted.
 *
 * @param node Pointer to the node.
 * @param lun LUN value.
 * @param myio Pointer to the IO requesting the abort.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
static int32_t
ocs_ramd_abort_node_tasks_lun(ocs_node_t *node, uint32_t lun, ocs_io_t *myio)
{
    ocs_io_t *io;
    ocs_io_t *ionext;
    ocs_list_t tmf_abort_list;

    /* Add IOs to be aborted to this list and trigger state machine outside active_ios lock*/
    ocs_list_init(&tmf_abort_list, ocs_io_t, tmf_abort_link);

    ocs_lock(&node->active_ios_lock);
        if (!ocs_list_empty(&node->active_ios)) {

            ocs_log_debug(node->ocs, "[%s] aborting IO's for lun x%x\n", node->display_name, lun);

            ocs_list_foreach_safe(&node->active_ios, io, ionext) {
                if (io == myio) {
                    continue;
                }

                if ( (io->tgt_io.lun == lun) && !io->tmf_abort && ocs_ref_get_unless_zero(&io->ref)) {
                    /* Mark the IO to indicate tmf_abort in progress */
                    io->tmf_abort = TRUE;
                    ocs_list_add_tail(&tmf_abort_list, io);
                }
            }
        }
    ocs_unlock(&node->active_ios_lock);

    ocs_list_foreach_safe(&tmf_abort_list, io, ionext) {
        ocs_list_remove(&tmf_abort_list, io);

        io_printf(myio, "aborting " IOFMT "\n", IOFMT_ARGS(io));
        ocs_sm_post_event(&io->tgt_io.sm, OCS_EVT_ABORT_IO_NO_RESP, NULL);
        io->tmf_abort = FALSE;
        ocs_ref_put(&io->ref);
    }
    
    return 0;
}

void
ocs_scsi_tgt_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
{
    int num_luns = 0;

    switch(type) {
    case OCS_SCSI_DDUMP_DEVICE: {
        int32_t i;
        ocs_t *ocs = obj;
        ocs_scsi_tgt_t *tgt_ocs = &ocs->tgt_ocs;
        ocs_ddump_value(textbuf, "max_sge", "%u", tgt_ocs->max_sge);
        ocs_ddump_value(textbuf, "max_sgl", "%u", tgt_ocs->max_sgl);
        ocs_ddump_value(textbuf, "ios_in_use", "%d", ACTIVE_IO_COUNT(ocs));
        ocs_ddump_value(textbuf, "io_high_watermark", "%d", ocs_atomic_read(&tgt_ocs->io_high_watermark));
        ocs_ddump_value(textbuf, "initiator_count", "%d", ocs_atomic_read(&tgt_ocs->initiator_count));
        ocs_ddump_value(textbuf, "watermark_max", "%d", tgt_ocs->watermark_max);
        ocs_ddump_value(textbuf, "watermark_min", "%d", tgt_ocs->watermark_min);
        ocs_ddump_value(textbuf, "watermark_hit", "%d", ocs_atomic_read(&tgt_ocs->watermark_hit));
        ocs_ddump_value(textbuf, "rdisc_count", "%d", tgt_ocs->rdisc_count);

        /* grab the lun count based on whether we have a global ramdisc */
        if (ocs->tgt_ocs.use_global_ramd) {
            num_luns = ocs->tgt_ocs.rdisc_count;

            for (i = 0; i < num_luns; i ++) {
                ocs_ddump_ramdisc(textbuf, ocs->tgt_ocs.rdisc[i]);
            }
        }
        ocs_ramd_thread_ddump(textbuf);
        break;
    }
    case OCS_SCSI_DDUMP_DOMAIN: {
//      ocs_domain_t *domain = obj;
        break;
    }
    case OCS_SCSI_DDUMP_SPORT: {
//      ocs_sport_t *sport = obj;
        break;
    }
    case OCS_SCSI_DDUMP_NODE: {
//      ocs_node_t *node = obj;
        break;
    }
    case OCS_SCSI_DDUMP_IO: {
        ocs_io_t *io = obj;

        ocs_ddump_value(textbuf, "current_state", "%s", ocs_ramd_state_names[io->tgt_io.current_state]);
        ocs_ddump_value(textbuf, "flags", "%#x", io->tgt_io.flags);
        ocs_ddump_value(textbuf, "lba", "%" PRIx64 , io->tgt_io.io_lba);
        ocs_ddump_value(textbuf, "command", "%d", io->tgt_io.cdb[0]);
        ocs_ddump_value(textbuf, "has_first_burst", "%d", io->tgt_io.has_first_burst);
        ocs_ddump_value(textbuf, "first_burst_bytes", "%d", io->tgt_io.first_burst_bytes);
        ocs_ddump_value(textbuf, "lun", "%d", io->tgt_io.lun);
        ocs_ddump_value(textbuf, "lun_is_valid", "%d", io->tgt_io.lun_is_valid);
        ocs_ddump_value(textbuf, "is_read", "%d", io->tgt_io.is_read);
        ocs_ddump_value(textbuf, "io_block_count", "%d", io->tgt_io.io_block_count);
        ocs_ddump_value(textbuf, "acc_block_count", "%d", io->tgt_io.acc_block_count);
        ocs_ddump_value(textbuf, "cur_lba", "%" PRIx64 , io->tgt_io.cur_lba);
        ocs_ddump_value(textbuf, "cur_block_count", "%d", io->tgt_io.cur_block_count);

        break;
    }
    default: {
        break;
    }
    }
}

/**
 * @ingroup io_sm
 * @brief State: ABTS: Wait for the IO to be aborted, and send response.
 *
 * @par Description
 * ABTS is waiting for the IO to be aborted. Once aborted, the
 * response (BA_ACC) is sent.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_abts_wait_io_abort_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *tmfio;

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    tmfio = ctx->app;
    ocs_assert(tmfio->node, NULL);
    ocs_assert(tmfio->ocs, NULL);

    tmfio_sm_trace();
    tmfio->tgt_io.current_state = __OCS_RAMD_ABTS_WAIT_IO_ABORT_RESP;

    switch(evt) {
    case OCS_EVT_IO_ABORTED_BY_TMF:
    case OCS_EVT_IO_ABORT_IGNORED:
        /* send BA_ACC */
        if (ocs_scsi_send_tmf_resp(tmfio, OCS_SCSI_TMF_FUNCTION_SUCCEEDED, NULL,
                       ocs_ramd_tgt_abort_rsp_cb, NULL)
            == 0) {
            /* transition to state to wait for BA_ACC to complete */
            ocs_sm_transition(ctx, __ocs_ramd_wait_abts_acc_cmpl, NULL);
        } else {
            ocs_ramd_io_free(tmfio);
        }
        break;
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        /* cannot abort an ABORT_XRI */
        ocs_ignore_abort_evt(evt, __func__, tmfio, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup io_sm
 * @brief State: ABTS: Wait for the BA_ACC to complete.
 *
 * @par Description
 * The IO has been aborted and a BA_ACC sent. Wait for the BA_ACC to
 * complete, and then free the ABTS IO.
 *
 * @param ctx Remote node sm context.
 * @param evt Event to process.
 * @param arg Per event optional argument.
 *
 * @return Returns NULL.
 */
static void *
__ocs_ramd_wait_abts_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
{
    ocs_io_t *tmfio;

    ocs_assert(ctx, NULL);
    ocs_assert(ctx->app, NULL);
    tmfio = ctx->app;
    ocs_assert(tmfio->node, NULL);
    ocs_assert(tmfio->ocs, NULL);

    tmfio_sm_trace();
    tmfio->tgt_io.current_state = __OCS_RAMD_WAIT_ABTS_ACC_CMPL;

    switch(evt) {
    case OCS_EVT_RESP_CMPL:
        ocs_ramd_io_free(tmfio);
        break;
    case OCS_EVT_ABORT_IO:
    case OCS_EVT_ABORT_IO_NO_RESP: {
        ocs_ignore_abort_evt(evt, __func__, tmfio, (ocs_io_t *)arg);
        break;
    }
    default:
        __ocs_ramd_io_common(__func__, ctx, evt, arg);
        break;
    }

    return NULL;
}

/**
 * @ingroup ramdisc
 * @brief Post a Unit Attention condition to a node/LUN (I_T nexus).
 *
 * @param node Pointer to a node structure.
 * @param lun LUN number.
 * @param asc Additional Sense Code.
 * @param ascq Additional Sense Code Qualifier.
 *
 * @return None.
 */
static void post_one_ua(ocs_node_t *node, uint32_t lun, uint8_t asc, uint8_t ascq) {
    ocs_ramdisc_ua_queue_t *ua_queue;
    ocs_ramdisc_ua_t *ua_entry;
    ocs_ramdisc_ua_t *next;
    ocs_t *ocs = node->ocs;

    /* If the node is not an initiator it won't have any UA queues */
    if (lun >= node->tgt_node.num_ua_queues) {
        return;
    }

    /* Post the UA to the UA queue for the correct LUN */
    ua_queue = &node->tgt_node.ua_queues[lun];



    /*
     * SAM 5.14: the device server should clear pending unit attention conditions
     * that have the same additional sense code (i.e., the device server should not
     * add the same unit attention condition twice)
     */
    ocs_lock(&ua_queue->ua_queue_lock);
    ocs_list_foreach_safe(&ua_queue->entry_list, ua_entry, next) {
        if (ua_entry->asc == asc) {
            ocs_log_debug(ocs, "Removing old entry for asc 0x%02x for node %d lun %d\n",
                    asc, node->instance_index, lun);
            ocs_list_remove(&ua_queue->entry_list, ua_entry);

        }
    }
    ocs_unlock(&ua_queue->ua_queue_lock);

    ua_entry = ocs_malloc(ocs, sizeof(*ua_entry), OCS_M_NOWAIT | OCS_M_ZERO);
    if (ua_entry != NULL) {
        ua_entry->asc = asc;
        ua_entry->ascq = ascq;
        ocs_list_add_tail(&ua_queue->entry_list, ua_entry);
        ocs_log_debug(ocs, "Posted UA %02x/%02x to node %d lun %d\n", asc, ascq, node->instance_index, lun);
    } else {
        ocs_log_err(ocs, "UA entry allocation failed for node %d, UA is dropped\n",
            node->instance_index);
    }
}

/**
 * @ingroup ramdisc
 * @brief Post a Unit Attention condition to a ramdisc.
 *
 * @par Description
 * Posts a Unit Attention condition to a ramdisc. If use_global_ramd is true,
 * then there is only one ramdisc and all nodes are attached to it. In this
 * case, this function posts the UA to all nodes. If use_global_ramd is false,
 * then there is a ramdisc per sport. In this case, this function posts the UA to
 * all nodes on that sport.
 * @n @n
 * If @c except_node points to a node structure, then that node does not get the UA
 * posted. This is used when the ramdisc has been formatted so that the UA can
 * be posted to all nodes other than the one that requested the format. See <i>SBC 4.10</i>.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc.
 * @param asc Additional Sense Code.
 * @param ascq Additional Sense Code Qualifier.
 * @param except_node Node which should @e not get the UA posted. May be NULL.
 *
 * @return None.
 */
void
ocs_ramd_post_ua(ocs_t *ocs, ocs_ramdisc_t *ramdisc, uint8_t asc, uint8_t ascq, ocs_node_t *except_node)
{
    ocs_domain_t *domain;
    ocs_sport_t *sport;
    ocs_node_t *node;


    if (ocs->tgt_ocs.use_global_ramd) {
        /* Post the UA to all nodes on all sports */
        ocs_device_lock(ocs);
        ocs_list_foreach(&ocs->domain_list, domain) {
            ocs_domain_lock(domain);
            ocs_list_foreach(&domain->sport_list, sport) {
                ocs_sport_lock(sport);
                    ocs_list_foreach(&sport->node_list, node) {
                        if (node != except_node) {
                            post_one_ua(node, ramdisc->lun, asc, ascq);
                        }
                    }
                ocs_sport_unlock(sport);
            }
            ocs_domain_unlock(domain);
        }
        ocs_device_unlock(ocs);
    } else {
        /* Post the UA to all nodes on the sport that this ramdisc is associated with */
        uint32_t i;

        ocs_device_lock(ocs);
        ocs_list_foreach(&ocs->domain_list, domain) {
            ocs_domain_lock(domain);
            ocs_list_foreach(&domain->sport_list, sport) {
                for (i=0;i<sport->tgt_sport.rdisc_count;i++) {
                    if (sport->tgt_sport.rdisc[i] == ramdisc) {
                        ocs_sport_lock(sport);
                            ocs_list_foreach(&sport->node_list, node) {
                                if (node != except_node) {
                                    post_one_ua(node, ramdisc->lun, asc, ascq);
                                }
                            }
                        ocs_sport_unlock(sport);
                    }
                }
            }
            ocs_domain_unlock(domain);
        }
        ocs_device_unlock(ocs);
    }
}

/**
 * @ingroup ramdisc
 * @brief Get a pending Unit Attention, if any.
 *
 * @par Description
 * Given a node and a LUN, check for a pending Unit Attention condition.
 * If there is a pending Unit Attention, the function fills in the
 * ASC and ASCQ for the UA and returns non-zero. If there are no pending
 * UA conditions, the function returns 0. If there is more than one
 * UA condition pending, the function returns the first one found.
 * @n @n
 * This function is on the performance path. It is called for every command
 * received from the initiator, including I/Os.
 *
 * @param ocs Pointer to the ocs structure.
 * @param node Pointer to the node structure.
 * @param lun Logical Unit Number.
 * @param asc Pointer to the location to store the Additional Sense Code.
 * @param ascq Pointer to the location to store the Additional Sense Code Qualifier.
 *
 * @return Returns 1 if a Unit Attention exists, or 0 if not.
 */
int32_t
ocs_ramd_get_ua(ocs_t *ocs, ocs_node_t *node, uint32_t lun, uint8_t *asc, uint8_t *ascq)
{
    ocs_ramdisc_ua_queue_t *ua_queue;
    ocs_ramdisc_ua_t *ua_entry;

    /* If the node is not an initiator it won't have any UA queues */
    if (lun >= node->tgt_node.num_ua_queues) {
        return 0;
    }

    /* Locate the UA queue for this LUN */
    ua_queue = &node->tgt_node.ua_queues[lun];

    ocs_lock(&ua_queue->ua_queue_lock);
    if (ocs_list_empty(&ua_queue->entry_list)) {
        ocs_unlock(&ua_queue->ua_queue_lock);
        return 0;
    }

    ua_entry = ocs_list_get_head(&ua_queue->entry_list);
    ocs_unlock(&ua_queue->ua_queue_lock);

    *asc = ua_entry->asc;
    *ascq = ua_entry->ascq;

    return 1;

}

/**
 * @ingroup ramdisc
 * @brief Clear a Unit Attention condition.
 *
 * @par Description
 * Given a node, LUN, ASC, and ASCQ, this function clears a Unit Attention
 * condition from that node/LUN combination for the given ASC and ASCQ.
 *
 * @param ocs Pointer to the ocs structure.
 * @param node Pointer to the node structure.
 * @param lun Logical Unit Number.
 * @param asc Additional Sense Code.
 * @param ascq Additional Sense Code Qualifier.
 *
 * @return None.
 */
void
ocs_ramd_clear_ua(ocs_t *ocs, ocs_node_t *node, uint32_t lun, uint8_t asc, uint8_t ascq)
{
    ocs_ramdisc_ua_queue_t *ua_queue;
    ocs_ramdisc_ua_t *ua_entry;
    ocs_ramdisc_ua_t *next;

    /* If the node is not an initiator it won't have any UA queues */
    if (lun >= node->tgt_node.num_ua_queues) {
        return;
    }

    /* Locate the UA queue for this LUN */
    ua_queue = &node->tgt_node.ua_queues[lun];

    ocs_lock(&ua_queue->ua_queue_lock);
    ocs_list_foreach_safe(&ua_queue->entry_list, ua_entry, next) {
        if ((ua_entry->asc == asc) && (ua_entry->ascq == ascq)) {
            ocs_list_remove(&ua_queue->entry_list, ua_entry);
            ocs_log_debug(ocs, "Removed UA %02x/%02x from node %d lun %d\n",
                    asc, ascq, node->instance_index, lun);
            break;
        }
    }
    ocs_unlock(&ua_queue->ua_queue_lock);

}

void
ocs_mgmt_ramd_list(ocs_textbuf_t *textbuf, void *object)
{
    ocs_mgmt_start_unnumbered_section(textbuf, "tgt");

    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_blocksize");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_luns");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p_type");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "dif_separate");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "read_block");

    ocs_mgmt_end_unnumbered_section(textbuf, "tgt");
}

int
ocs_mgmt_ramd_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
{
    int retval = -1;
    char qualifier[80];
    char prop_buf[32];

    ocs_mgmt_start_unnumbered_section(textbuf, "tgt");

    snprintf(qualifier, sizeof(qualifier), "%s/tgt", parent);

    /* 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, "ramdisc_size") == 0) {
            ocs_get_property("ramdisc_size", prop_buf, sizeof(prop_buf));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", prop_buf);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramdisc_blocksize") == 0) {
            ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", prop_buf);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "num_luns") == 0) {
            ocs_get_property("num_luns", prop_buf, sizeof(prop_buf));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "num_luns", prop_buf);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "dif_separate") == 0) {
            ocs_get_property("dif_separate", prop_buf, sizeof(prop_buf));
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "dif_separate", ocs_strtoul(prop_buf, NULL, 0));
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "p_type") == 0) {
            ocs_get_property("p_type", prop_buf, sizeof(prop_buf));
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "p_type", prop_buf);
            retval = 0;
        }
    }

    ocs_mgmt_end_unnumbered_section(textbuf, "tgt");

    return retval;
}

void
ocs_mgmt_ramd_get_all(ocs_textbuf_t *textbuf, void *object)
{
    char prop_buf[32];

    ocs_mgmt_start_unnumbered_section(textbuf, "tgt");

    ocs_get_property("ramdisc_size", prop_buf, sizeof(prop_buf));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", prop_buf);
    ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", prop_buf);
    ocs_get_property("num_luns", prop_buf, sizeof(prop_buf));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "num_luns", prop_buf);
    ocs_get_property("p_type", prop_buf, sizeof(prop_buf));
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "p_type", prop_buf);
    ocs_get_property("dif_separate", prop_buf, sizeof(prop_buf));
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "dif_separate", ocs_strtoul(prop_buf, NULL, 0));
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "read_block");

    ocs_mgmt_end_unnumbered_section(textbuf, "tgt");
}

int
ocs_mgmt_ramd_exec(char *parent, char *action_name, void *arg_in, uint32_t arg_in_length,
            void *arg_out, uint32_t arg_out_length, void *object)
{
    char qualifier[80];
    int retval = -1;
    ocs_scsi_tgt_t *tgt_ocs = (ocs_scsi_tgt_t *)object;
    ocs_t *ocs;

    ocs = container_of(tgt_ocs, ocs_t, tgt_ocs);

    ocs_snprintf(qualifier, sizeof(qualifier), "%s/tgt", parent);

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

        /* See if it's a value I can supply */
        if (ocs_strcmp(unqualified_name, "read_block") == 0) {
            retval = ocs_mgmt_read_block(ocs, unqualified_name, arg_in, arg_in_length,
                             arg_out, arg_out_length);
        }
    }

    return retval;
}

static int32_t
ocs_mgmt_read_block(ocs_t *ocs, char *name, void *arg_in, uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length)
{
    uint32_t tgt;
    uint32_t lun;
    uint32_t lba;
    char input_buffer[80];
    ocs_ramdisc_t *ramdisc;
    uint8_t *block;
    uint32_t length;

    if ((arg_in == NULL) ||
        (arg_in_length == 0) ||
        (arg_out == NULL) ||
        (arg_out_length == 0)) {
        return -1;
    }

    if (arg_in_length > sizeof(input_buffer)) {
        arg_in_length = sizeof(input_buffer);
    }

    if (ocs_copy_from_user(input_buffer, arg_in, arg_in_length)) {
        ocs_log_test(ocs, "Failed to copy addr from user\n");
        return -EFAULT;
    }

    if (ocs_sscanf(input_buffer, "%d:%d:%d", &tgt, &lun, &lba) != 3) {
        return -EFAULT;
    }

    ramdisc = ocs_ramd_lookup_by_tgt(ocs, tgt, lun);
    if (ramdisc == NULL) {
        return -EFAULT;
    }

    block = ocs_ramdisc_lba_address(ramdisc, lba);

    length = arg_out_length;

    if (ocs_copy_to_user(arg_out, block, length)) {
        ocs_log_test(ocs, "Failed to copy buffer to user\n");
        return -EFAULT;
    }


    return 0;
}

/**
 * @brief Initialize per port ramdisc structure.
 *
 * @par Description
 * The per port ramdisc persistence data structure is initialized.
 *
 * @param ocs pointer to OCS instance
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_port_rdisc_init(ocs_t *ocs)
{
    ocs_list_init(&ocs->tgt_ocs.port_rdisc_head, ocs_port_rdisc_t, link);
    return 0;
}

/**
 * @brief Free per port ramdisc structure
 *
 * @par Description
 * The per port ramdisc persistence data structure is freed along with the ramdisc
 * objects
 *
 * @param ocs Pointer to OCS instance.
 *
 * @return None.
 */
void
ocs_port_rdisc_free(ocs_t *ocs)
{
    ocs_port_rdisc_t *prd;
    ocs_port_rdisc_t *next;

    ocs_list_foreach_safe(&ocs->tgt_ocs.port_rdisc_head, prd, next) {
        ocs_list_remove(&ocs->tgt_ocs.port_rdisc_head, prd);

        ocs_scsi_ramd_free(ocs, &prd->rdisc, &prd->rdisc_count);

        ocs_free(ocs, prd, sizeof(*prd));
    }
}

/**
 * @brief Find a per port ramdisc instance
 *
 * @par Description
 * A per port ramdisc instance is searched for given its target id (tgt_id),
 * if found, the rdisc/rdisc_count arguments are updated with the persisted
 * ramdisc information.
 *
 * @param ocs Pointer to OCS structure.
 * @param tgt_id Target id.
 * @param rdisc Pointer to ramdiscs.
 * @param rdisc_count Count of ramdiscs.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_port_rdisc_find(ocs_t *ocs, uint32_t tgt_id, ocs_ramdisc_t ***rdisc, uint32_t *rdisc_count)
{
    ocs_port_rdisc_t *prd;
    int32_t rc = -1;

    ocs_list_foreach(&ocs->tgt_ocs.port_rdisc_head, prd) {
        if (prd->tgt_id == tgt_id) {
            *rdisc = prd->rdisc;
            *rdisc_count = prd->rdisc_count;
            rc = 0;
            break;
        }
    }

    return rc;
}

/**
 * @brief Save a per port ramdisc.
 *
 * @par Description
 * The ramdisc instance given by rdisc/rdisc_count is saved in the per port
 * ramdisc persist structure.
 *
 * @param ocs Pointer to OCS structure.
 * @param tgt_id Target id for this ramdisc.
 * @param rdisc Pointer to ramdiscs.
 * @param rdisc_count Count of ramdiscs.
 *
 * @return Returns 0 for success, or a negative error code value on failure.
 */
int32_t
ocs_port_rdisc_save(ocs_t *ocs, uint32_t tgt_id, ocs_ramdisc_t **rdisc, uint32_t rdisc_count)
{
    ocs_port_rdisc_t *port_rdisc;

    port_rdisc = ocs_malloc(ocs, sizeof(*port_rdisc), OCS_M_ZERO|OCS_M_NOWAIT);
    if (port_rdisc == NULL) {
        ocs_log_err(NULL, "ocs_malloc failed\n");
        return -1;
    }
    port_rdisc->tgt_id = tgt_id;
    port_rdisc->rdisc = rdisc;
    port_rdisc->rdisc_count = rdisc_count;
    ocs_list_add_tail(&ocs->tgt_ocs.port_rdisc_head, port_rdisc);
    return 0;
}

#if defined(OCS_INCLUDE_FC)
/**
 * @brief Cancel HAL IOs
 */
void ocs_scsi_tgt_cancel_io(ocs_t *ocs)
{
    /* Flush the WCQE's before cleaning-up the io_inuse list */
    ocs_hal_flush(&ocs->hal);
    ocs_hal_io_cancel(&ocs->hal);
}

/*
 * @brief Wait for all sessions are completely deteled.
 */
void ocs_scsi_tgt_sess_del_wait(ocs_sport_t *sport)
{
    /* Nothing to do in RAMD backend, as session deletion
     * will be serialized.
     */
}

/*
 * @brief Count number of initiators logged in to sport
 *    to use this count reference to wait till
 *    all the sessions are shutdown.
 */
void ocs_scsi_tgt_count_sessions(ocs_t *ocs, uint64_t wwpn)
{

    /*
     * Nothing to do in RAMD backend, as session deletion
     * will be serialized.
     */
}

/*
 * @Brief Bring target port online when target is enabled
 */
int32_t ocs_scsi_tgt_port_online(ocs_t *ocs)
{
    int32_t rc = 0;

    if (ocs->holdoff_link_online == 0) {
        ocs_log_debug(ocs, "Restore port ONLINE\n");
        rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
        if (rc)
            ocs_log_err(ocs, "Failed to bring port online\n");
    }
    return rc;
}
#endif