ns/sdbc/sd_misc.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#define _SCM_

#include <sys/types.h>
#include <sys/ksynch.h>
#include <sys/cmn_err.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/nsc_thread.h>

#include "sd_bcache.h"
#include "sd_misc.h"
#include "sd_trace.h"
#include "sd_ft.h"
#include "sd_io.h"
#include "sd_bio.h"
#include "sd_pcu.h"
#include "sd_tdaemon.h"
#include "sdbc_ioctl.h"
#include <sys/ncall/ncall.h>
#include <sys/nsctl/nsctl.h>
#include <sys/nsctl/nsvers.h>

#include <sys/sdt.h>        /* dtrace is S10 or later */

#include <sys/unistat/spcs_s.h>
#include <sys/unistat/spcs_s_k.h>
#include <sys/unistat/spcs_errors.h>
static dev_info_t *dev_dip;
dev_info_t *sdbc_get_dip();


/*
 *  A global variable to set the threshold for large writes to
 *  be in write through mode when NVRAM is present. This should
 *  solve the NVRAM bandwidth problem.
 */

int sdbc_wrthru_len;
nsc_size_t sdbc_max_fbas = _SD_MAX_FBAS;
int sdbc_max_devs = 0;

krwlock_t sdbc_queue_lock;

static int _sd_debug_level = 0;

static kmutex_t _sd_block_lk;

#define REGISTER_SVC(X, Y) (ncall_register_svc(X, Y))
#define UNREGISTER_SVC(X) (ncall_unregister_svc(X))

const int sdbc_major_rev = ISS_VERSION_MAJ;
const int sdbc_minor_rev = ISS_VERSION_MIN;
const int sdbc_micro_rev = ISS_VERSION_MIC;
const int sdbc_baseline_rev = ISS_VERSION_NUM;
static char sdbc_version[16];

static int _sdbc_attached = 0;

static int _sdbc_print(dev_t dev, char *s);
static int sdbcunload(void);
static int sdbcload(void);
static int sdbcopen(dev_t *devp, int flag, int otyp, cred_t *crp);
static int sdbcclose(dev_t dev, int flag, int otyp, cred_t *crp);
static int sdbcioctl(dev_t dev, int cmd, void *arg, int mode, cred_t *crp,
    int *rvp);
static int _sdbc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int _sdbc_probe(dev_info_t *dip);
static int _sdbc_attach(dev_info_t *, ddi_attach_cmd_t);
static int _sdbc_detach(dev_info_t *, ddi_detach_cmd_t);
static int _sdbc_reset(dev_info_t *, ddi_reset_cmd_t);

#ifdef sun
/*
 * Solaris specific driver module interface code.
 */

#ifdef USES_SOFT_STATE
struct  sdbc_state {
    dev_info_t  *dip;       /* everyone would need a devinfo */
};

static  void    *sdbc_statep;       /* for soft state routines */
#endif /* USES_SOFT_STATE */

static  struct  cb_ops sdbc_cb_ops = {
    sdbcopen,   /* open */
    sdbcclose,  /* close */
    nodev,      /* not a block driver, strategy not an entry point */
    _sdbc_print,    /* no print routine */
    nodev,      /* no dump routine */
    nodev,      /* read */
    nodev,      /* write */
    (int (*) ()) sdbcioctl, /* ioctl */
    nodev,      /* no devmap routine */
    nodev,      /* no mmap routine */
    nodev,      /* no segmap routine */
    nochpoll,   /* no chpoll routine */
    ddi_prop_op,
    0,      /* not a STREAMS driver, no cb_str routine */
    D_NEW | D_MP,   /* safe for multi-thread/multi-processor */
};


static  struct  dev_ops sdbc_ops = {
    DEVO_REV,           /* Driver build version */
    0,              /* device reference count */
    _sdbc_getinfo,
    nulldev,
    _sdbc_probe,
    _sdbc_attach,
    _sdbc_detach,
    _sdbc_reset,
    &sdbc_cb_ops,
    (struct bus_ops *)NULL
};

static struct modldrv sdbc_ldrv = {
    &mod_driverops,
    "nws:Storage Cache:" ISS_VERSION_STR,
    &sdbc_ops
};

static  struct modlinkage sdbc_modlinkage = {
    MODREV_1,
    &sdbc_ldrv,
    NULL
};

/*
 * dynmem interface
 */
static int mutex_and_condvar_flag;

/*
 * Solaris module load time code
 */
int
_init(void)
{

    int err;

    mutex_and_condvar_flag = 0;

#ifdef USES_SOFT_STATE
    ddi_soft_state_init(&sdbc_statep, sizeof (struct sdbc_state),
        MAX_INSTANCES);
#endif /* USES_SOFT_STATE */

    /*
     * It is "load" time, call the unixware equivalent.
     */
    err = sdbcload();
    if (!err)
        err = mod_install(&sdbc_modlinkage);

    if (err) {
        (void) sdbcunload();
#ifdef USES_SOFT_STATE
        ddi_soft_state_fini(&sdbc_statep);
#endif /* USES_SOFT_STATE */
    }

    if (!err) {
        mutex_and_condvar_flag = 1;
        mutex_init(&dynmem_processing_dm.thread_dm_lock, "dynmem",
            MUTEX_DRIVER, NULL);
        cv_init(&dynmem_processing_dm.thread_dm_cv, "dynmem",
            CV_DRIVER, NULL);
    }

    return (err);

}
/*
 * Solaris module unload time code
 */

int
_fini(void)
{
    int err;

    if (_sd_cache_initialized) {
        return (EBUSY);
    } else if (_sd_ioset &&
        (_sd_ioset->set_nlive || _sd_ioset->set_nthread)) {
        cmn_err(CE_WARN, "!sdbc:_fini() %d threads still "
            "active; %d threads in set\n", _sd_ioset->set_nlive,
            _sd_ioset->set_nthread);
        return (EBUSY);
    }
    if ((err = mod_remove(&sdbc_modlinkage)) == 0) {
        DTRACE_PROBE2(_sdbc_fini_mod_remove_succeeded,
            int, err,
            struct modlinkage *, &sdbc_modlinkage);
        err = sdbcunload();
#ifdef USES_SOFT_STATE
        ddi_soft_state_fini(&sdbc_statep);
#endif /* USES_SOFT_STATE */

        if (mutex_and_condvar_flag) {
            cv_destroy(&dynmem_processing_dm.thread_dm_cv);
            mutex_destroy(&dynmem_processing_dm.thread_dm_lock);
            mutex_and_condvar_flag = 0;
        }
    }

    return (err);
}

/*
 * Solaris module info code
 */
int
_info(struct modinfo *modinfop)
{
    return (mod_info(&sdbc_modlinkage, modinfop));
}

/*ARGSUSED*/
static int
_sdbc_probe(dev_info_t *dip)
{
    return (DDI_PROBE_SUCCESS);
}

/*
 * Attach an instance of the device. This happens before an open
 * can succeed.
 */
static int
_sdbc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    _dm_process_vars_t local_dm_process_vars;
    struct buf bp;

    if (cmd != DDI_ATTACH)
        return (DDI_FAILURE);

    /*
     *  Get the threshold value for setting large writes in
     *  write through mode(when NVRAM is present)
     */

    sdbc_wrthru_len =  ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_wrthru_thresh", 64);

    /* Get sdbc_max_fbas from sdbc.conf */
    sdbc_max_fbas =  ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_fbas",
        _SD_MAX_FBAS);

    bp.b_bcount = (size_t)FBA_SIZE(sdbc_max_fbas);
    minphys(&bp); /* clamps value to maxphys */

    sdbc_max_fbas = FBA_NUM(bp.b_bcount);

    if (sdbc_max_fbas > _SD_MAX_FBAS) {
        cmn_err(CE_WARN,
            "!_sdbc_attach: sdbc_max_fbas set to %d", _SD_MAX_FBAS);
        sdbc_max_fbas = _SD_MAX_FBAS;
    }

    /*
     * -get the maximum list length for multipage dynmem
     * -time between aging
     * -number of agings before dealloc
     * -what to report D0=shutdown, D1=thread variables
     */
    dynmem_processing_dm.max_dyn_list = MAX_DYN_LIST_DEFAULT;
    dynmem_processing_dm.monitor_dynmem_process =
        MONITOR_DYNMEM_PROCESS_DEFAULT;
    dynmem_processing_dm.cache_aging_ct1 = CACHE_AGING_CT_DEFAULT;
    dynmem_processing_dm.cache_aging_ct2 = CACHE_AGING_CT_DEFAULT;
    dynmem_processing_dm.cache_aging_ct3 = CACHE_AGING_CT_DEFAULT;
    dynmem_processing_dm.cache_aging_sec1 = CACHE_AGING_SEC1_DEFAULT;
    dynmem_processing_dm.cache_aging_sec2 = CACHE_AGING_SEC2_DEFAULT;
    dynmem_processing_dm.cache_aging_sec3 = CACHE_AGING_SEC3_DEFAULT;
    dynmem_processing_dm.cache_aging_pcnt1 = CACHE_AGING_PCNT1_DEFAULT;
    dynmem_processing_dm.cache_aging_pcnt2 = CACHE_AGING_PCNT2_DEFAULT;
    dynmem_processing_dm.max_holds_pcnt = MAX_HOLDS_PCNT_DEFAULT;
    dynmem_processing_dm.process_directive = PROCESS_DIRECTIVE_DEFAULT;

    local_dm_process_vars.max_dyn_list = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_dyn_list",
        MAX_DYN_LIST_DEFAULT);

    local_dm_process_vars.monitor_dynmem_process =
        ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_monitor_dynmem",
        MONITOR_DYNMEM_PROCESS_DEFAULT);

    local_dm_process_vars.cache_aging_ct1 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct1",
        CACHE_AGING_CT_DEFAULT);

    local_dm_process_vars.cache_aging_ct2 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct2",
        CACHE_AGING_CT_DEFAULT);

    local_dm_process_vars.cache_aging_ct3 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct3",
        CACHE_AGING_CT_DEFAULT);

    local_dm_process_vars.cache_aging_sec1 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec1",
        CACHE_AGING_SEC1_DEFAULT);

    local_dm_process_vars.cache_aging_sec2 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec2",
        CACHE_AGING_SEC2_DEFAULT);

    local_dm_process_vars.cache_aging_sec3 = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec3",
        CACHE_AGING_SEC3_DEFAULT);

    local_dm_process_vars.cache_aging_pcnt1 =
        ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_pcnt1",
        CACHE_AGING_PCNT1_DEFAULT);

    local_dm_process_vars.cache_aging_pcnt2 =
        ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_pcnt2",
        CACHE_AGING_PCNT2_DEFAULT);

    local_dm_process_vars.process_directive =
        ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_process_directive",
        PROCESS_DIRECTIVE_DEFAULT);

    local_dm_process_vars.max_holds_pcnt = ddi_prop_get_int(DDI_DEV_T_ANY,
        dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_holds_pcnt",
        MAX_HOLDS_PCNT_DEFAULT);

    (void) sdbc_edit_xfer_process_vars_dm(&local_dm_process_vars);

#define MINOR_NAME  "c,sdbc"        /* character device */
#define MINOR_NUMBER    0
#ifdef MINOR_NAME
    if (ddi_create_minor_node(dip, MINOR_NAME, S_IFCHR,
        MINOR_NUMBER, DDI_PSEUDO, 0) != DDI_SUCCESS) {
        /* free anything we allocated here */
        return (DDI_FAILURE);
    }
#endif /* MINOR_NAME */

    /* Announce presence of the device */
    ddi_report_dev(dip);
    dev_dip = dip;
    /* mark the device as attached, opens may proceed */
    _sdbc_attached = 1;

    rw_init(&sdbc_queue_lock, NULL, RW_DRIVER, NULL);

    return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
_sdbc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    if (cmd == DDI_DETACH) {
        /*
         * Check first if the cache is still in use
         * and if it is, prevent the detach.
         */
        if (_sd_cache_initialized)
            return (EBUSY);

        _sdbc_attached = 0;

        rw_destroy(&sdbc_queue_lock);
        dev_dip = NULL;

        return (DDI_SUCCESS);
    } else
        return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
_sdbc_reset(dev_info_t *dip, ddi_reset_cmd_t cmd)
{
    return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
_sdbc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
    dev_t dev;
#ifdef USES_SOFT_STATE
    struct sdbc_state *xsp;
    int instance;
#endif /* USES_SOFT_STATE */
    int rc;

    switch (cmd) {
        case DDI_INFO_DEVT2INSTANCE:
            dev = (dev_t)arg;
            /* The "instance" number is the minor number */
            *result = (void *)(unsigned long)getminor(dev);
            rc = DDI_SUCCESS;
            break;

        case DDI_INFO_DEVT2DEVINFO:
            dev = (dev_t)arg;
#ifdef USES_SOFT_STATE
            /* the instance number is the minor number */
            instance = getminor(dev);
            xsp = ddi_get_soft_state(sdbc_statep, instance);
            if (xsp == NULL)
                return (DDI_FAILURE);
            *result = (void *) xsp->dip;
#else
            *result = (void *) NULL;
#endif /* USES_SOFT_STATE */
            rc = DDI_SUCCESS;
            break;

        default:
            rc = DDI_FAILURE;
            break;
    }
    return (rc);
}

/*ARGSUSED*/
int
_sdbc_print(dev_t dev, char *s)
{
    cmn_err(CE_WARN, "!sdbc(_sdbc_print) %s", s);
    return (0);
}
#else
MOD_DRV_WRAPPER(sdbc, sdbcload, sdbcunload, NULL, "Storage Device Block Cache");
#endif /* sun */

static int sdbc_inited;

static int
sdbcinit(void)
{
    int rc;

    sdbc_inited = 0;

    (void) strncpy(sdbc_version, _VERSION_, sizeof (sdbc_version));

    mutex_init(&_sd_cache_lock, NULL, MUTEX_DRIVER, NULL);
    mutex_init(&_sdbc_config_lock, NULL, MUTEX_DRIVER, NULL);

#ifdef m88k
    REGISTER_SVC(SD_DUAL_WRITE, r_sd_ifs_write);
    REGISTER_SVC(SD_DUAL_READ,  r_sd_ifs_read);
    REGISTER_SVC(SD_SET_CD,     r_sd_set_cd);
    REGISTER_SVC(SD_GETSIZE,    r_sd_getsize);
    REGISTER_SVC(SD_DUAL_OPEN,  r_sd_ifs_open);
    REGISTER_SVC(SD_REMOTE_FLUSH,   r_sd_remote_flush);
    REGISTER_SVC(SD_SGREMOTE_FLUSH, r_sd_sgremote_flush);
    REGISTER_SVC(SD_DISK_IO,    r_sd_disk_io);
    REGISTER_SVC(SD_GET_BMAP,   r_rem_get_bmap);

    if ((rc = hpf_register_module("SDBC", _sd_hpf_stats)) != 0)
        return (rc);
#endif
    REGISTER_SVC(SD_ENABLE,     r_sd_ifs_cache_enable);
    REGISTER_SVC(SD_DISABLE,    r_sd_ifs_cache_disable);
    REGISTER_SVC(SD_CD_DISCARD, r_cd_discard);

    cv_init(&_sd_flush_cv, NULL, CV_DRIVER, NULL);

    mutex_init(&_sd_block_lk, NULL, MUTEX_DRIVER, NULL);

    sdbc_max_devs = nsc_max_devices();

    /*
     * Initialize the bitmap array that would be useful in determining
     * if the mask is not fragmented, instead of determinig this
     * at run time. Also initialize a lookup array for each mask, with
     * the starting position, the length, and the mask subset
     */
    _sd_init_contig_bmap();
    _sd_init_lookup_map();

    if ((rc = _sdbc_iobuf_load()) != 0)
        return (rc);
    if ((rc = _sdbc_handles_load()) != 0)
        return (rc);
    if ((rc = _sdbc_tr_load()) != 0)
        return (rc);
    if ((rc = _sdbc_ft_load()) != 0)
        return (rc);
    if ((rc = _sdbc_tdaemon_load()) != 0)
        return (rc);
    if ((rc = _sdbc_hash_load()) != 0)
        return (rc);
#ifdef DEBUG
    _sdbc_ioj_load();
#endif
    sdbc_inited = 1;

    return (0);
}

static int
sdbcunload(void)
{
    if (_sd_cache_initialized) {
        cmn_err(CE_WARN,
            "!sdbc(sdbcunload) cannot unload module - cache in use!");
        return (EEXIST);
    }
#ifdef m88k
    UNREGISTER_SVC(SD_DUAL_WRITE);
    UNREGISTER_SVC(SD_DUAL_READ);
    UNREGISTER_SVC(SD_SET_CD);
    UNREGISTER_SVC(SD_GETSIZE);
    UNREGISTER_SVC(SD_DUAL_OPEN);
    UNREGISTER_SVC(SD_REMOTE_FLUSH);
    UNREGISTER_SVC(SD_SGREMOTE_FLUSH);
    UNREGISTER_SVC(SD_DISK_IO);
    UNREGISTER_SVC(SD_GET_BMAP);

    (void) hpf_unregister_module("SDBC");
#endif
    UNREGISTER_SVC(SD_ENABLE);
    UNREGISTER_SVC(SD_DISABLE);
    UNREGISTER_SVC(SD_CD_DISCARD);

    cv_destroy(&_sd_flush_cv);
    mutex_destroy(&_sd_block_lk);

    _sdbc_hash_unload();
    _sdbc_ft_unload();
    _sdbc_tr_unload();
    _sdbc_tdaemon_unload();
    _sdbc_handles_unload();
    _sdbc_iobuf_unload();
#ifdef DEBUG
    _sdbc_ioj_unload();
#endif

    mutex_destroy(&_sd_cache_lock);
    mutex_destroy(&_sdbc_config_lock);

    /*
     * Normally we would unregister memory at deconfig time.
     * However when chasing things like memory leaks it is
     * useful to defer until unload time.
     */
    if (_sdbc_memtype_deconfigure_delayed)
        _sdbc_memtype_deconfigure();

    return (0);
}


static int
sdbcload(void)
{
    int err;

    if ((err = sdbcinit()) != 0) {
        (void) sdbcunload();
        return (err);
    }
    return (0);
}


/* ARGSUSED */

static int
sdbcopen(dev_t *devp, int flag, int otyp, cred_t *crp)
{
    int nd = nsc_node_id();

    /*
     * If we were statically linked in then returning an error out
     * of sdbcinit won't prevent someone from coming thru here.
     * We must prevent them from getting any further.
     */
    if (!sdbc_inited)
        return (EINVAL);

    if (nd < nsc_min_nodeid) {
        cmn_err(CE_WARN,
            "!sdbc(sdbcopen) open failed, systemid (%d) must be >= %d",
            nd, nsc_min_nodeid);
        return (EINVAL);
    }
    if (!_sdbc_attached)
        return (ENXIO);

    return (0);
}


/* ARGSUSED */

static int
sdbcclose(dev_t dev, int flag, int otyp, cred_t *crp)
{
    return (0);
}

#ifdef _MULTI_DATAMODEL
static int
convert_ioctl_args(int cmd, void *arg, int mode, _sdbc_ioctl_t *args)
/*
 * convert_ioctl-args - Do a case by case conversion of a ILP32 ioctl
 * structure to an LP64 structure.
 * The main concern here is whether to sign-extend or not. The rule
 * is that pointers are not sign extended, the rest are obvious.
 * Since most everything is sign-extended the definition of
 * _sdbc_ioctl32_t uses signed fields.
 *
 */
{
    _sdbc_ioctl32_t args32;

    if (ddi_copyin(arg, &args32, sizeof (_sdbc_ioctl32_t), mode))
        return (EFAULT);

    bzero((void *) args, sizeof (_sdbc_ioctl_t));

    switch (cmd) {

    case SDBC_UNUSED_1:
    case SDBC_UNUSED_2:
    case SDBC_UNUSED_3:
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        cmn_err(CE_WARN,
            "!sdbc(convert_ioctl_args) obsolete sdbc ioctl used");
        return (EINVAL);

    case SDBC_ADUMP:
        args->arg0 = args32.arg0; /* cd */
        args->arg1 = (uint32_t)args32.arg1; /* &tt */
        args->arg2 = (uint32_t)args32.arg2; /* NULL (buf) */
        args->arg3 = args32.arg3; /*  size of buf */
        args->arg4 = args32.arg4; /* flag */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_TEST_INIT:
        args->arg0 = (uint32_t)args32.arg0; /* fname (char *) */
        args->arg1 = args32.arg1; /* index */
        args->arg2 = args32.arg2; /* len */
        args->arg3 = args32.arg3; /* track size */
        args->arg4 = args32.arg4; /* flag */
        break;

    case SDBC_TEST_START:
        args->arg0 = args32.arg0; /* num */
        args->arg1 = args32.arg1; /* type */
        args->arg2 = args32.arg2; /* loops */
        args->arg3 = args32.arg3; /* from */
        args->arg4 = args32.arg4; /* seed */
        break;

    case SDBC_TEST_END:
        break;

    case SDBC_ENABLE:
    case SDBC_VERSION:
        args->arg0 = (uint32_t)args32.arg0; /* pointer */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_DISABLE:
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_GET_CLUSTER_SIZE:
        args->arg0 = (uint32_t)args32.arg0; /* (int * ) */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    /* get the gl_file data */
    case SDBC_GET_CLUSTER_DATA:
        /* pointer to array[2*cluster_size] */
        args->arg0 = (uint32_t)args32.arg0;
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    /*  get the size of the global info pages for each board */
    case SDBC_GET_GLMUL_SIZES:
        args->arg0 = (uint32_t)args32.arg0; /* int[CACHE_MEM_PAD] * */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    /* get the global info about write blocks */
    case SDBC_GET_GLMUL_INFO:
        /* pointer to array[2*(sum of GLMUL_SIZES)] */
        args->arg0 = (uint32_t)args32.arg0;
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_SET_CD_HINT:
        args->arg0 = args32.arg0; /* cd */
        args->arg1 = args32.arg1; /* hint */
        args->arg2 = args32.arg2; /* flag */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_GET_CD_HINT:
        args->arg0 = args32.arg0;
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_SET_NODE_HINT:
        args->arg0 = args32.arg0; /* hint */
        args->arg1 = args32.arg1; /* flag */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_GET_NODE_HINT:
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_STATS:
        args->arg0 = (uint32_t)args32.arg0; /* (_sd_stats_t *) */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_ZAP_STATS:
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_GET_CD_BLK:
        args->arg0 = args32.arg0; /* cd */
        args->arg1 = (uint32_t)args32.arg1; /* blk */
        args->arg2 = (uint32_t)args32.arg2; /* (addr[5] *) */
        break;

    case SDBC_GET_CONFIG:
        args->arg0 = (uint32_t)args32.arg0; /* (_sdbc_config_t *) */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_SET_CONFIG:
        args->arg0 = (uint32_t)args32.arg0; /* (_sdbc_config_t *) */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_MAXFILES:
        args->arg0 = (uint32_t)args32.arg0; /* (int * ) */
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

#ifdef DEBUG
    /* toggle flusher flag for testing */
    case SDBC_TOGGLE_FLUSH:
        args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus;
        break;

    case SDBC_INJ_IOERR: /* cd, errnum */
        args->arg0 = args32.arg0; /* cd */
        args->arg1 = args32.arg1; /* i/o error number */
        args->arg2 = args32.arg2; /* countdown to issuing error */
        break;

    /* clear injected i/o errors */
    case SDBC_CLR_IOERR: /* cd */
        args->arg0 = args32.arg0; /* cd */
        break;
#endif /* DEBUG */
    default:
        return (EINVAL);
    }

    return (0);
}
#endif /* _MULTI_DATAMODEL */

static int
sdbc_get_cd_blk(_sdbc_ioctl_t *args, int mode)
{

    _sd_cctl_t *cc_ent;
    caddr_t data;
    char *taddr;
    intptr_t addr[5];
#ifdef _MULTI_DATAMODEL
    uint32_t addr_32[5];
#endif /* _MULTI_DATAMODEL */
    char *lookup_file = NULL;
    int rc;
    sdbc_info_t info;
    nsc_off_t fba_pos;  /* disk block number */

    if (_sd_cache_initialized == 0) {
        return (EINVAL);
    }

    /* copyin the block number */
    if (ddi_copyin((void *)args->arg1, &fba_pos, sizeof (nsc_off_t),
        mode)) {
        return (EFAULT);
    }

#ifdef _MULTI_DATAMODEL
    if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
        if (ddi_copyin((void *)args->arg2, addr_32, sizeof (addr_32),
            mode)) {
            return (EFAULT);
        }
        addr[0] = addr_32[0]; /* (sdbc_info_t *) */
        addr[1] = addr_32[1]; /* (char *) cdata */
        addr[2] = addr_32[2]; /* ( int * ) cblk_size */
        addr[3] = addr_32[3]; /* ( char * ) filename */
        addr[4] = addr_32[4]; /* ( char *) wdata */
    } else {
        if (ddi_copyin((void *)args->arg2, addr, sizeof (addr), mode)) {
            return (EFAULT);
        }
    }
#else /* _MULTI_DATAMODEL */
    if (ddi_copyin((void *)args->arg2, addr, sizeof (addr), mode)) {
        return (EFAULT);
    }
#endif /* _MULTI_DATAMODEL */

    (void) copyout(&CACHE_BLOCK_SIZE, (void *)addr[2], sizeof (int));

    if (_sd_get_cd_blk((int)args->arg0, FBA_TO_BLK_NUM(fba_pos),
        &cc_ent, &data, &lookup_file)) {
        if (lookup_file != NULL)
            (void) copyout(lookup_file, (void *)addr[3],
                NSC_MAXPATH);
        return (ENOENT);
    }
    rc = 0;
    taddr = NULL;

    info.ci_write = cc_ent->cc_write ? 1 : 0;
    info.ci_dirty = cc_ent->cc_dirty;
    info.ci_valid = cc_ent->cc_valid;
    info.ci_cd = CENTRY_CD(cc_ent);
    info.ci_dblk = BLK_TO_FBA_NUM(CENTRY_BLK(cc_ent));
    (void) copyout(lookup_file, (void *)addr[3], NSC_MAXPATH);
    (void) copyout(&info, (void *)addr[0], sizeof (sdbc_info_t));

    (void) copyout(data, (void *)addr[1], CACHE_BLOCK_SIZE);

    /* get the write data if any */
    if (cc_ent->cc_write) {

        if (sdbc_safestore) {
            cmn_err(CE_WARN,
                "!sdbc(sdbc_get_cd_blk) cc_write 0x%p sc-res 0x%p",
                (void *)cc_ent->cc_write,
                (void *)cc_ent->cc_write->sc_res);

            if ((taddr = kmem_alloc(CACHE_BLOCK_SIZE,
                KM_NOSLEEP)) == NULL) {
                cmn_err(CE_WARN,
                    "!sdbc(sdbc_get_cd_blk) kmem_alloc failed."
                    " cannot get write data");
                info.ci_write = NULL;
                rc = EFAULT;
            } else if (SSOP_READ_CBLOCK(sdbc_safestore,
                cc_ent->cc_write->sc_res, taddr,
                CACHE_BLOCK_SIZE, 0) == SS_ERR) {

                cmn_err(CE_WARN, "sdbc(sdbc_get_cd_blk) "
                    "!safestore read failed");
                rc = EFAULT;

            } else if (copyout(taddr, (void *)addr[4],
                CACHE_BLOCK_SIZE)) {
                cmn_err(CE_WARN,
                    "!sdbc(sdbc_get_cd_blk) copyout failed."
                    " cannot get write data");
                rc = EFAULT;
            }
        }

    }

    if (taddr)
        kmem_free(taddr, CACHE_BLOCK_SIZE);

    return (rc);
}

/* ARGSUSED */
static int
sdbcioctl(dev_t dev, int cmd, void *arg, int mode, cred_t *crp, int *rvp)
{
    int rc = 0;
    _sdbc_ioctl_t args;
    int convert_32 = 0;
    spcs_s_info_t kstatus;

    *rvp = 0;

#ifdef _MULTI_DATAMODEL
    if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
        int rc;
        convert_32 = 1;
        if ((rc = convert_ioctl_args(cmd, arg, mode, &args)) != 0)
            return (rc);
    } else {
        if (ddi_copyin(arg, &args, sizeof (_sdbc_ioctl_t), mode)) {
            return (EFAULT);
        }
    }
#else /* _MULTI_DATAMODEL */
    if (ddi_copyin(arg, &args, sizeof (_sdbc_ioctl_t), mode)) {
        return (EFAULT);
    }
#endif /* _MULTI_DATAMODEL */

    kstatus = spcs_s_kcreate();
    if (!kstatus)
        return (ENOMEM);

    switch (cmd) {

    case SDBC_UNUSED_1:
    case SDBC_UNUSED_2:
    case SDBC_UNUSED_3:

        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
            SDBC_EOBSOLETE));

    case SDBC_ADUMP:
        rc = _sd_adump(&args, rvp);
        break;

    case SDBC_TEST_INIT:
        rc = _sd_test_init(&args);
        break;

    case SDBC_TEST_START:
        rc = _sd_test_start(&args, rvp);
        break;

    case SDBC_TEST_END:
        rc = _sd_test_end();
        break;

    case SDBC_ENABLE:
        mutex_enter(&_sdbc_config_lock);
        rc = _sdbc_configure((_sd_cache_param_t *)args.arg0,
            NULL, kstatus);
        if (rc && rc != EALREADY && rc != SDBC_ENONETMEM) {
            (void) _sdbc_deconfigure(kstatus);
            mutex_exit(&_sdbc_config_lock);
            return (spcs_s_ocopyoutf
                (&kstatus, args.sdbc_ustatus, rc));
        }
        mutex_exit(&_sdbc_config_lock);
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));

    case SDBC_DISABLE:
        mutex_enter(&_sdbc_config_lock);
        if (_sd_cache_initialized == 0) {

            mutex_exit(&_sdbc_config_lock);
            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                SDBC_EDISABLE));
        }
        rc = _sdbc_deconfigure(kstatus);
        mutex_exit(&_sdbc_config_lock);
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));

    case SDBC_GET_CLUSTER_SIZE:
        if (_sd_cache_initialized == 0) {

            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                SDBC_ECLUSTER_SIZE));
        }

        rc = sd_get_file_info_size((void *)args.arg0);
        break;

    /* get the gl_file data */
    case SDBC_GET_CLUSTER_DATA:
        if (_sd_cache_initialized == 0) {

            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                SDBC_ECLUSTER_DATA));
        }
        rc = sd_get_file_info_data((void *)args.arg0);
        break;

    /*  get the size of the global info pages for each board */
    case SDBC_GET_GLMUL_SIZES:
        if (_sd_cache_initialized == 0) {
            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                SDBC_EGLMUL_SIZE));
        }
        rc = sd_get_glmul_sizes((void *)args.arg0);
        break;

    /* get the global info about write blocks */
    case SDBC_GET_GLMUL_INFO:
        if (_sd_cache_initialized == 0) {

            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                SDBC_EGLMUL_INFO));

        }
        rc = sd_get_glmul_info((void *)args.arg0);
        break;

    case SDBC_SET_CD_HINT:
        if (_sd_cache_initialized == 0)
            return (spcs_s_ocopyoutf(&kstatus,
                args.sdbc_ustatus, EINVAL));
        rc = ((args.arg2) ?
            _sd_set_hint((int)args.arg0, (uint_t)args.arg1) :
            _sd_clear_hint((int)args.arg0, (uint_t)args.arg1));
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));

    case SDBC_GET_CD_HINT:
        {
            uint_t hint;

            if (_sd_cache_initialized == 0)
                return (spcs_s_ocopyoutf(&kstatus,
                    args.sdbc_ustatus, EINVAL));
            if ((rc = _sd_get_cd_hint((int)args.arg0, &hint)) == 0)
                *rvp = hint;
            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                rc));
        }

    case SDBC_SET_NODE_HINT:
        rc = ((args.arg1) ? _sd_set_node_hint((uint_t)args.arg0) :
            _sd_clear_node_hint((uint_t)args.arg0));
        if (rc)
            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                rc));
        /* FALLTHRU */
    case SDBC_GET_NODE_HINT:
        {
            uint_t hint;
            if ((rc = _sd_get_node_hint(&hint)) == 0)
                *rvp = hint;
            return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
                rc));
        }

    case SDBC_STATS:
        rc = _sd_get_stats((void *)args.arg0, convert_32);
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));

    case SDBC_ZAP_STATS:
        _sd_zap_stats();
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 0));

    case SDBC_GET_CD_BLK:
        if (_sd_cache_initialized == 0)
            return (spcs_s_ocopyoutf(&kstatus,
                args.sdbc_ustatus, EINVAL));
        rc = sdbc_get_cd_blk(&args, mode);
        break;

    case SDBC_GET_CONFIG:
        {
        _sdbc_config_t sdbc_config_info;

        if (ddi_copyin((void *)args.arg0,
            &sdbc_config_info,
            sizeof (_sdbc_config_t),
            mode)) {
            spcs_s_kfree(kstatus);
            return (EFAULT);
        }
        rc = _sdbc_get_config(&sdbc_config_info);
        (void) ddi_copyout(&sdbc_config_info,
            (void *)args.arg0,
            sizeof (_sdbc_config_t),
            mode);
        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));
        }

    case SDBC_SET_CONFIG:
    {
        _sdbc_config_t mgmt_config_info;

        if (ddi_copyin((void *)args.arg0,
            &mgmt_config_info,
            sizeof (_sdbc_config_t),
            mode)) {
            spcs_s_kfree(kstatus);
            return (EFAULT);
        }

        rc = _sdbc_configure(NULL, &mgmt_config_info, kstatus);
        if (rc && rc != EALREADY) {
            (void) _sdbc_deconfigure(kstatus);
            return (spcs_s_ocopyoutf
                (&kstatus, args.sdbc_ustatus, rc));
        }

        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc));
    }

    case SDBC_MAXFILES:
        if (copyout(&sdbc_max_devs, (void *)args.arg0,
            sizeof (sdbc_max_devs)))
            rc = EFAULT;
        else
            rc = 0;

        break;

    case SDBC_VERSION:
    {
        cache_version_t cache_version;

        cache_version.major = sdbc_major_rev;
        cache_version.minor = sdbc_minor_rev;
        cache_version.micro = sdbc_micro_rev;
        cache_version.baseline = sdbc_baseline_rev;

        if (ddi_copyout(&cache_version, (void *)args.arg0,
            sizeof (cache_version_t), mode)) {
            rc = EFAULT;
            break;
        }

        break;
    }


#ifdef DEBUG
    /* toggle flusher flag for testing */
    case SDBC_TOGGLE_FLUSH:
        _sdbc_flush_flag ^= 1;
        *rvp = _sdbc_flush_flag;
        rc = 0;

        return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus,
            SDBC_ETOGGLE_FLUSH, _sdbc_flush_flag ? "on" : "off"));


    /* inject i/o errors */
    case SDBC_INJ_IOERR: /* cd, errnum */
        if (_sd_cache_initialized == 0)
            return (spcs_s_ocopyoutf(&kstatus,
                args.sdbc_ustatus, EINVAL));
        rc = _sdbc_inject_ioerr(args.arg0, args.arg1, args.arg2);
        break;

    /* clear injected i/o errors */
    case SDBC_CLR_IOERR: /* cd */
        if (_sd_cache_initialized == 0)
            return (spcs_s_ocopyoutf(&kstatus,
                args.sdbc_ustatus, EINVAL));
        rc = _sdbc_clear_ioerr(args.arg0);
        break;

#endif /* DEBUG */
    default:
        _sd_print(3, "!SDBC unknown ioctl: 0x%x unsupported", cmd);
        rc = EINVAL;
        break;
    }

    spcs_s_kfree(kstatus);
    return (rc);
}


/*
 * _sd_timed_block - sleep waiting for ticks time delay.
 * ticks - # of ticks to sleep
 * cvp - pointer to the cv we wait on while we delay.
 *
 * NO spin locks can be held at entry!
 *
 */
void
_sd_timed_block(clock_t ticks, kcondvar_t *cvp)
{
    mutex_enter(&_sd_block_lk);
    (void) cv_reltimedwait(cvp, &_sd_block_lk, ticks, TR_CLOCK_TICK);
    mutex_exit(&_sd_block_lk);
}


/*
 * _sd_unblock - awake a sleeper waiting on cv pointed to by cvp.
 *
 * NO spin locks can be held at entry as we may sleep.
 *
 */
void
_sd_unblock(kcondvar_t *cvp)
{

    mutex_enter(&_sd_block_lk);
    cv_broadcast(cvp);
    mutex_exit(&_sd_block_lk);
}

/* ARGSUSED */
void
_sd_data_log(int num, _sd_cctl_t *centry, nsc_off_t st, nsc_size_t len)
{
#if defined(_SD_FBA_DATA_LOG)
    nsc_size_t i;
    nsc_off_t blk;

    blk = BLK_TO_FBA_NUM(CENTRY_BLK(centry));
    for (i = st; i < (st + len); i++)
        SDTRACE(num, CENTRY_CD(centry), 1, blk + i,
            *(int *)(centry->cc_data + FBA_SIZE(i)),
            *(int *)(centry->cc_data + FBA_SIZE(i) + 4));
#endif /* _SD_FBA_DATA_LOG */
}

/* ARGSUSED */
void
_sd_data_log_chain(int num, _sd_cctl_t *centry, nsc_off_t fba_pos,
    nsc_size_t fba_len)
{
#if defined(_SD_FBA_DATA_LOG)
    sdbc_cblk_fba_t st_cblk_len;    /* FBA len of starting cache block */
    sdbc_cblk_fba_t end_cblk_len;   /* FBA len of ending cache block */
    sdbc_cblk_fba_t st_cblk_off;    /* FBA offset into starting cblock */

    while (CENTRY_BLK(centry) != FBA_TO_BLK_NUM(fba_pos))
        centry = centry->cc_chain;

    st_cblk_off = BLK_FBA_OFF(fba_pos);
    st_cblk_len = BLK_FBAS - st_cblk_off;
    if (st_cblk_len >= fba_len) {
        end_cblk_len = 0;
        st_cblk_len = fba_len;
    } else {
        end_cblk_len = BLK_FBA_OFF(fba_pos + fba_len);
    }

    DATA_LOG(num, centry, st_cblk_off, st_cblk_len);

    fba_len -= st_cblk_len;
    centry = centry->cc_chain;

    while (fba_len > end_cblk_len) {
        DATA_LOG(num, centry, 0, BLK_FBAS);
        fba_len -= BLK_FBAS;
        centry = centry->cc_chain;
    }
    if (end_cblk_len) DATA_LOG(num, centry, 0, end_cblk_len);
#endif /* _SD_FBA_DATA_LOG */
}


void
_sd_zap_stats(void)
{
    int i;

    if (_sd_cache_stats == NULL)
        return;

    _sd_cache_stats->st_rdhits = 0;
    _sd_cache_stats->st_rdmiss = 0;
    _sd_cache_stats->st_wrhits = 0;
    _sd_cache_stats->st_wrmiss = 0;
    _sd_lru_q.sq_noreq_stat = 0;
    _sd_lru_q.sq_req_stat = 0;

    for (i = 0; i < sdbc_max_devs; i++) {
        _sd_cache_stats->st_shared[i].sh_cache_read  = 0;
        _sd_cache_stats->st_shared[i].sh_cache_write = 0;
        _sd_cache_stats->st_shared[i].sh_disk_read   = 0;
        _sd_cache_stats->st_shared[i].sh_disk_write  = 0;
    }
}


/*
 * Return the cache sizes used by the Sense Subsystem Status CCW
 */
int
_sd_cache_sizes(int *asize, int *wsize)
{
    int psize;

    *asize = 0;
    *wsize = 0;

    /*
     * add in the total cache size and the
     * non-volatile (battery-backed) cache size.
     */
    if (_sd_net_config.sn_configured) {
        psize = _sd_net_config.sn_psize;
        *asize += (_sd_net_config.sn_cpages * psize);
        *wsize += (safestore_config.ssc_wsize);
    }

    return (0);
}


/*PRINTFLIKE2*/
void
_sd_print(int level, char *fmt, ...)
{
    va_list adx;
    if (level <= _sd_debug_level) {
        va_start(adx, fmt);
        vcmn_err(CE_NOTE, fmt, adx);
        va_end(adx);

    }
}


int
_sd_get_cd_blk(int cd, nsc_off_t cblk, _sd_cctl_t **cc, caddr_t *data,
    char **filename)
{
    _sd_cctl_t *cc_ent;

    if (FILE_OPENED(cd) != 0) {
        *filename = _sd_cache_files[cd].cd_info->sh_filename;
        if (cc_ent = (_sd_cctl_t *)
            _sd_hash_search(cd, cblk, _sd_htable)) {
            *cc = cc_ent;
            *data = (caddr_t)cc_ent->cc_data;
            return (0);
        }
    }
    return (-1);
}

/*
 * central dyn mem processing vars edit rtn.
 * input a local copy and xfer to global
 *
 * sec0,sec1,sec2
 * range check 1 to 255 (arbitrary but in any case must be <= 2000 due to
 *  32bit signed int limits in later calc)
 * aging_ct
 * range check 1 to 255 (only 8 bits reserved for aging ctr)
 *
 */
int
sdbc_edit_xfer_process_vars_dm(_dm_process_vars_t *process_vars)
{
    if (process_vars->max_dyn_list > 0)
        dynmem_processing_dm.max_dyn_list = process_vars->max_dyn_list;

    /* no edit on monitor_dynmem_process */
    dynmem_processing_dm.monitor_dynmem_process =
        process_vars->monitor_dynmem_process;
    /* no edit on process_directive */
    dynmem_processing_dm.process_directive =
        process_vars->process_directive;

    if (process_vars->cache_aging_ct1 > 0 &&
        process_vars->cache_aging_ct1 <= CACHE_AGING_CT_MAX)
        dynmem_processing_dm.cache_aging_ct1 =
            process_vars->cache_aging_ct1;
    if (process_vars->cache_aging_ct2 > 0 &&
        process_vars->cache_aging_ct2 <= CACHE_AGING_CT_MAX)
        dynmem_processing_dm.cache_aging_ct2 =
            process_vars->cache_aging_ct2;
    if (process_vars->cache_aging_ct3 > 0 &&
        process_vars->cache_aging_ct3 <= CACHE_AGING_CT_MAX)
        dynmem_processing_dm.cache_aging_ct3 =
            process_vars->cache_aging_ct3;
    if (process_vars->cache_aging_sec1 > 0 &&
        process_vars->cache_aging_sec1 <= CACHE_AGING_SEC1_MAX)
        dynmem_processing_dm.cache_aging_sec1 =
            process_vars->cache_aging_sec1;
    if (process_vars->cache_aging_sec2 > 0 &&
        process_vars->cache_aging_sec2 <= CACHE_AGING_SEC2_MAX)
        dynmem_processing_dm.cache_aging_sec2 =
            process_vars->cache_aging_sec2;
    if (process_vars->cache_aging_sec3 > 0 &&
        process_vars->cache_aging_sec3 <= CACHE_AGING_SEC3_MAX)
        dynmem_processing_dm.cache_aging_sec3 =
            process_vars->cache_aging_sec3;
    if (process_vars->cache_aging_pcnt1 >= 0 &&
        process_vars->cache_aging_pcnt1 <= CACHE_AGING_PCNT1_MAX)
        dynmem_processing_dm.cache_aging_pcnt1 =
            process_vars->cache_aging_pcnt1;
    if (process_vars->cache_aging_pcnt2 >= 0 &&
        process_vars->cache_aging_pcnt2 <= CACHE_AGING_PCNT2_MAX)
        dynmem_processing_dm.cache_aging_pcnt2 =
            process_vars->cache_aging_pcnt2;
    if (process_vars->max_holds_pcnt >= 0 &&
        process_vars->max_holds_pcnt <= MAX_HOLDS_PCNT_MAX)
        dynmem_processing_dm.max_holds_pcnt =
            process_vars->max_holds_pcnt;
    return (0);
}

dev_info_t *
sdbc_get_dip()
{
    return (dev_dip);
}