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_elxu.h"
#include "ocs_driver.h"
#include "ocs_vpd.h"
#include "ocs_params.h"
#include "ocs_gendump.h"
#include "ocs_ocsu.h"

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

static ocs_t *ocs_devices[MAX_OCS_DEVICES];

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 void ocs_driver_print_module_params(void);

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: generate parameter declarations with initializers */
#define P(type, name, value, desc)  type name = value;
PARAM_LIST
#undef P

int32_t
ocs_device_init(void)
{
    hal_global.queue_topology_string = queue_topology;
    int32_t rc;

    ocs_thread_init();

    /* Call back-end driver wide initialzation functions */

        /* driver-wide init for target-server */
        if (target) {
        rc = ocs_scsi_tgt_driver_init();
        if (rc) {
            return rc;
        }
    }

        /* driver-wide init for initiator-client */
        if (initiator) {
        rc = ocs_scsi_ini_driver_init(initiator);
        if (rc) {
            return rc;
        }
    }

    /* Print module Parameters */
    ocs_driver_print_module_params();

    return 0;
}

/*
 * @brief allocate ocs device
 *
 * @param nid Numa node ID
 *
 * @return returns pointer to allocated OCS structure
 */
void *
ocs_device_alloc(uint32_t nid)
{
    ocs_t *ocs = NULL;
        uint32_t i;

    ocs = ocs_malloc(NULL, sizeof(*ocs), OCS_M_NOWAIT | OCS_M_ZERO);
    if (ocs == NULL) {
        ocs_log_err(ocs, "memory allocation failed for ocs_t\n");
        return NULL;
    }

    for (i = 0; i < ARRAY_SIZE(ocs_devices); i ++) {
        if (ocs_devices[i] == NULL) {
            ocs->instance_index = i;
            ocs_devices[ocs->instance_index] = ocs;
                        break;
        }
    }

    if (i == ARRAY_SIZE(ocs_devices)) {
        ocs_log_err(NULL, "failed\n");
        ocs_free(ocs, ocs, sizeof(*ocs));
        ocs = NULL;
                return ocs;
    }

    /* 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_list_init(&ocs->domain_list, ocs_domain_t, link);
//TODO:     ocs->ocs_os.interrupt_cb = ocs_device_interrupt_handler;

#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

    ocs_device_lock_init(ocs);
    ocs->drv_ocs.attached = FALSE;
    ocs->mgmt_functions = &driver_mgmt_functions;

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

/**
 * @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.
 */
int32_t
ocs_device_interrupts_required(ocs_t *ocs)
{
    int32_t rc;

    rc = ocs_hal_setup(&ocs->hal, ocs, SLI4_PORT_TYPE_FC);
    if (rc) {
        return -1;
    }
    return ocs_hal_qtop_eq_count(&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_warn(ocs, "Device is already attached\n");
                rc = -1;
        } else {

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

        ocs->enable_ini = initiator;
        ocs->enable_tgt = target;
        ocs->ctrlmask = ctrlmask;
        ocs->topology = topology;
        ocs->speed = speed;
        ocs->ethernet_license = ethernet_license;
        ocs->num_scsi_ios = num_scsi_ios;
        ocs->enable_hlm = enable_hlm;
        ocs->enable_fw_ag_rsp = enable_fw_ag_rsp;
        ocs->hlm_group_size = hlm_group_size;
        ocs->hal_war_version = hal_war_version;
        ocs->explicit_buffer_list = explicit_buffer_list;
        ocs->esoc = esoc;
        ocs->logmask = logmask;
        ocs->num_vports = num_vports;
        ocs->enable_dpp = enable_dpp;
        ocs->external_loopback = external_loopback;
        ocs->target_io_timer_sec = target_io_timer;
        ocs->tgt_wqe_timer = target_wqe_timer;
        ocs->driver_version = DRV_VERSION;
        ocs->hal_bounce = hal_bounce;
        ocs->rq_threads = rq_threads;
        ocs->rq_selection_policy = rq_selection_policy;
        ocs->rr_quanta = rr_quanta;
        ocs->filter_def = filter_def;
            ocs->max_isr_time_msec = OCS_OS_MAX_ISR_TIME_MSEC;
            ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device);
            ocs->fw_version = (const char*) ocs_hal_get_ptr(&ocs->hal, OCS_HAL_FW_REV);
        ocs->sliport_pause_errors = sliport_pause_errors;
        ocs->enable_bbcr = enable_bbcr;

        ocs->tgt_rscn_delay_msec = 0;
        ocs->tgt_rscn_period_msec = 0;

        /* Allocate transport object and bring online */
        ocs->xport = ocs_xport_alloc(ocs);
        if (ocs->xport == NULL) {
            ocs_log_err(ocs, "failed to allocate transport object\n");
            rc = -1;
        } else if (ocs_xport_attach(ocs->xport) != 0) {
            ocs_log_err(ocs, "failed to attach transport object\n");
            rc = -1;
        } else if (ocs_xport_initialize(ocs->xport) != 0) {
            ocs_log_err(ocs, "failed to initialize transport object\n");
            rc = -1;
        } else {
                        if ((holdoff_link_online == 2) && ((!ocs->enable_tgt) && (ocs->enable_ini))) {
                                 holdoff_link_online = 0;
                        }

                        if (holdoff_link_online == 0) {
                                if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE) != 0) {
                                         /*
                                          * Only log a message.  Don't return the error,
                                          * so that the driver will still attach to this port.
                                         */
                                         ocs_log_err(ocs, "failed to bring port online\n");
                                 }
                         }

        }
        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_xport_free(ocs->xport);
                                ocs->xport = NULL;
                        }
        }
    return rc;
}

/**
 * @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)
{
    int32_t rc = 0;

    if (ocs != NULL) {

                if (!ocs->drv_ocs.attached) {
                        ocs_log_warn(ocs, "Device is not attached\n");
                        return -1;
                }
        rc = ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN);
        if (rc) {
            ocs_log_err(ocs, "Transport Shutdown timed out\n");
        }
        if (uspacemask & (1U << 1)) {
            ocs_log_test(ocs, "terminating event threads for OCS device: %d\n",
                     ocs->instance_index);
            ocsu_terminate_event_threads(ocs);
        }
        if (ocs_xport_detach(ocs->xport) != 0) {
            ocs_log_err(ocs, "Transport detach failed\n");
        }

        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, "ramdisc_size") == 0) {
        strncpy(buffer, ramdisc_size, buffer_len);
    } else if (ocs_strcmp(prop_name, "ramdisc_blocksize") == 0) {
        snprintf(buffer, buffer_len, "%d", ramdisc_blocksize);
    } else if (ocs_strcmp(prop_name, "num_luns") == 0) {
        snprintf(buffer, buffer_len, "%d", num_luns);
    } else if (ocs_strcmp(prop_name, "initiator") == 0) {
        snprintf(buffer, buffer_len, "%d", initiator);
    } else if (ocs_strcmp(prop_name, "target") == 0) {
        snprintf(buffer, buffer_len, "%d", target);
    } else if (ocs_strcmp(prop_name, "wwn_bump") == 0) {
        snprintf(buffer, buffer_len, "%s", wwn_bump);
    } else if (ocs_strcmp(prop_name, "p_type") == 0) {
        snprintf(buffer, buffer_len, "%d", p_type);
    } else if (ocs_strcmp(prop_name, "dif_separate") == 0) {
        snprintf(buffer, buffer_len, "%d", dif_separate);
    } else if (ocs_strcmp(prop_name, "global_ramdisc") == 0) {
        snprintf(buffer, buffer_len, "%d", global_ramdisc);
    } else if (ocs_strcmp(prop_name, "ncpu") == 0) {
        ocs_snprintf(buffer, buffer_len, "%ld", sysconf(_SC_NPROCESSORS_ONLN));
    } else if (ocs_strcmp(prop_name, "ramd_threading") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", ramd_threading);
    } else if (ocs_strcmp(prop_name, "thread_cmds") == 0) {
        ocs_snprintf(buffer, buffer_len, "%d", thread_cmds);
        } else if (ocs_strcmp(prop_name, "external_dif") == 0) {
                ocs_strncpy(buffer, external_dif, buffer_len);
    } else if (strcmp(prop_name, "esoc") == 0) { 
                ocs_snprintf(buffer, buffer_len, "%d", esoc);
    } else if (strcmp(prop_name, "tow_xri_cnt") == 0) {
                ocs_snprintf(buffer, buffer_len, "%d", tow_xri_cnt);
    }
    else {
        ocs_log_test(NULL, "Error: unknown property %s\n", prop_name);
        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;
}

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

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

/**
 * @brief Return instance index of an opaque ocs structure
 *
 * Returns the ocs instance index
 *
 * @param os pointer to ocs instance
 *
 * @return pointer to ocs instance index
 */
uint32_t
ocs_instance(void *os)
{
    ocs_t *ocs = os;

    return ocs != NULL ? ocs->instance_index : UINT32_MAX;
}

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, "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, "initiator");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "logmask");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ctrlmask");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwn_bump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "topology");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "speed");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p_type");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "holdoff_link_online");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_hlm");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_fw_ag_rsp");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hlm_group_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "external_loopback");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target_io_timer");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "auto_xfer_rdy_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "esoc");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "auto_xfer_rdy_xri_cnt");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "clear_ramlog");

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");
}

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, "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, "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, "logmask") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logmask", "0x%x", logmask);
            retval = 0;
        } else 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, "wwn_bump") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "wwn_bump", wwn_bump);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "topology") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "topology", "%d", topology);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "speed") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "speed", "%d", speed);
            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, "holdoff_link_online") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "holdoff_link_online", holdoff_link_online);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_hlm") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hlm", enable_hlm);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_fw_ag_rsp") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_fw_ag_rsp", enable_fw_ag_rsp);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hlm_group_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hlm_group_size", "%d", hlm_group_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tow_feature") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_feature", "%d", tow_feature);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tow_xri_cnt") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_xri_cnt", "%d", tow_xri_cnt);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tow_io_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_io_size", "%d", tow_io_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "esoc") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "esoc", "%d", esoc);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "external_loopback") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "external_loopback", external_loopback);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "target_io_timer") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_io_timer", "%d", target_io_timer);
            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, "global_ramdisc", "%d", global_ramdisc);
    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, "logmask", "0x%x", logmask);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "loglevel", "%d", loglevel);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ctrlmask", "0x%x", ctrlmask);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "wwn_bump", wwn_bump);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "hal_war_version", hal_war_version);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "filter_def", filter_def);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "topology", "%d", topology);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "speed", "%d", speed);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "holdoff_link_online", holdoff_link_online);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hlm", enable_hlm);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_fw_ag_rsp", enable_fw_ag_rsp);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hlm_group_size", "%d", hlm_group_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_feature", "%d", tow_feature);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_io_size", "%d", tow_io_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tow_xri_cnt", "%d", tow_xri_cnt);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "esoc", "%d", esoc);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "external_loopback", external_loopback);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_io_timer", "%d", target_io_timer);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ethernet_license", "%d", ethernet_license);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_vports", "%d", num_vports);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rq_threads", "%d", rq_threads);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rr_quanta", "%d", rr_quanta);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "explicit_buffer_list", "%d", explicit_buffer_list);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "external_loopback", "%d", external_loopback);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "queue_topology", queue_topology);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "dif_separate", dif_separate);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rq_selection_policy", "%d", rq_selection_policy);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cq_process_limit", "%d", cq_process_limit);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramlog_size", "%d", ramlog_size);
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "clear_ramlog");
#if defined(OCS_INCLUDE_RAMD)
    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_boolean(textbuf, MGMT_MODE_RD, "stub_res6_rel6", stub_res6_rel6);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "external_dif", external_dif);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramd_threading", "%d", ramd_threading);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "thread_cmds", "%d", thread_cmds);
#endif

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

        /* See if it's a value I can supply */
        if (ocs_strcmp(unqualified_name, "gendump") == 0) {
            retval = ocs_gen_dump(ocs);
        }
        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;
        }
    }

    return retval;
}
/**
 * @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 Log module parameters
 *
 * A list of module paramters is gerneated to the driver log
 *
 * @return none
 */
static void
ocs_driver_print_module_params(void)
{
        ocs_log_info(NULL, "%s: driver version %s\n", DRV_NAME, DRV_VERSION);

    ocs_log_info(NULL, "  Module parameters:\n");
    ocs_log_info(NULL, "  Initiator = %d\n",        initiator);
    ocs_log_info(NULL, "  Target = %d\n",           target);
    ocs_log_info(NULL, "  ctrlmask = 0x%04x\n",     ctrlmask);
    ocs_log_info(NULL, "  loglevel = %d\n",         loglevel);
    ocs_log_info(NULL, "  logmask = 0x%04x\n",      logmask);
    ocs_log_info(NULL, "  ramlog_size = %d\n",      ramlog_size);
    ocs_log_info(NULL, "  rq_threads = %d\n",       rq_threads);
    ocs_log_info(NULL, "  wwn_bump = %s\n",         wwn_bump);
    ocs_log_info(NULL, "  topology = %d\n",         topology);
    ocs_log_info(NULL, "  speed = %d\n",            speed);
    ocs_log_info(NULL, "  holdoff_link_online = %d\n",  holdoff_link_online);
    ocs_log_info(NULL, "  enable_hlm = %d\n",       enable_hlm);
    ocs_log_info(NULL, "  enable_fw_ag_rsp = %d\n",     enable_fw_ag_rsp);
    ocs_log_info(NULL, "  hlm_group_size = %d\n",       hlm_group_size);
    ocs_log_info(NULL, "  ethernet_license = %d\n",     ethernet_license);
    ocs_log_info(NULL, "  num_scsi_ios = %d\n",     num_scsi_ios);
    ocs_log_info(NULL, "  dif_separate = %d\n",     dif_separate);
    ocs_log_info(NULL, "  tow_feature = %d\n",      tow_feature);
    ocs_log_info(NULL, "  tow_xri_cnt = %d\n",      tow_xri_cnt);
    ocs_log_info(NULL, "  tow_io_size = %d\n",      tow_io_size);
    ocs_log_info(NULL, "  esoc = %d\n",         esoc);
    ocs_log_info(NULL, "  queue_topology = %s\n",       queue_topology);
    ocs_log_info(NULL, "  rq_selection_policy = %d\n",  rq_selection_policy);
    ocs_log_info(NULL, "  rr_quanta = %d\n",        rr_quanta);
    ocs_log_info(NULL, "  filter_ref = %s\n",       filter_def);
    ocs_log_info(NULL, "  cq_process_limit = %d\n",     cq_process_limit);
    ocs_log_info(NULL, "  explicit_buffer_list = %d\n", explicit_buffer_list);
    ocs_log_info(NULL, "  num_vports = %d\n",       num_vports);
    ocs_log_info(NULL, "  external_loopback = %d\n",    external_loopback);
    ocs_log_info(NULL, "  target_io_timer = %d\n",      target_io_timer);
    ocs_log_info(NULL, "  target_wqe_timer = %d\n",     target_wqe_timer);
    ocs_log_info(NULL, "  ddump_saved_size = %d\n",     ddump_saved_size);
    ocs_log_info(NULL, "  hal_war_version = %s\n",      hal_war_version);

#if defined(OCS_INCLUDE_RAMD)
    ocs_log_info(NULL, "  p_type = %d\n",           p_type);
    ocs_log_info(NULL, "  ramdisc_size = %s\n",     ramdisc_size);
    ocs_log_info(NULL, "  ramdisc_blocksize = %d\n",    ramdisc_blocksize);
    ocs_log_info(NULL, "  num_luns = %d\n",         num_luns);
    ocs_log_info(NULL, "  global_ramdisc = %d\n",       global_ramdisc);
    ocs_log_info(NULL, "  stub_res6_rel6 = %d\n",       stub_res6_rel6);
    ocs_log_info(NULL, "  ramd_threading = %d\n",       ramd_threading);
    ocs_log_info(NULL, "  thread_cmds = %d\n",      thread_cmds);
    ocs_log_info(NULL, "  external_dif = %s\n",     external_dif);
#endif
}