ocs_driver.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.
 *
 */

#include "ocs.h"
#include "ocs_driver.h"
#include "ocs_vpd.h"
#include "ocs_mgmt.h"
#include "ocs_gendump.h"
#include "ocs_pm.h"
#if defined(OCS_INCLUDE_RAMD)
#include "ocs_ramd.h"
#endif

#include "ocs_params.h"

static void ocs_device_interrupt_handler(ocs_t *ocs, uint32_t vector);

#if defined(OCS_INCLUDE_RAMD)
static int32_t ocs_mgmt_read_block(ocs_t *ocs, char *, void *, uint32_t , void *, uint32_t);
#endif

void ocs_mgmt_driver_list(ocs_textbuf_t *textbuf, void *driver);
void ocs_mgmt_driver_get_all(ocs_textbuf_t *textbuf, void *driver);
int ocs_mgmt_driver_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *driver);
int ocs_mgmt_driver_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
        void *arg_out, uint32_t arg_out_length, void *driver);

static ocs_mgmt_functions_t driver_mgmt_functions = {
    .get_list_handler = ocs_mgmt_driver_list,
    .get_handler = ocs_mgmt_driver_get,
    .get_all_handler = ocs_mgmt_driver_get_all,
    .exec_handler = ocs_mgmt_driver_exec,
};

/**
 * @brief Perform driver wide initialization
 *
 * This function is called prior to enumerating PCI devices, with subsequent calls
 * to ocs_device_attach.  For OCS, this function invokes the back end functions
 * ocs_scsi_tgt_driver_init(), and ocs_scsi_ini_driver_init()
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
int32_t
ocs_device_init(void)
{
    int32_t rc;

    ocs_thread_init();

    /* driver-wide init for target-server */
    if (target) {
        rc = ocs_scsi_tgt_driver_init();
        if (rc) {
            ocs_log_err(NULL, "ocs_scsi_tgt_init failed rc=%d\n", rc);
            return -1;
        }
    }

    /* driver-wide init for initiator-client */
    if (initiator) {
        rc = ocs_scsi_ini_driver_init(initiator);
        if (rc) {
            ocs_log_err(NULL, "ocs_scsi_ini_init failed rc=%d\n", rc);
            ocs_device_shutdown();
            return -ENOMEM;
        }
    }
    return 0;
}

/**
 * @brief Perform device initialization complete
 *
 * This function is called after all PCI device/functions have been enumerated.
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
int32_t
ocs_device_init_complete(void)
{
    return 0;
}

/**
 * @brief Perform driver wide shutdown actions
 *
 * This function is called prior to detatching devices during a driver
 * unload.
 *
 * @return none
 */
void
ocs_device_shutdown(void)
{
}

/**
 * @brief Perform driver wide shutdown complete actions
 *
 * This function is called shutdown for all devices has completed
 *
 * @return none
 */
void
ocs_device_shutdown_complete(void)
{
    if (initiator) {
        ocs_scsi_ini_driver_exit(initiator);
    }
    if (target) {
        ocs_scsi_tgt_driver_exit();
    }
}

/*
 * @brief Allocate ocs device.
 *
 * @param nid Numa node ID
 *
 * @return Returns a pointer to an ocs_t on success, NULL on failure
 */

void *ocs_device_alloc(int32_t nid)
{
    ocs_t *ocs = NULL;
    uint32_t i;

#if defined(OCS_INCLUDE_ISCSI)
    if (initiator && (hw_cmpl_context == OCS_HW_CMPL_CONTEXT_THREAD)) {
        ocs_log_test(NULL, "iSCSI initiator requires tasklets, setting hw_cmpl_context to %d\n",
            OCS_HW_CMPL_CONTEXT_TASKLET);
        hw_cmpl_context = OCS_HW_CMPL_CONTEXT_TASKLET;
    }
#endif

    /* Allocate memory using nid only if it has valid NUMA node avalible*/
    if (nid < 0) {
        ocs = ocs_malloc(NULL, sizeof(*ocs), OCS_M_NOWAIT | OCS_M_ZERO);
    } else {
        ocs = ocs_malloc_nid(nid, sizeof(*ocs), OCS_M_NOWAIT | OCS_M_ZERO);
    }
    if (ocs != NULL) {
        for (i = 0; i < ARRAY_SIZE(ocs_devices); i ++) {
            if (ocs_devices[i] == NULL) {
                ocs->instance_index = i;
                ocs_devices[i] = ocs;
                break;
            }
        }

        if (i == ARRAY_SIZE(ocs_devices)) {
            ocs_log_err(NULL, "failed\n");
            ocs_free(ocs, ocs, sizeof(*ocs));
            ocs = NULL;
        } else {
            /* If enabled, initailize a RAM logging buffer */
            if (logdest & 2) {
                ocs->ramlog = ocs_ramlog_init(ocs, ramlog_size/OCS_RAMLOG_DEFAULT_BUFFERS,
                    OCS_RAMLOG_DEFAULT_BUFFERS);
                /* If NULL was returned, then we'll simply skip using the ramlog but */
                /* set logdest to 1 to ensure that we at least get default logging.  */
                if (ocs->ramlog == NULL) {
                    logdest = 1;
                }
            }

            /* initialize a saved ddump */
            if (ddump_saved_size) {
                if (ocs_textbuf_alloc(ocs, &ocs->ddump_saved, ddump_saved_size)) {
                    ocs_log_err(ocs, "failed to allocate memory for saved ddump\n");
                }
            }

#if defined(ENABLE_LOCK_DEBUG)
            ocs_list_init(&ocs->ocs_os.locklist, ocs_lock_t, link);
            ocs_lock_init(NULL, &ocs->ocs_os.locklist_lock, "locklist_lock[%d]", ocs->instance_index);
#endif
            ocs_list_init(&ocs->domain_list, ocs_domain_t, link);
            ocs->ocs_os.interrupt_cb = ocs_device_interrupt_handler;
            ocs_device_lock_init(ocs);
            ocs->drv_ocs.attached = FALSE;
            ocs->ocs_os.hw_cmpl_context = hw_cmpl_context;
            ocs->mgmt_functions = &driver_mgmt_functions;
        }
    }
    return ocs;
}

/**
 * @brief free ocs device
 *
 * @param ocs pointer to ocs structure
 *
 * @return none
 */

void ocs_device_free(ocs_t *ocs)
{
    if (ocs != NULL) {
        ocs_textbuf_free(ocs, &ocs->ddump_saved);
        ocs_ramlog_free(ocs, ocs->ramlog);
        ocs_devices[ocs->instance_index] = NULL;
        ocs_device_lock_free(ocs);
#if defined(ENABLE_LOCK_DEBUG)
        {
            ocs_os_t *os = &ocs->ocs_os;
            ocs_lock_t *l;
            uint32_t count = 0;
            ocs_list_foreach(&os->locklist, l) {
                ocs_log_test(os, "%s not freed\n", l->name);
                count++;
            }
            if (count == 0) {
                ocs_log_debug(ocs, "all lock objects freed\n");
            }
        }
#endif
        ocs_free(ocs, ocs, sizeof(*ocs));
    }
}

/**
 * @brief return the number of interrupts required per HBA
 *
 * @param ocs pointer to ocs structure
 *
 * @return the number of interrupts or negative value on error.
 */
int32_t ocs_device_interrupts_required(ocs_t *ocs)
{
    /* So we set the port type properly in ocs_hal_setup */
    ocs->enable_ini = initiator;
    ocs->enable_tgt = target;

    return ocs_iscsi_interrupts_required((ocs_os_handle_t)ocs, &ocs->hal);
}

/**
 * @brief Initialize resources when pci devices attach
 *
 * @param ocs pointer to ocs structure
 *
 * @return 0 for success, a negative error code value for failure.
 */

int32_t
ocs_device_attach(ocs_t *ocs)
{
    uint32_t rc = 0;

    if (ocs->drv_ocs.attached) {
        ocs_log_test(ocs, "Device is already attached\n");
        rc = -1;
    } else {
        ocs_snprintf(ocs->display_name, sizeof(ocs->display_name), "[%s%d] ", "i",  ocs->instance_index);

        /* copy the module paramaters to ocs */
        ocs->enable_ini = initiator;
        ocs->enable_tgt = target;
        ocs->num_scsi_ios = num_scsi_ios;
        ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device);
        ocs->driver_version = DRV_VERSION;

#if defined(OCS_INCLUDE_RAMD)
        ocs->num_tgts = num_tgts;
        ocs->global_ramdisc = global_ramdisc;
#else
        /* num_tgts is used in a lot of code.  Set to 1 for now */
        ocs->num_tgts = 1;
#endif

        ocs_strcpy(ocs->local_ip, local_ip);
        ocs_strcpy(ocs->local_subnet, local_subnet);
        ocs_strcpy(ocs->iqn_prefix, iqn_prefix);
        ocs_strcpy(ocs->iqn_suffix,
               (iqn_suffix[ocs->instance_index] ?
                iqn_suffix[ocs->instance_index] :
                OCS_IQN_SUFFIX_DEFAULT));
        ocs_strcpy(ocs->gateway, gateway);
        ocs->tcp_window_size = tcp_window_size;
        ocs->tcp_window_scale = tcp_window_scale;
        ocs->num_scsi_ios = num_scsi_ios;
        ocs->ctrlmask = ctrlmask;
        ocs->num_cxns = num_cxns;
        ocs->hal_war_version = hal_war_version;
        ocs->max_cxns_per_session = OCS_ISCSI_MAX_CXNS_PER_SESSION;

        ocs->enable_sgl_chaining = (enable_sgl_chaining == 0 ? FALSE : TRUE);
        ocs->enable_immediate_data = (enable_immediate_data == 0 ? FALSE : TRUE);
        ocs->enable_hdr_digest = (enable_hdr_digest == 0 ? FALSE : TRUE);
        ocs->enable_data_digest = (enable_data_digest == 0 ? FALSE : TRUE);
        ocs->enable_jumbo_frame = (enable_jumbo_frame == 0 ? FALSE : TRUE);
        ocs->require_chap = FALSE;

        /* non-zero target IO timer not supported for iSCSI */
        ocs->target_io_timer_sec = 0;

        if (max_sge_size < 1024 &&
            max_sge_size > 65536) {
            ocs_log_test(ocs, "Ignoring invalid max_sge_size\n");
        } else {
            ocs->max_sge_size = max_sge_size;
        }
        ocs->post_sgl_config = post_sgl_config;

        rc = ocs_iscsi_initialize(ocs, &ocs->iscsi, &ocs->hal, ocs->instance_index);
        if (rc == 0) {
            rc = ocs_start_event_processing(&ocs->ocs_os);
        }
    }
    ocs->desc = ocs->hal.sli.config.modeldesc;
    ocs_log_info(ocs, "adapter model description: %s\n", ocs->hal.sli.config.modeldesc);
    if (rc == 0) {
        ocs->drv_ocs.attached = TRUE;
    } else {
        ocs_teardown_msix((ocs_os_t *)ocs);
    }

    return rc;
}

/**
 * @brief interrupt handler
 *
 * Interrupt handler
 *
 * @param ocs pointer to ocs structure
 * @param vector Zero-based interrupt vector number.
 *
 * @return none
 */

static void
ocs_device_interrupt_handler(ocs_t *ocs, uint32_t vector)
{
    ocs_hal_process(&ocs->hal, vector, ocs->max_isr_time_msec);
}

/**
 * @brief free resources when pci device detach
 *
 * @param ocs pointer to ocs structure
 *
 * @return 0 for success, a negative error code value for failure.
 */

int32_t
ocs_device_detach(ocs_t *ocs)
{
    if (ocs != NULL) {
        if (!ocs->drv_ocs.attached) {
            ocs_log_test(ocs, "Device is not attached\n");
            return -1;
        }

        /* Check and invalidate active connections before disabling interrupts */
        ocs_iscsi_cxn_req_invalidate(&ocs->iscsi);

        ocs_intr_disable(ocs);

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

        ocs_stop_event_processing(&ocs->ocs_os);

        ocs_xport_free(ocs->xport);
        ocs->xport = NULL;

        ocs->drv_ocs.attached = FALSE;
    }

    return 0;
}

/**
 * @brief get driver wide property value
 *
 * Return valued driver wide property.   All property values using this interface
 * are returned as null terminated text.
 *
 * @param prop_name property name
 * @param buffer pointer to buffer
 * @param buffer_len length of buffer in bytes
 *
 * @return returns 0 for success, a negative error code value for failure.
 */

int32_t
ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len)
{
    if (ocs_strcmp(prop_name, "initiator") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", initiator);
    } else if (ocs_strcmp(prop_name, "target") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", target);
#if defined(OCS_INCLUDE_RAMD)
    } else if (ocs_strcmp(prop_name, "global_ramdisc") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", global_ramdisc);
    } else if (ocs_strcmp(prop_name, "ramdisc_size") == 0) {
        ocs_strncpy(buffer, ramdisc_size, buffer_len);
    } else if (ocs_strcmp(prop_name, "ramdisc_blocksize") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", ramdisc_blocksize);
    } else if (ocs_strcmp(prop_name, "num_luns") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", num_luns);
    } else if (ocs_strcmp(prop_name, "p_type") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", p_type);
    } else if (ocs_strcmp(prop_name, "stub_res6_rel6") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", stub_res6_rel6);
    } else if (strcmp(prop_name, "ramd_threading") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", ramd_threading);
    } else if (strcmp(prop_name, "thread_cmds") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", thread_cmds);
    } else if (strcmp(prop_name, "external_dif") == 0) {
        ocs_strncpy(buffer, external_dif, buffer_len);
    } else if (ocs_strcmp(prop_name, "num_tgts") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", num_tgts);
#endif
    } else if (ocs_strcmp(prop_name, "dif_separate") == 0) {
        /* iSCSI only supports DIF separate */
        ocs_snprintf(buffer, buffer_len, "%d", 1);
    } else {
        ocs_log_test(NULL, "Error: unknown property %s\n", prop_name);
        ocs_snprintf(buffer, buffer_len, "%s", "");
        return -1;
    }
    return 0;
}

/**
 * @brief return OCS instance display name
 *
 * returns const char string of OCS instance display name
 *
 * @param os pointer to OS (ocs_t) object
 *
 * @return return display name
 */

const char *ocs_display_name(void *os)
{
    ocs_t *ocs = os;
    ocs_assert(ocs, "[?]");
    return ocs->display_name;
}

void ocs_mgmt_driver_list(ocs_textbuf_t *textbuf, void *object)
{

    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    /* Readonly values */
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ctrlmask");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_cxns");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ddump_saved_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_data_digest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_hdr_digest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_immediate_data");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_jumbo_frame");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_sgl_chaining");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "gateway");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hal_war_version");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hw_cmpl_context");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "initiator");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "local_ip");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "local_subnet");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "logdest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "max_sge_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_luns");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_scsi_ios");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "post_sgl_config");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "global_ramdisc");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_blocksize");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramlog_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tcp_window_scale");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tcp_window_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_tgts");

    /* Actions */
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "clear_ramlog");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "read_block");

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");

    return;
}

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

    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    ocs_snprintf(qualifier, sizeof(qualifier), "%s/driver", 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, "ctrlmask") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ctrlmask", "0x%x", ctrlmask);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "num_cxns") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_cxns", "%d", num_cxns);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ddump_saved_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_data_digest") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_data_digest", enable_data_digest);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_hdr_digest") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hdr_digest", enable_hdr_digest);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_immediate_data") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_immediate_data", enable_immediate_data);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_jumbo_frame") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_jumbo_frame", enable_jumbo_frame);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_sgl_chaining") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_sgl_chaining", enable_sgl_chaining);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "gateway") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "gateway", gateway);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hal_war_version") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "hal_war_version", hal_war_version);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hw_cmpl_context") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_cmpl_context", "%d", hw_cmpl_context);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "initiator") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "initiator", initiator);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "local_ip") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "local_ip", local_ip);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "local_subnet") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "local_subnet", local_subnet);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "logdest") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logdest", "0x%x", logdest);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "max_sge_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "max_sge_size", "%d", max_sge_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "num_scsi_ios") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "post_sgl_config") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "post_sgl_config", "%d", post_sgl_config);
            retval = 0;
#if defined(OCS_INCLUDE_RAMD)
        } else if (ocs_strcmp(unqualified_name, "num_luns") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "global_ramdisc") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "global_ramdisc", "%d", global_ramdisc);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramdisc_blocksize") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", "%d", ramdisc_blocksize);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramdisc_size") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "num_tgts") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_tgts", "%d", num_tgts);
            retval = 0;
#endif
        } else if (ocs_strcmp(unqualified_name, "ramlog_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramlog_size", "%d", ramlog_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "target") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tcp_window_scale") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_scale", "%d", tcp_window_scale);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tcp_window_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_size", "%d", tcp_window_size);
            retval = 0;
        }
    }

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");

    return retval;
}

void ocs_mgmt_driver_get_all(ocs_textbuf_t *textbuf, void *object)
{
    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ctrlmask", "0x%x", ctrlmask);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_cxns", "%d", num_cxns);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_data_digest", enable_data_digest);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hdr_digest", enable_hdr_digest);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_immediate_data", enable_immediate_data);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_jumbo_frame", enable_jumbo_frame);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_sgl_chaining", enable_sgl_chaining);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "gateway", gateway);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "hal_war_version", hal_war_version);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_cmpl_context", "%d", hw_cmpl_context);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "initiator", initiator);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "local_ip", local_ip);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "local_subnet", local_subnet);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logdest", "0x%x", logdest);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "max_sge_size", "%d", max_sge_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "post_sgl_config", "%d", post_sgl_config);
#if defined(OCS_INCLUDE_RAMD)
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "global_ramdisc", "%d", global_ramdisc);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", "%d", ramdisc_blocksize);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_tgts", "%d", num_tgts);
#endif
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramlog_size", "%d", ramlog_size);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_scale", "%d", tcp_window_scale);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_size", "%d", tcp_window_size);

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");
}


int ocs_mgmt_driver_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_t *ocs = (ocs_t *)object;

    ocs_snprintf(qualifier, sizeof(qualifier), "%s/driver", 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;

        if (ocs_strcmp(unqualified_name, "clear_ramlog") == 0) {
            char local_arg_in[128];
            int clear_start_of_day = 0;
            int clear_recent = 0;
            if (arg_in) {
                if (ocs_copy_from_user(local_arg_in, arg_in,
                    MIN(arg_in_length, sizeof(local_arg_in)-1))) {
                    ocs_log_test(ocs, "Error: copy arg_in from user failed\n");
                    return -1;
                }

                local_arg_in[sizeof(local_arg_in)-1] = 0;
                if (ocs_strcmp(local_arg_in, "recent") == 0) {
                    clear_recent = 1;
                } else if (ocs_strcmp(local_arg_in, "start_of_day") == 0) {
                    clear_start_of_day = 1;
                } else if (ocs_strcmp(local_arg_in, "all") == 0) {
                    clear_recent = 1;
                    clear_start_of_day = 1;
                }
            } else {
                clear_recent = 1;
                clear_start_of_day = 1;
            }

            ocs_log_debug(ocs, "Clear ramlog:%s%s\n", clear_start_of_day ? " start_of_day" : "",
                clear_recent ? " recent" : "");

            ocs_ramlog_clear(ocs, ocs->ramlog, clear_start_of_day, clear_recent);
            retval = 0;
        }
#if defined(OCS_INCLUDE_RAMD)
        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);
        }
#endif
    }

    return retval;
}

#if defined(OCS_INCLUDE_RAMD)
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;
}
#endif