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 "version.h"
#include "ocs_vpd.h"
#include "ocs_params.h"

char ocs_version[] = "version: ocs_iscsi_ramd: " DRV_VERSION;

ocs_t *ocs_devices[MAX_OCS_DEVICES];
uint32_t ocs_instance_count = 0;

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,
};

/*
 * PARAM_LIST: expand to initialized declarations
 */
#define P(type, name, value, desc) type name = value;
PARAM_LIST
#undef P

/**
 * @brief Perform driver-wide initialization.
 *
 * @par
 * 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, or 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.
 * 
 * @par
 * 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 shut down actions.
 *
 * @par
 * This function is called prior to detaching devices during a driver
 * unload.
 *
 * @return None.
 */
void
ocs_device_shutdown(void)
{
}


/**
 * @brief Returns a pointer to the ocs structure given the instance index.
 *
 * @par
 * A pointer to an ocs structure is returned given an instance index.
 *
 * @param index Index to ocs_devices array.
 *
 * @return Returns ocs pointer.
 */

ocs_t *ocs_get_instance(uint32_t index)
{
        if (index < ARRAY_SIZE(ocs_devices)) {
                return ocs_devices[index];
        }
        return NULL;
}

/**
 * @brief Return the instance index of an opaque ocs structure.
 *
 * @par
 * Returns the ocs instance index.
 *
 * @param os Pointer to the ocs instance.
 *
 * @return Pointer to the ocs instance index.
 */
uint32_t
ocs_instance(void *os)
{
    ocs_t *ocs = os;
    return ocs->instance_index;
}


/**
 * @brief Instantiate the PCI device.
 *
 * @par
 * This is the PCI device probe entry point, called by the Linux PCI subsystem once for
 * each matching device/function.
 * @n @n
 * The ocs structure is allocated, and initialized
 
 * @param nid NUMA node ID.
 *
 * @return Returns the pointer to the allocated OCS structure.
 */
void *
ocs_device_alloc(uint32_t nid)
{
    ocs_t *ocs;

    ocs = ocs_malloc(NULL, sizeof(ocs_t), OCS_M_NOWAIT | OCS_M_ZERO);
    if (ocs == NULL) {
        ocs_log_err(ocs, "memory allocation failed for ocs_t\n");
        return NULL;
    }
    ocs->instance_index = ocs_instance_count;
    ocs_devices[ocs->instance_index] = ocs;
    ocs_instance_count++;

    /* 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");
        }
    }

    ocs->mgmt_functions = &driver_mgmt_functions;

#if defined(ENABLE_LOCK_DEBUG)
    ocs_lock_init(NULL, &ocs->ocs_os.locklist_lock, "locklist_lock[%d]", ocs->instance_index);
    ocs_list_init(&ocs->ocs_os.locklist, ocs_lock_t, link);
#endif

    /* Save userspace mask value */
    ocs->drv_ocs.uspace_thread_per_port = (uspacemask & (1U << 0)) == 0;
    ocs->drv_ocs.uspace_threads_block = (uspacemask & (1U << 1)) == 0;

    return ocs;
}

void
ocs_device_free(ocs_t *ocs)
{
    if (ocs) {
        ocs_textbuf_free(ocs, &ocs->ddump_saved);
        ocs_ramlog_free(ocs, ocs->ramlog);
        ocs_devices[ocs->instance_index] = NULL;

#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(NULL, ocs, sizeof(*ocs));
    }
}

/**
 * @brief Returns the number of interrupts required per HBA.
 *
 * @param ocs Pointer to the ocs structure.
 *
 * @return Returns the number of interrupts.
 */
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);
}

int32_t
ocs_device_attach(ocs_t *ocs)
{
    unsigned int    rc;

    /* any ocs initialization */
    ocs->enable_ini = initiator;
    ocs->enable_tgt = target;
    ocs_device_lock_init(ocs);
    ocs_list_init(&ocs->domain_list, ocs_domain_t, link);

    snprintf(ocs->display_name, sizeof(ocs->display_name), "[%s%d] ", "i",  ocs->instance_index);

    /* copy the module paramaters to ocs */
    ocs->ctrlmask = ctrlmask;
    ocs->num_cxns = num_cxns;
    ocs->num_tgts = num_tgts;
    ocs->global_ramdisc = global_ramdisc;
    ocs->num_scsi_ios = num_scsi_ios;
    ocs_strcpy(ocs->local_ip, local_ip);
    ocs_strcpy(ocs->local_subnet, local_subnet);
    ocs_strcpy(ocs->gateway, gateway);
    ocs->tcp_window_size = tcp_window_size;
    ocs->tcp_window_scale = tcp_window_scale;
    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->max_cxns_per_session = OCS_ISCSI_MAX_CXNS_PER_SESSION;
    ocs->driver_version = DRV_VERSION;
    ocs->hal_war_version = hal_war_version;

    /* 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_os_handle_t)ocs, &ocs->iscsi, &ocs->hal, ocs->instance_index);
    if (rc) {
        ocs_log_err(ocs, "ocs_iscsi_initialize failed\n");
    }

    return rc;
}

/**
 * @brief Remove the PCI device instance.
 *
 * @par
 * Called when the driver is unloaded, once for each PCI device/function instance.
 *
 * @param ocs Pointer to the ocs structure.
 *
 * @return None.
 */

int32_t
ocs_device_detach(ocs_t *ocs)
{
    int32_t rc = 0;
    if (ocs) {

        if (ocs->enable_tgt) {
            ocs_scsi_tgt_del_device(ocs);
        }
        if (ocs->enable_ini) {
            ocs_scsi_ini_del_device(ocs);
        }

        rc = ocs_iscsi_teardown(&ocs->iscsi);
        if (rc) {
            ocs_log_err(ocs, "ocs_iscsi_teardown() failed: %d\n", rc);
        }
        ocs_xport_free(ocs->xport);
        ocs->xport = NULL;
    }
    return rc;
}

int32_t
ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len)
{
    if (ocs_strcmp(prop_name, "num_tgts") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", num_tgts);
    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, "initiator") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", initiator);
    else if (ocs_strcmp(prop_name, "target") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", target);
    else if (ocs_strcmp(prop_name, "p_type") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", p_type);
    else if (ocs_strcmp(prop_name, "dif_separate") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", 1);
    else {
        printf("Error: %s: unknown property %s\n", __func__, prop_name);
        ocs_snprintf(buffer, buffer_len, "%s", "");
        return -1;
    }
    return 0;
}

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");

    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, "num_tgts");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_sgl_chaining");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_immediate_data");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_hdr_digest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_data_digest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_jumbo_frame");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "max_sge_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "post_sgl_config");
    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, "gateway");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tcp_window_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tcp_window_scale");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "initiator");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "global_ramdisc");
    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, "num_scsi_ios");

    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");

    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", "%d", 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, "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, "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_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_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_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, "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, "post_sgl_config") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "post_sgl_config", "%d", post_sgl_config);
            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, "gateway") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "gateway", gateway);
            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;
        } 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, "num_tgts") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_tgts", "%d", num_tgts);
            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, "target") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
            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_size") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
            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, "num_luns") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "p_type") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p_type", "%d", p_type);
            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;
        }
    }

    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", "%d", ctrlmask);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_cxns", "%d", num_cxns);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_sgl_chaining", enable_sgl_chaining);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_immediate_data", enable_immediate_data);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hdr_digest", enable_hdr_digest);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_data_digest", enable_data_digest);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_jumbo_frame", enable_jumbo_frame);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "max_sge_size", "%d", max_sge_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "post_sgl_config", "%d", post_sgl_config);
    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_string(textbuf, MGMT_MODE_RD, "gateway", gateway);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_size", "%d", tcp_window_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tcp_window_scale", "%d", tcp_window_scale);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_tgts", "%d", num_tgts);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "initiator", initiator);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "global_ramdisc", "%d", global_ramdisc);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", "%d", ramdisc_blocksize);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p_type", "%d", p_type);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");
}

int ocs_mgmt_driver_set(char *parent, char *name, char *value)
{
    return -1;
}


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)
{
    return -1;
}

/**
 * @brief Perform driver-wide shutdown complete actions.
 *
 * @par
 * This function is called shutdown for all devices has completed.
 *
 * @return None.
 */
void
ocs_device_shutdown_complete(void)
{
}