modules/dtrace/dtrace.c

	dtrace.c revision b8fac8e162eda7e98db13dfa3e439e43f90f41d9
/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * explicitly define DTRACE_ERRDEBUG to pull in definition of dtrace_errhash_t
 * explicitly define _STDARG_H to avoid stdarg.h/varargs.h u/k defn conflict
 */
#define DTRACE_ERRDEBUG
#define _STDARG_H

#include <mdb/mdb_param.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ks.h>
#include <sys/dtrace_impl.h>
#include <sys/vmem_impl.h>
#include <sys/ddi_impldefs.h>
#include <sys/sysmacros.h>
#include <sys/kobj.h>
#include <dtrace.h>
#include <alloca.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>

/*ARGSUSED*/
int
id2probe(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    uintptr_t probe = NULL;
    uintptr_t probes;

    if (!(flags & DCMD_ADDRSPEC))
        return (DCMD_USAGE);

    if (addr == DTRACE_IDNONE || addr > UINT32_MAX)
        goto out;

    if (mdb_readvar(&probes, "dtrace_probes") == -1) {
        mdb_warn("failed to read 'dtrace_probes'");
        return (DCMD_ERR);
    }

    probes += (addr - 1) * sizeof (dtrace_probe_t *);

    if (mdb_vread(&probe, sizeof (uintptr_t), probes) == -1) {
        mdb_warn("failed to read dtrace_probes[%d]", addr - 1);
        return (DCMD_ERR);
    }

out:
    mdb_printf("%p\n", probe);
    return (DCMD_OK);
}

void
dtrace_help(void)
{

    mdb_printf("Given a dtrace_state_t structure that represents a "
        "DTrace consumer, prints\n"
        "dtrace(1M)-like output for in-kernel DTrace data.  (The "
        "dtrace_state_t\n"
        "structures for all DTrace consumers may be obtained by running "
        "the \n"
        "::dtrace_state dcmd.)   When data is present on multiple CPUs, "
        "data are\n"
        "presented in CPU order, with records within each CPU ordered "
        "oldest to \n"
        "youngest.  Options:\n\n"
        "-c cpu     Only provide output for specified CPU.\n");
}

static int
dtracemdb_eprobe(dtrace_state_t *state, dtrace_eprobedesc_t *epd)
{
    dtrace_epid_t epid = epd->dtepd_epid;
    dtrace_probe_t probe;
    dtrace_ecb_t ecb;
    uintptr_t addr, paddr, ap;
    dtrace_action_t act;
    int nactions, nrecs;

    addr = (uintptr_t)state->dts_ecbs +
        (epid - 1) * sizeof (dtrace_ecb_t *);

    if (mdb_vread(&addr, sizeof (addr), addr) == -1) {
        mdb_warn("failed to read ecb for epid %d", epid);
        return (-1);
    }

    if (addr == NULL) {
        mdb_warn("epid %d doesn't match an ecb\n", epid);
        return (-1);
    }

    if (mdb_vread(&ecb, sizeof (ecb), addr) == -1) {
        mdb_warn("failed to read ecb at %p", addr);
        return (-1);
    }

    paddr = (uintptr_t)ecb.dte_probe;

    if (mdb_vread(&probe, sizeof (probe), paddr) == -1) {
        mdb_warn("failed to read probe for ecb %p", addr);
        return (-1);
    }

    /*
     * This is a little painful:  in order to find the number of actions,
     * we need to first walk through them.
     */
    for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) {
        if (mdb_vread(&act, sizeof (act), ap) == -1) {
            mdb_warn("failed to read action %p on ecb %p",
                ap, addr);
            return (-1);
        }

        if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple)
            nactions++;

        ap = (uintptr_t)act.dta_next;
    }

    nrecs = epd->dtepd_nrecs;
    epd->dtepd_nrecs = nactions;
    epd->dtepd_probeid = probe.dtpr_id;
    epd->dtepd_uarg = ecb.dte_uarg;
    epd->dtepd_size = ecb.dte_size;

    for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) {
        if (mdb_vread(&act, sizeof (act), ap) == -1) {
            mdb_warn("failed to read action %p on ecb %p",
                ap, addr);
            return (-1);
        }

        if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) {
            if (nrecs-- == 0)
                break;

            epd->dtepd_rec[nactions++] = act.dta_rec;
        }

        ap = (uintptr_t)act.dta_next;
    }

    return (0);
}

/*ARGSUSED*/
static int
dtracemdb_probe(dtrace_state_t *state, dtrace_probedesc_t *pd)
{
    uintptr_t base, addr, paddr, praddr;
    int nprobes, i;
    dtrace_probe_t probe;
    dtrace_provider_t prov;

    if (pd->dtpd_id == DTRACE_IDNONE)
        pd->dtpd_id++;

    if (mdb_readvar(&base, "dtrace_probes") == -1) {
        mdb_warn("failed to read 'dtrace_probes'");
        return (-1);
    }

    if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) {
        mdb_warn("failed to read 'dtrace_nprobes'");
        return (-1);
    }

    for (i = pd->dtpd_id; i <= nprobes; i++) {
        addr = base + (i - 1) * sizeof (dtrace_probe_t *);

        if (mdb_vread(&paddr, sizeof (paddr), addr) == -1) {
            mdb_warn("couldn't read probe pointer at %p", addr);
            return (-1);
        }

        if (paddr != NULL)
            break;
    }

    if (paddr == NULL) {
        errno = ESRCH;
        return (-1);
    }

    if (mdb_vread(&probe, sizeof (probe), paddr) == -1) {
        mdb_warn("couldn't read probe at %p", paddr);
        return (-1);
    }

    pd->dtpd_id = probe.dtpr_id;

    if (mdb_vread(pd->dtpd_name, DTRACE_NAMELEN,
        (uintptr_t)probe.dtpr_name) == -1) {
        mdb_warn("failed to read probe name for probe %p", paddr);
        return (-1);
    }

    if (mdb_vread(pd->dtpd_func, DTRACE_FUNCNAMELEN,
        (uintptr_t)probe.dtpr_func) == -1) {
        mdb_warn("failed to read function name for probe %p", paddr);
        return (-1);
    }

    if (mdb_vread(pd->dtpd_mod, DTRACE_MODNAMELEN,
        (uintptr_t)probe.dtpr_mod) == -1) {
        mdb_warn("failed to read module name for probe %p", paddr);
        return (-1);
    }

    praddr = (uintptr_t)probe.dtpr_provider;

    if (mdb_vread(&prov, sizeof (prov), praddr) == -1) {
        mdb_warn("failed to read provider for probe %p", paddr);
        return (-1);
    }

    if (mdb_vread(pd->dtpd_provider, DTRACE_PROVNAMELEN,
        (uintptr_t)prov.dtpv_name) == -1) {
        mdb_warn("failed to read provider name for probe %p", paddr);
        return (-1);
    }

    return (0);
}

/*ARGSUSED*/
static int
dtracemdb_aggdesc(dtrace_state_t *state, dtrace_aggdesc_t *agd)
{
    dtrace_aggid_t aggid = agd->dtagd_id;
    dtrace_aggregation_t agg;
    dtrace_ecb_t ecb;
    uintptr_t addr, eaddr, ap, last;
    dtrace_action_t act;
    dtrace_recdesc_t *lrec;
    int nactions, nrecs;

    addr = (uintptr_t)state->dts_aggregations +
        (aggid - 1) * sizeof (dtrace_aggregation_t *);

    if (mdb_vread(&addr, sizeof (addr), addr) == -1) {
        mdb_warn("failed to read aggregation for aggid %d", aggid);
        return (-1);
    }

    if (addr == NULL) {
        mdb_warn("aggid %d doesn't match an aggregation\n", aggid);
        return (-1);
    }

    if (mdb_vread(&agg, sizeof (agg), addr) == -1) {
        mdb_warn("failed to read aggregation at %p", addr);
        return (-1);
    }

    eaddr = (uintptr_t)agg.dtag_ecb;

    if (mdb_vread(&ecb, sizeof (ecb), eaddr) == -1) {
        mdb_warn("failed to read ecb for aggregation %p", addr);
        return (-1);
    }

    last = (uintptr_t)addr + offsetof(dtrace_aggregation_t, dtag_action);

    /*
     * This is a little painful:  in order to find the number of actions,
     * we need to first walk through them.
     */
    ap = (uintptr_t)agg.dtag_first;
    nactions = 0;

    for (;;) {
        if (mdb_vread(&act, sizeof (act), ap) == -1) {
            mdb_warn("failed to read action %p on aggregation %p",
                ap, addr);
            return (-1);
        }

        nactions++;

        if (ap == last)
            break;

        ap = (uintptr_t)act.dta_next;
    }

    lrec = &act.dta_rec;
    agd->dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - agg.dtag_base;

    nrecs = agd->dtagd_nrecs;
    agd->dtagd_nrecs = nactions;
    agd->dtagd_epid = ecb.dte_epid;

    ap = (uintptr_t)agg.dtag_first;
    nactions = 0;

    for (;;) {
        dtrace_recdesc_t rec;

        if (mdb_vread(&act, sizeof (act), ap) == -1) {
            mdb_warn("failed to read action %p on aggregation %p",
                ap, addr);
            return (-1);
        }

        if (nrecs-- == 0)
            break;

        rec = act.dta_rec;
        rec.dtrd_offset -= agg.dtag_base;
        rec.dtrd_uarg = 0;
        agd->dtagd_rec[nactions++] = rec;

        if (ap == last)
            break;

        ap = (uintptr_t)act.dta_next;
    }

    return (0);
}

static int
dtracemdb_bufsnap(dtrace_buffer_t *which, dtrace_bufdesc_t *desc)
{
    uintptr_t addr;
    size_t bufsize;
    dtrace_buffer_t buf;
    caddr_t data = desc->dtbd_data;
    processorid_t max_cpuid, cpu = desc->dtbd_cpu;

    if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) {
        mdb_warn("failed to read 'max_cpuid'");
        errno = EIO;
        return (-1);
    }

    if (cpu < 0 || cpu > max_cpuid) {
        errno = EINVAL;
        return (-1);
    }

    addr = (uintptr_t)which + cpu * sizeof (dtrace_buffer_t);

    if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
        mdb_warn("failed to read buffer description at %p", addr);
        errno = EIO;
        return (-1);
    }

    if (buf.dtb_tomax == NULL) {
        errno = ENOENT;
        return (-1);
    }

    if (buf.dtb_flags & DTRACEBUF_WRAPPED) {
        bufsize = buf.dtb_size;
    } else {
        bufsize = buf.dtb_offset;
    }

    if (mdb_vread(data, bufsize, (uintptr_t)buf.dtb_tomax) == -1) {
        mdb_warn("couldn't read buffer for CPU %d", cpu);
        errno = EIO;
        return (-1);
    }

    if (buf.dtb_offset > buf.dtb_size) {
        mdb_warn("buffer for CPU %d has corrupt offset\n", cpu);
        errno = EIO;
        return (-1);
    }

    if (buf.dtb_flags & DTRACEBUF_WRAPPED) {
        if (buf.dtb_xamot_offset > buf.dtb_size) {
            mdb_warn("ringbuffer for CPU %d has corrupt "
                "wrapped offset\n", cpu);
            errno = EIO;
            return (-1);
        }

        /*
         * If the ring buffer has wrapped, it needs to be polished.
         * See the comment in dtrace_buffer_polish() for details.
         */
        if (buf.dtb_offset < buf.dtb_xamot_offset) {
            bzero(data + buf.dtb_offset,
                buf.dtb_xamot_offset - buf.dtb_offset);
        }

        if (buf.dtb_offset > buf.dtb_xamot_offset) {
            bzero(data + buf.dtb_offset,
                buf.dtb_size - buf.dtb_offset);
            bzero(data, buf.dtb_xamot_offset);
        }

        desc->dtbd_oldest = buf.dtb_xamot_offset;
    } else {
        desc->dtbd_oldest = 0;
    }

    desc->dtbd_size = bufsize;
    desc->dtbd_drops = buf.dtb_drops;
    desc->dtbd_errors = buf.dtb_errors;

    return (0);
}

/*
 * This is essentially identical to its cousin in the kernel.
 */
static dof_hdr_t *
dtracemdb_dof_create(dtrace_state_t *state)
{
    dof_hdr_t *dof;
    dof_sec_t *sec;
    dof_optdesc_t *opt;
    int i, len = sizeof (dof_hdr_t) +
        roundup(sizeof (dof_sec_t), sizeof (uint64_t)) +
        sizeof (dof_optdesc_t) * DTRACEOPT_MAX;

    dof = mdb_zalloc(len, UM_SLEEP);
    dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0;
    dof->dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1;
    dof->dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2;
    dof->dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3;

    dof->dofh_ident[DOF_ID_MODEL] = DOF_MODEL_NATIVE;
    dof->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE;
    dof->dofh_ident[DOF_ID_VERSION] = DOF_VERSION;
    dof->dofh_ident[DOF_ID_DIFVERS] = DIF_VERSION;
    dof->dofh_ident[DOF_ID_DIFIREG] = DIF_DIR_NREGS;
    dof->dofh_ident[DOF_ID_DIFTREG] = DIF_DTR_NREGS;

    dof->dofh_flags = 0;
    dof->dofh_hdrsize = sizeof (dof_hdr_t);
    dof->dofh_secsize = sizeof (dof_sec_t);
    dof->dofh_secnum = 1;   /* only DOF_SECT_OPTDESC */
    dof->dofh_secoff = sizeof (dof_hdr_t);
    dof->dofh_loadsz = len;
    dof->dofh_filesz = len;
    dof->dofh_pad = 0;

    /*
     * Fill in the option section header...
     */
    sec = (dof_sec_t *)((uintptr_t)dof + sizeof (dof_hdr_t));
    sec->dofs_type = DOF_SECT_OPTDESC;
    sec->dofs_align = sizeof (uint64_t);
    sec->dofs_flags = DOF_SECF_LOAD;
    sec->dofs_entsize = sizeof (dof_optdesc_t);

    opt = (dof_optdesc_t *)((uintptr_t)sec +
        roundup(sizeof (dof_sec_t), sizeof (uint64_t)));

    sec->dofs_offset = (uintptr_t)opt - (uintptr_t)dof;
    sec->dofs_size = sizeof (dof_optdesc_t) * DTRACEOPT_MAX;

    for (i = 0; i < DTRACEOPT_MAX; i++) {
        opt[i].dofo_option = i;
        opt[i].dofo_strtab = DOF_SECIDX_NONE;
        opt[i].dofo_value = state->dts_options[i];
    }

    return (dof);
}

static int
dtracemdb_format(dtrace_state_t *state, dtrace_fmtdesc_t *desc)
{
    uintptr_t addr, faddr;
    char c;
    int len = 0;

    if (desc->dtfd_format == 0 || desc->dtfd_format > state->dts_nformats) {
        errno = EINVAL;
        return (-1);
    }

    faddr = (uintptr_t)state->dts_formats +
        (desc->dtfd_format - 1) * sizeof (char *);

    if (mdb_vread(&addr, sizeof (addr), faddr) == -1) {
        mdb_warn("failed to read format string pointer at %p", faddr);
        return (-1);
    }

    do {
        if (mdb_vread(&c, sizeof (c), addr + len++) == -1) {
            mdb_warn("failed to read format string at %p", addr);
            return (-1);
        }
    } while (c != '\0');

    if (len > desc->dtfd_length) {
        desc->dtfd_length = len;
        return (0);
    }

    if (mdb_vread(desc->dtfd_string, len, addr) == -1) {
        mdb_warn("failed to reread format string at %p", addr);
        return (-1);
    }

    return (0);
}

static int
dtracemdb_status(dtrace_state_t *state, dtrace_status_t *status)
{
    dtrace_dstate_t *dstate;
    int i, j;
    uint64_t nerrs;
    uintptr_t addr;
    int ncpu;

    if (mdb_readvar(&ncpu, "_ncpu") == -1) {
        mdb_warn("failed to read '_ncpu'");
        return (DCMD_ERR);
    }

    bzero(status, sizeof (dtrace_status_t));

    if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) {
        errno = ENOENT;
        return (-1);
    }

    /*
     * For the MDB backend, we never set dtst_exiting or dtst_filled.  This
     * is by design:  we don't want the library to try to stop tracing,
     * because it doesn't particularly mean anything.
     */
    nerrs = state->dts_errors;
    dstate = &state->dts_vstate.dtvs_dynvars;

    for (i = 0; i < ncpu; i++) {
        dtrace_dstate_percpu_t dcpu;
        dtrace_buffer_t buf;

        addr = (uintptr_t)&dstate->dtds_percpu[i];

        if (mdb_vread(&dcpu, sizeof (dcpu), addr) == -1) {
            mdb_warn("failed to read per-CPU dstate at %p", addr);
            return (-1);
        }

        status->dtst_dyndrops += dcpu.dtdsc_drops;
        status->dtst_dyndrops_dirty += dcpu.dtdsc_dirty_drops;
        status->dtst_dyndrops_rinsing += dcpu.dtdsc_rinsing_drops;

        addr = (uintptr_t)&state->dts_buffer[i];

        if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
            mdb_warn("failed to read per-CPU buffer at %p", addr);
            return (-1);
        }

        nerrs += buf.dtb_errors;

        for (j = 0; j < state->dts_nspeculations; j++) {
            dtrace_speculation_t spec;

            addr = (uintptr_t)&state->dts_speculations[j];

            if (mdb_vread(&spec, sizeof (spec), addr) == -1) {
                mdb_warn("failed to read "
                    "speculation at %p", addr);
                return (-1);
            }

            addr = (uintptr_t)&spec.dtsp_buffer[i];

            if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
                mdb_warn("failed to read "
                    "speculative buffer at %p", addr);
                return (-1);
            }

            status->dtst_specdrops += buf.dtb_xamot_drops;
        }
    }

    status->dtst_specdrops_busy = state->dts_speculations_busy;
    status->dtst_specdrops_unavail = state->dts_speculations_unavail;
    status->dtst_errors = nerrs;

    return (0);
}

typedef struct dtracemdb_data {
    dtrace_state_t *dtmd_state;
    char *dtmd_symstr;
    char *dtmd_modstr;
    uintptr_t dtmd_addr;
} dtracemdb_data_t;

static int
dtracemdb_ioctl(void *varg, int cmd, void *arg)
{
    dtracemdb_data_t *data = varg;
    dtrace_state_t *state = data->dtmd_state;

    switch (cmd) {
    case DTRACEIOC_CONF: {
        dtrace_conf_t *conf = arg;

        bzero(conf, sizeof (conf));
        conf->dtc_difversion = DIF_VERSION;
        conf->dtc_difintregs = DIF_DIR_NREGS;
        conf->dtc_diftupregs = DIF_DTR_NREGS;
        conf->dtc_ctfmodel = CTF_MODEL_NATIVE;

        return (0);
    }

    case DTRACEIOC_DOFGET: {
        dof_hdr_t *hdr = arg, *dof;

        dof = dtracemdb_dof_create(state);
        bcopy(dof, hdr, MIN(hdr->dofh_loadsz, dof->dofh_loadsz));
        mdb_free(dof, dof->dofh_loadsz);

        return (0);
    }

    case DTRACEIOC_BUFSNAP:
        return (dtracemdb_bufsnap(state->dts_buffer, arg));

    case DTRACEIOC_AGGSNAP:
        return (dtracemdb_bufsnap(state->dts_aggbuffer, arg));

    case DTRACEIOC_AGGDESC:
        return (dtracemdb_aggdesc(state, arg));

    case DTRACEIOC_EPROBE:
        return (dtracemdb_eprobe(state, arg));

    case DTRACEIOC_PROBES:
        return (dtracemdb_probe(state, arg));

    case DTRACEIOC_FORMAT:
        return (dtracemdb_format(state, arg));

    case DTRACEIOC_STATUS:
        return (dtracemdb_status(state, arg));

    case DTRACEIOC_GO:
        *(processorid_t *)arg = -1;
        return (0);

    case DTRACEIOC_ENABLE:
        errno = ENOTTY; /* see dt_open.c:dtrace_go() */
        return (-1);

    case DTRACEIOC_PROVIDER:
    case DTRACEIOC_PROBEMATCH:
        errno = ESRCH;
        return (-1);

    default:
        mdb_warn("unexpected ioctl 0x%x (%s)\n", cmd,
            cmd == DTRACEIOC_PROVIDER   ? "DTRACEIOC_PROVIDER" :
            cmd == DTRACEIOC_PROBES ? "DTRACEIOC_PROBES" :
            cmd == DTRACEIOC_BUFSNAP    ? "DTRACEIOC_BUFSNAP" :
            cmd == DTRACEIOC_PROBEMATCH ? "DTRACEIOC_PROBEMATCH" :
            cmd == DTRACEIOC_ENABLE ? "DTRACEIOC_ENABLE" :
            cmd == DTRACEIOC_AGGSNAP    ? "DTRACEIOC_AGGSNAP" :
            cmd == DTRACEIOC_EPROBE ? "DTRACEIOC_EPROBE" :
            cmd == DTRACEIOC_PROBEARG   ? "DTRACEIOC_PROBEARG" :
            cmd == DTRACEIOC_CONF   ? "DTRACEIOC_CONF" :
            cmd == DTRACEIOC_STATUS ? "DTRACEIOC_STATUS" :
            cmd == DTRACEIOC_GO     ? "DTRACEIOC_GO" :
            cmd == DTRACEIOC_STOP   ? "DTRACEIOC_STOP" :
            cmd == DTRACEIOC_AGGDESC    ? "DTRACEIOC_AGGDESC" :
            cmd == DTRACEIOC_FORMAT ? "DTRACEIOC_FORMAT" :
            cmd == DTRACEIOC_DOFGET ? "DTRACEIOC_DOFGET" :
            cmd == DTRACEIOC_REPLICATE  ? "DTRACEIOC_REPLICATE" :
            "???");
        errno = ENXIO;
        return (-1);
    }
}

static int
dtracemdb_modctl(uintptr_t addr, const struct modctl *m, dtracemdb_data_t *data)
{
    struct module mod;

    if (m->mod_mp == NULL)
        return (WALK_NEXT);

    if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) {
        mdb_warn("couldn't read modctl %p's module", addr);
        return (WALK_NEXT);
    }

    if ((uintptr_t)mod.text > data->dtmd_addr)
        return (WALK_NEXT);

    if ((uintptr_t)mod.text + mod.text_size <= data->dtmd_addr)
        return (WALK_NEXT);

    if (mdb_readstr(data->dtmd_modstr, MDB_SYM_NAMLEN,
        (uintptr_t)m->mod_modname) == -1)
        return (WALK_ERR);

    return (WALK_DONE);
}

static int
dtracemdb_lookup_by_addr(void *varg, GElf_Addr addr, GElf_Sym *symp,
    dtrace_syminfo_t *sip)
{
    dtracemdb_data_t *data = varg;

    if (data->dtmd_symstr == NULL) {
        data->dtmd_symstr = mdb_zalloc(MDB_SYM_NAMLEN,
            UM_SLEEP | UM_GC);
    }

    if (data->dtmd_modstr == NULL) {
        data->dtmd_modstr = mdb_zalloc(MDB_SYM_NAMLEN,
            UM_SLEEP | UM_GC);
    }

    if (symp != NULL) {
        if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, data->dtmd_symstr,
            MDB_SYM_NAMLEN, symp) == -1)
            return (-1);
    }

    if (sip != NULL) {
        data->dtmd_addr = addr;

        (void) strcpy(data->dtmd_modstr, "???");

        if (mdb_walk("modctl",
            (mdb_walk_cb_t)dtracemdb_modctl, varg) == -1) {
            mdb_warn("couldn't walk 'modctl'");
            return (-1);
        }

        sip->dts_object = data->dtmd_modstr;
        sip->dts_id = 0;
        sip->dts_name = symp != NULL ? data->dtmd_symstr : NULL;
    }

    return (0);
}

/*ARGSUSED*/
static int
dtracemdb_stat(void *varg, processorid_t cpu)
{
    GElf_Sym sym;
    cpu_t c;
    uintptr_t caddr, addr;

    if (mdb_lookup_by_name("cpu", &sym) == -1) {
        mdb_warn("failed to find symbol for 'cpu'");
        return (-1);
    }

    if (cpu * sizeof (uintptr_t) > sym.st_size)
        return (-1);

    addr = (uintptr_t)sym.st_value + cpu * sizeof (uintptr_t);

    if (mdb_vread(&caddr, sizeof (caddr), addr) == -1) {
        mdb_warn("failed to read cpu[%d]", cpu);
        return (-1);
    }

    if (caddr == NULL)
        return (-1);

    if (mdb_vread(&c, sizeof (c), caddr) == -1) {
        mdb_warn("failed to read cpu at %p", caddr);
        return (-1);
    }

    if (c.cpu_flags & CPU_POWEROFF) {
        return (P_POWEROFF);
    } else if (c.cpu_flags & CPU_SPARE) {
        return (P_SPARE);
    } else if (c.cpu_flags & CPU_FAULTED) {
        return (P_FAULTED);
    } else if ((c.cpu_flags & (CPU_READY | CPU_OFFLINE)) != CPU_READY) {
        return (P_OFFLINE);
    } else if (c.cpu_flags & CPU_ENABLE) {
        return (P_ONLINE);
    } else {
        return (P_NOINTR);
    }
}

/*ARGSUSED*/
static long
dtracemdb_sysconf(void *varg, int name)
{
    int max_ncpus;
    processorid_t max_cpuid;

    switch (name) {
    case _SC_CPUID_MAX:
        if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) {
            mdb_warn("failed to read 'max_cpuid'");
            return (-1);
        }

        return (max_cpuid);

    case _SC_NPROCESSORS_MAX:
        if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
            mdb_warn("failed to read 'max_ncpus'");
            return (-1);
        }

        return (max_ncpus);

    default:
        mdb_warn("unexpected sysconf code %d\n", name);
        return (-1);
    }
}

const dtrace_vector_t dtrace_mdbops = {
    dtracemdb_ioctl,
    dtracemdb_lookup_by_addr,
    dtracemdb_stat,
    dtracemdb_sysconf
};

typedef struct dtrace_dcmddata {
    dtrace_hdl_t *dtdd_dtp;
    int dtdd_cpu;
    int dtdd_quiet;
    int dtdd_flowindent;
    int dtdd_heading;
} dtrace_dcmddata_t;

/*ARGSUSED*/
static int
dtrace_dcmdrec(const dtrace_probedata_t *data,
    const dtrace_recdesc_t *rec, void *arg)
{
    dtrace_dcmddata_t *dd = arg;

    if (rec == NULL) {
        /*
         * We have processed the final record; output the newline if
         * we're not in quiet mode.
         */
        if (!dd->dtdd_quiet)
            mdb_printf("\n");

        return (DTRACE_CONSUME_NEXT);
    }

    return (DTRACE_CONSUME_THIS);
}

/*ARGSUSED*/
static int
dtrace_dcmdprobe(const dtrace_probedata_t *data, void *arg)
{
    dtrace_probedesc_t *pd = data->dtpda_pdesc;
    processorid_t cpu = data->dtpda_cpu;
    dtrace_dcmddata_t *dd = arg;
    char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2];

    if (dd->dtdd_cpu != -1UL && dd->dtdd_cpu != cpu)
        return (DTRACE_CONSUME_NEXT);

    if (dd->dtdd_heading == 0) {
        if (!dd->dtdd_flowindent) {
            if (!dd->dtdd_quiet) {
                mdb_printf("%3s %6s %32s\n",
                    "CPU", "ID", "FUNCTION:NAME");
            }
        } else {
            mdb_printf("%3s %-41s\n", "CPU", "FUNCTION");
        }
        dd->dtdd_heading = 1;
    }

    if (!dd->dtdd_flowindent) {
        if (!dd->dtdd_quiet) {
            (void) mdb_snprintf(name, sizeof (name), "%s:%s",
                pd->dtpd_func, pd->dtpd_name);

            mdb_printf("%3d %6d %32s ", cpu, pd->dtpd_id, name);
        }
    } else {
        int indent = data->dtpda_indent;

        if (data->dtpda_flow == DTRACEFLOW_NONE) {
            (void) mdb_snprintf(name, sizeof (name), "%*s%s%s:%s",
                indent, "", data->dtpda_prefix, pd->dtpd_func,
                pd->dtpd_name);
        } else {
            (void) mdb_snprintf(name, sizeof (name), "%*s%s%s",
                indent, "", data->dtpda_prefix, pd->dtpd_func);
        }

        mdb_printf("%3d %-41s ", cpu, name);
    }

    return (DTRACE_CONSUME_THIS);
}

/*ARGSUSED*/
static int
dtrace_dcmderr(const dtrace_errdata_t *data, void *arg)
{
    mdb_warn(data->dteda_msg);
    return (DTRACE_HANDLE_OK);
}

/*ARGSUSED*/
static int
dtrace_dcmddrop(const dtrace_dropdata_t *data, void *arg)
{
    mdb_warn(data->dtdda_msg);
    return (DTRACE_HANDLE_OK);
}

/*ARGSUSED*/
static int
dtrace_dcmdbuffered(const dtrace_bufdata_t *bufdata, void *arg)
{
    mdb_printf("%s", bufdata->dtbda_buffered);
    return (DTRACE_HANDLE_OK);
}

/*ARGSUSED*/
int
dtrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    dtrace_state_t state;
    dtrace_hdl_t *dtp;
    int ncpu, err;
    uintptr_t c = -1UL;
    dtrace_dcmddata_t dd;
    dtrace_optval_t val;
    dtracemdb_data_t md;
    int rval = DCMD_ERR;

    if (!(flags & DCMD_ADDRSPEC))
        return (DCMD_USAGE);

    if (mdb_getopts(argc, argv, 'c', MDB_OPT_UINTPTR, &c, NULL) != argc)
        return (DCMD_USAGE);

    if (mdb_readvar(&ncpu, "_ncpu") == -1) {
        mdb_warn("failed to read '_ncpu'");
        return (DCMD_ERR);
    }

    if (mdb_vread(&state, sizeof (state), addr) == -1) {
        mdb_warn("couldn't read dtrace_state_t at %p", addr);
        return (DCMD_ERR);
    }

    bzero(&md, sizeof (md));
    md.dtmd_state = &state;

    if ((dtp = dtrace_vopen(DTRACE_VERSION, DTRACE_O_NOSYS, &err,
        &dtrace_mdbops, &md)) == NULL) {
        mdb_warn("failed to initialize dtrace: %s\n",
            dtrace_errmsg(NULL, err));
        return (DCMD_ERR);
    }

    if (dtrace_go(dtp) != 0) {
        mdb_warn("failed to initialize dtrace: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    bzero(&dd, sizeof (dd));
    dd.dtdd_dtp = dtp;
    dd.dtdd_cpu = c;

    if (dtrace_getopt(dtp, "flowindent", &val) == -1) {
        mdb_warn("couldn't get 'flowindent' option: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    dd.dtdd_flowindent = (val != DTRACEOPT_UNSET);

    if (dtrace_getopt(dtp, "quiet", &val) == -1) {
        mdb_warn("couldn't get 'quiet' option: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    dd.dtdd_quiet = (val != DTRACEOPT_UNSET);

    if (dtrace_handle_err(dtp, dtrace_dcmderr, NULL) == -1) {
        mdb_warn("couldn't add err handler: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    if (dtrace_handle_drop(dtp, dtrace_dcmddrop, NULL) == -1) {
        mdb_warn("couldn't add drop handler: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    if (dtrace_handle_buffered(dtp, dtrace_dcmdbuffered, NULL) == -1) {
        mdb_warn("couldn't add buffered handler: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    if (dtrace_status(dtp) == -1) {
        mdb_warn("couldn't get status: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    if (dtrace_aggregate_snap(dtp) == -1) {
        mdb_warn("couldn't snapshot aggregation: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    if (dtrace_consume(dtp, NULL,
        dtrace_dcmdprobe, dtrace_dcmdrec, &dd) == -1) {
        mdb_warn("couldn't consume DTrace buffers: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
    }

    if (dtrace_aggregate_print(dtp, NULL, NULL) == -1) {
        mdb_warn("couldn't print aggregation: %s\n",
            dtrace_errmsg(dtp, dtrace_errno(dtp)));
        goto err;
    }

    rval = DCMD_OK;
err:
    dtrace_close(dtp);
    return (rval);
}

static int
dtrace_errhash_cmp(const void *l, const void *r)
{
    uintptr_t lhs = *((uintptr_t *)l);
    uintptr_t rhs = *((uintptr_t *)r);
    dtrace_errhash_t lerr, rerr;
    char lmsg[256], rmsg[256];

    (void) mdb_vread(&lerr, sizeof (lerr), lhs);
    (void) mdb_vread(&rerr, sizeof (rerr), rhs);

    if (lerr.dter_msg == NULL)
        return (-1);

    if (rerr.dter_msg == NULL)
        return (1);

    (void) mdb_readstr(lmsg, sizeof (lmsg), (uintptr_t)lerr.dter_msg);
    (void) mdb_readstr(rmsg, sizeof (rmsg), (uintptr_t)rerr.dter_msg);

    return (strcmp(lmsg, rmsg));
}

int
dtrace_errhash_init(mdb_walk_state_t *wsp)
{
    GElf_Sym sym;
    uintptr_t *hash, addr;
    int i;

    if (wsp->walk_addr != NULL) {
        mdb_warn("dtrace_errhash walk only supports global walks\n");
        return (WALK_ERR);
    }

    if (mdb_lookup_by_name("dtrace_errhash", &sym) == -1) {
        mdb_warn("couldn't find 'dtrace_errhash' (non-DEBUG kernel?)");
        return (WALK_ERR);
    }

    addr = (uintptr_t)sym.st_value;
    hash = mdb_alloc(DTRACE_ERRHASHSZ * sizeof (uintptr_t),
        UM_SLEEP | UM_GC);

    for (i = 0; i < DTRACE_ERRHASHSZ; i++)
        hash[i] = addr + i * sizeof (dtrace_errhash_t);

    qsort(hash, DTRACE_ERRHASHSZ, sizeof (uintptr_t), dtrace_errhash_cmp);

    wsp->walk_addr = 0;
    wsp->walk_data = hash;

    return (WALK_NEXT);
}

int
dtrace_errhash_step(mdb_walk_state_t *wsp)
{
    int ndx = (int)wsp->walk_addr;
    uintptr_t *hash = wsp->walk_data;
    dtrace_errhash_t err;
    uintptr_t addr;

    if (ndx >= DTRACE_ERRHASHSZ)
        return (WALK_DONE);

    wsp->walk_addr = ndx + 1;
    addr = hash[ndx];

    if (mdb_vread(&err, sizeof (err), addr) == -1) {
        mdb_warn("failed to read dtrace_errhash_t at %p", addr);
        return (WALK_DONE);
    }

    if (err.dter_msg == NULL)
        return (WALK_NEXT);

    return (wsp->walk_callback(addr, &err, wsp->walk_cbdata));
}

/*ARGSUSED*/
int
dtrace_errhash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    dtrace_errhash_t err;
    char msg[256];

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("dtrace_errhash", "dtrace_errhash",
            argc, argv) == -1) {
            mdb_warn("can't walk 'dtrace_errhash'");
            return (DCMD_ERR);
        }

        return (DCMD_OK);
    }

    if (DCMD_HDRSPEC(flags))
        mdb_printf("%8s %s\n", "COUNT", "ERROR");

    if (mdb_vread(&err, sizeof (err), addr) == -1) {
        mdb_warn("failed to read dtrace_errhash_t at %p", addr);
        return (DCMD_ERR);
    }

    addr = (uintptr_t)err.dter_msg;

    if (mdb_readstr(msg, sizeof (msg), addr) == -1) {
        mdb_warn("failed to read error msg at %p", addr);
        return (DCMD_ERR);
    }

    mdb_printf("%8d %s", err.dter_count, msg);

    /*
     * Some error messages include a newline -- only print the newline
     * if the message doesn't have one.
     */
    if (msg[strlen(msg) - 1] != '\n')
        mdb_printf("\n");

    return (DCMD_OK);
}

int
dtrace_helptrace_init(mdb_walk_state_t *wsp)
{
    uint32_t next;
    int enabled;

    if (wsp->walk_addr != NULL) {
        mdb_warn("dtrace_helptrace only supports global walks\n");
        return (WALK_ERR);
    }

    if (mdb_readvar(&enabled, "dtrace_helptrace_enabled") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_enabled'");
        return (WALK_ERR);
    }

    if (!enabled) {
        mdb_warn("helper tracing is not enabled\n");
        return (WALK_ERR);
    }

    if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_next'");
        return (WALK_ERR);
    }

    wsp->walk_addr = next;

    return (WALK_NEXT);
}

int
dtrace_helptrace_step(mdb_walk_state_t *wsp)
{
    uint32_t next, size, nlocals, bufsize;
    uintptr_t buffer, addr;
    dtrace_helptrace_t *ht;
    int rval;

    if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_next'");
        return (WALK_ERR);
    }

    if (mdb_readvar(&bufsize, "dtrace_helptrace_bufsize") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_bufsize'");
        return (WALK_ERR);
    }

    if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_buffer'");
        return (WALK_ERR);
    }

    if (mdb_readvar(&nlocals, "dtrace_helptrace_nlocals") == -1) {
        mdb_warn("couldn't read 'dtrace_helptrace_nlocals'");
        return (WALK_ERR);
    }

    size = sizeof (dtrace_helptrace_t) +
        nlocals * sizeof (uint64_t) - sizeof (uint64_t);

    if (wsp->walk_addr + size > bufsize) {
        if (next == 0)
            return (WALK_DONE);

        wsp->walk_addr = 0;
    }

    addr = buffer + wsp->walk_addr;
    ht = alloca(size);

    if (mdb_vread(ht, size, addr) == -1) {
        mdb_warn("couldn't read entry at %p", addr);
        return (WALK_ERR);
    }

    if (ht->dtht_helper != NULL) {
        rval = wsp->walk_callback(addr, ht, wsp->walk_cbdata);

        if (rval != WALK_NEXT)
            return (rval);
    }

    if (wsp->walk_addr < next && wsp->walk_addr + size >= next)
        return (WALK_DONE);

    wsp->walk_addr += size;
    return (WALK_NEXT);
}

int
dtrace_helptrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    dtrace_helptrace_t help;
    dtrace_helper_action_t helper;
    char where[30];
    uint_t opt_v = FALSE;
    uintptr_t haddr;

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("dtrace_helptrace", "dtrace_helptrace",
            argc, argv) == -1) {
            mdb_warn("can't walk 'dtrace_helptrace'");
            return (DCMD_ERR);
        }

        return (DCMD_OK);
    }

    if (mdb_getopts(argc, argv, 'v',
        MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
        return (DCMD_USAGE);

    if (DCMD_HDRSPEC(flags)) {
        mdb_printf(" %?s %?s %12s %s\n",
            "ADDR", "HELPER", "WHERE", "DIFO");
    }

    if (mdb_vread(&help, sizeof (help), addr) == -1) {
        mdb_warn("failed to read dtrace_helptrace_t at %p", addr);
        return (DCMD_ERR);
    }

    switch (help.dtht_where) {
    case 0:
        (void) mdb_snprintf(where, sizeof (where), "predicate");
        break;

    case DTRACE_HELPTRACE_NEXT:
        (void) mdb_snprintf(where, sizeof (where), "next");
        break;

    case DTRACE_HELPTRACE_DONE:
        (void) mdb_snprintf(where, sizeof (where), "done");
        break;

    case DTRACE_HELPTRACE_ERR:
        (void) mdb_snprintf(where, sizeof (where), "err");
        break;

    default:
        (void) mdb_snprintf(where, sizeof (where),
            "action #%d", help.dtht_where);
        break;
    }

    mdb_printf(" %?p %?p %12s ", addr, help.dtht_helper, where);

    haddr = (uintptr_t)help.dtht_helper;

    if (mdb_vread(&helper, sizeof (helper), haddr) == -1) {
        /*
         * We're not going to warn in this case -- we're just not going
         * to print anything exciting.
         */
        mdb_printf("???\n");
    } else {
        switch (help.dtht_where) {
        case 0:
            mdb_printf("%p\n", helper.dtha_predicate);
            break;

        case DTRACE_HELPTRACE_NEXT:
        case DTRACE_HELPTRACE_DONE:
        case DTRACE_HELPTRACE_ERR:
            mdb_printf("-\n");
            break;

        default:
            haddr = (uintptr_t)helper.dtha_actions +
                (help.dtht_where - 1) * sizeof (uintptr_t);

            if (mdb_vread(&haddr, sizeof (haddr), haddr) == -1) {
                mdb_printf("???\n");
            } else {
                mdb_printf("%p\n", haddr);
            }
        }
    }

    if (opt_v) {
        int i;

        if (help.dtht_where == DTRACE_HELPTRACE_ERR) {
            int f = help.dtht_fault;

            mdb_printf("%?s| %?s %10s |\n", "", "", "");
            mdb_printf("%?s| %?s %10s +->  fault: %s\n", "", "", "",
                f == DTRACEFLT_BADADDR ? "BADADDR" :
                f == DTRACEFLT_BADALIGN ? "BADALIGN" :
                f == DTRACEFLT_ILLOP ? "ILLOP" :
                f == DTRACEFLT_DIVZERO ? "DIVZERO" :
                f == DTRACEFLT_NOSCRATCH ? "NOSCRATCH" :
                f == DTRACEFLT_KPRIV ? "KPRIV" :
                f == DTRACEFLT_UPRIV ? "UPRIV" :
                f == DTRACEFLT_TUPOFLOW ? "TUPOFLOW" :
                f == DTRACEFLT_BADSTACK ? "BADSTACK" :
                "DTRACEFLT_UNKNOWN");
            mdb_printf("%?s| %?s %12s     addr: 0x%x\n", "", "", "",
                help.dtht_illval);
            mdb_printf("%?s| %?s %12s   offset: %d\n", "", "", "",
                help.dtht_fltoffs);
        }

        mdb_printf("%?s|\n%?s+--> %?s %4s %s\n", "", "",
            "ADDR", "NDX", "VALUE");
        addr += sizeof (help) - sizeof (uint64_t);

        for (i = 0; i < help.dtht_nlocals; i++) {
            uint64_t val;

            if (mdb_vread(&val, sizeof (val), addr) == -1) {
                mdb_warn("couldn't read local at %p", addr);
                continue;
            }

            mdb_printf("%?s     %?p %4d %p\n", "", addr, i, val);
            addr += sizeof (uint64_t);
        }

        mdb_printf("\n");
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
dtrace_state_walk(uintptr_t addr, const vmem_seg_t *seg, minor_t *highest)
{
    if (seg->vs_end > *highest)
        *highest = seg->vs_end;

    return (WALK_NEXT);
}

typedef struct dtrace_state_walk {
    uintptr_t dtsw_softstate;
    minor_t dtsw_max;
    minor_t dtsw_current;
} dtrace_state_walk_t;

int
dtrace_state_init(mdb_walk_state_t *wsp)
{
    uintptr_t dtrace_minor;
    minor_t max = 0;
    dtrace_state_walk_t *dw;

    if (wsp->walk_addr != NULL) {
        mdb_warn("dtrace_state only supports global walks\n");
        return (WALK_ERR);
    }

    /*
     * Find the dtrace_minor vmem arena and walk it to get the maximum
     * minor number.
     */
    if (mdb_readvar(&dtrace_minor, "dtrace_minor") == -1) {
        mdb_warn("failed to read 'dtrace_minor'");
        return (WALK_ERR);
    }

    if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)dtrace_state_walk,
        &max, dtrace_minor) == -1) {
        mdb_warn("couldn't walk 'vmem_alloc'");
        return (WALK_ERR);
    }

    dw = mdb_zalloc(sizeof (dtrace_state_walk_t), UM_SLEEP | UM_GC);
    dw->dtsw_current = 0;
    dw->dtsw_max = max;

    if (mdb_readvar(&dw->dtsw_softstate, "dtrace_softstate") == -1) {
        mdb_warn("failed to read 'dtrace_softstate'");
        return (DCMD_ERR);
    }

    wsp->walk_data = dw;

    return (WALK_NEXT);
}

int
dtrace_state_step(mdb_walk_state_t *wsp)
{
    dtrace_state_walk_t *dw = wsp->walk_data;
    uintptr_t statep;
    dtrace_state_t state;
    int rval;

    while (mdb_get_soft_state_byaddr(dw->dtsw_softstate, dw->dtsw_current,
        &statep, NULL, 0) == -1) {
        if (dw->dtsw_current >= dw->dtsw_max)
            return (WALK_DONE);

        dw->dtsw_current++;
    }

    if (mdb_vread(&state, sizeof (state), statep) == -1) {
        mdb_warn("couldn't read dtrace_state_t at %p", statep);
        return (WALK_NEXT);
    }

    rval = wsp->walk_callback(statep, &state, wsp->walk_cbdata);
    dw->dtsw_current++;

    return (rval);
}

typedef struct dtrace_state_data {
    int dtsd_major;
    uintptr_t dtsd_proc;
    uintptr_t dtsd_softstate;
    uintptr_t dtsd_state;
} dtrace_state_data_t;

static int
dtrace_state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data)
{
    vnode_t vnode;
    proc_t proc;
    minor_t minor;
    uintptr_t statep;

    if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) {
        mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode);
        return (WALK_NEXT);
    }

    if (getmajor(vnode.v_rdev) != data->dtsd_major)
        return (WALK_NEXT);

    minor = getminor(vnode.v_rdev);

    if (mdb_vread(&proc, sizeof (proc), data->dtsd_proc) == -1) {
        mdb_warn("failed to read proc at %p", data->dtsd_proc);
        return (WALK_NEXT);
    }

    if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor,
        &statep, NULL, 0) == -1) {
        mdb_warn("failed to read softstate for minor %d", minor);
        return (WALK_NEXT);
    }

    if (statep != data->dtsd_state)
        return (WALK_NEXT);

    mdb_printf("%?p %5d %?p %-*s %?p\n", statep, minor,
        data->dtsd_proc, MAXCOMLEN, proc.p_user.u_comm, addr);

    return (WALK_NEXT);
}

/*ARGSUSED*/
static int
dtrace_state_proc(uintptr_t addr, void *ignored, dtrace_state_data_t *data)
{
    data->dtsd_proc = addr;

    if (mdb_pwalk("file",
        (mdb_walk_cb_t)dtrace_state_file, data, addr) == -1) {
        mdb_warn("couldn't walk 'file' for proc %p", addr);
        return (WALK_ERR);
    }

    return (WALK_NEXT);
}

void
dtrace_state_help(void)
{
    mdb_printf("Given a dtrace_state_t structure, displays all "
        /*CSTYLED*/
        "consumers, or \"<anonymous>\"\nif the consumer is anonymous.  If "
        "no state structure is provided, iterates\nover all state "
        "structures.\n\n"
        "Addresses in ADDR column may be provided to ::dtrace to obtain\n"
        "dtrace(1M)-like output for in-kernel DTrace data.\n");
}

int
dtrace_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    uintptr_t devi;
    struct dev_info info;
    dtrace_state_data_t data;
    dtrace_anon_t anon;
    dtrace_state_t state;

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("dtrace_state",
            "dtrace_state", argc, argv) == -1) {
            mdb_warn("can't walk dtrace_state");
            return (DCMD_ERR);
        }
        return (DCMD_OK);
    }

    if (DCMD_HDRSPEC(flags)) {
        mdb_printf("%?s %5s %?s %-*s %?s\n", "ADDR", "MINOR", "PROC",
            MAXCOMLEN, "NAME", "FILE");
    }

    /*
     * First determine if this is anonymous state.
     */
    if (mdb_readvar(&anon, "dtrace_anon") == -1) {
        mdb_warn("failed to read 'dtrace_anon'");
        return (DCMD_ERR);
    }

    if ((uintptr_t)anon.dta_state == addr) {
        if (mdb_vread(&state, sizeof (state), addr) == -1) {
            mdb_warn("failed to read anon at %p", addr);
            return (DCMD_ERR);
        }

        mdb_printf("%?p %5d %?s %-*s %?s\n", addr,
            getminor(state.dts_dev), "-", MAXCOMLEN,
            "<anonymous>", "-");

        return (DCMD_OK);
    }

    if (mdb_readvar(&devi, "dtrace_devi") == -1) {
        mdb_warn("failed to read 'dtrace_devi'");
        return (DCMD_ERR);
    }

    if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) {
        mdb_warn("failed to read 'dev_info'");
        return (DCMD_ERR);
    }

    data.dtsd_major = info.devi_major;

    if (mdb_readvar(&data.dtsd_softstate, "dtrace_softstate") == -1) {
        mdb_warn("failed to read 'dtrace_softstate'");
        return (DCMD_ERR);
    }

    data.dtsd_state = addr;

    /*
     * Walk through all processes and all open files looking for this
     * state.  It must be open somewhere...
     */
    if (mdb_walk("proc", (mdb_walk_cb_t)dtrace_state_proc, &data) == -1) {
        mdb_warn("couldn't walk 'proc'");
        return (DCMD_ERR);
    }

    return (DCMD_OK);
}

typedef struct dtrace_aggkey_data {
    uintptr_t *dtakd_hash;
    uintptr_t dtakd_hashsize;
    uintptr_t dtakd_next;
    uintptr_t dtakd_ndx;
} dtrace_aggkey_data_t;

int
dtrace_aggkey_init(mdb_walk_state_t *wsp)
{
    dtrace_buffer_t buf;
    uintptr_t addr;
    dtrace_aggbuffer_t agb;
    dtrace_aggkey_data_t *data;
    size_t hsize;

    if ((addr = wsp->walk_addr) == NULL) {
        mdb_warn("dtrace_aggkey walk needs aggregation buffer\n");
        return (WALK_ERR);
    }

    if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
        mdb_warn("failed to read aggregation buffer at %p", addr);
        return (WALK_ERR);
    }

    addr = (uintptr_t)buf.dtb_tomax +
        buf.dtb_size - sizeof (dtrace_aggbuffer_t);

    if (mdb_vread(&agb, sizeof (agb), addr) == -1) {
        mdb_warn("failed to read dtrace_aggbuffer_t at %p", addr);
        return (WALK_ERR);
    }

    data = mdb_zalloc(sizeof (dtrace_aggkey_data_t), UM_SLEEP);

    data->dtakd_hashsize = agb.dtagb_hashsize;
    hsize = agb.dtagb_hashsize * sizeof (dtrace_aggkey_t *);
    data->dtakd_hash = mdb_alloc(hsize, UM_SLEEP);

    if (mdb_vread(data->dtakd_hash, hsize,
        (uintptr_t)agb.dtagb_hash) == -1) {
        mdb_warn("failed to read hash at %p",
            (uintptr_t)agb.dtagb_hash);
        mdb_free(data->dtakd_hash, hsize);
        mdb_free(data, sizeof (dtrace_aggkey_data_t));
        return (WALK_ERR);
    }

    wsp->walk_data = data;
    return (WALK_NEXT);
}

int
dtrace_aggkey_step(mdb_walk_state_t *wsp)
{
    dtrace_aggkey_data_t *data = wsp->walk_data;
    dtrace_aggkey_t key;
    uintptr_t addr;

    while ((addr = data->dtakd_next) == NULL) {
        if (data->dtakd_ndx == data->dtakd_hashsize)
            return (WALK_DONE);

        data->dtakd_next = data->dtakd_hash[data->dtakd_ndx++];
    }

    if (mdb_vread(&key, sizeof (key), addr) == -1) {
        mdb_warn("failed to read dtrace_aggkey_t at %p", addr);
        return (WALK_ERR);
    }

    data->dtakd_next = (uintptr_t)key.dtak_next;

    return (wsp->walk_callback(addr, &key, wsp->walk_cbdata));
}

void
dtrace_aggkey_fini(mdb_walk_state_t *wsp)
{
    dtrace_aggkey_data_t *data = wsp->walk_data;
    size_t hsize;

    hsize = data->dtakd_hashsize * sizeof (dtrace_aggkey_t *);
    mdb_free(data->dtakd_hash, hsize);
    mdb_free(data, sizeof (dtrace_aggkey_data_t));
}

typedef struct dtrace_dynvar_data {
    dtrace_dynhash_t *dtdvd_hash;
    uintptr_t dtdvd_hashsize;
    uintptr_t dtdvd_next;
    uintptr_t dtdvd_ndx;
} dtrace_dynvar_data_t;

int
dtrace_dynvar_init(mdb_walk_state_t *wsp)
{
    uintptr_t addr;
    dtrace_dstate_t dstate;
    dtrace_dynvar_data_t *data;
    size_t hsize;

    if ((addr = wsp->walk_addr) == NULL) {
        mdb_warn("dtrace_dynvar walk needs dtrace_dstate_t\n");
        return (WALK_ERR);
    }

    if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) {
        mdb_warn("failed to read dynamic state at %p", addr);
        return (WALK_ERR);
    }

    data = mdb_zalloc(sizeof (dtrace_dynvar_data_t), UM_SLEEP);

    data->dtdvd_hashsize = dstate.dtds_hashsize;
    hsize = dstate.dtds_hashsize * sizeof (dtrace_dynhash_t);
    data->dtdvd_hash = mdb_alloc(hsize, UM_SLEEP);

    if (mdb_vread(data->dtdvd_hash, hsize,
        (uintptr_t)dstate.dtds_hash) == -1) {
        mdb_warn("failed to read hash at %p",
            (uintptr_t)dstate.dtds_hash);
        mdb_free(data->dtdvd_hash, hsize);
        mdb_free(data, sizeof (dtrace_dynvar_data_t));
        return (WALK_ERR);
    }

    wsp->walk_data = data;
    return (WALK_NEXT);
}

int
dtrace_dynvar_step(mdb_walk_state_t *wsp)
{
    dtrace_dynvar_data_t *data = wsp->walk_data;
    dtrace_dynvar_t dynvar, *dvar;
    size_t dvarsize;
    uintptr_t addr;
    int nkeys;

    while ((addr = data->dtdvd_next) == NULL) {
        if (data->dtdvd_ndx == data->dtdvd_hashsize)
            return (WALK_DONE);

        data->dtdvd_next =
            (uintptr_t)data->dtdvd_hash[data->dtdvd_ndx++].dtdh_chain;
    }

    if (mdb_vread(&dynvar, sizeof (dynvar), addr) == -1) {
        mdb_warn("failed to read dtrace_dynvar_t at %p", addr);
        return (WALK_ERR);
    }

    /*
     * Now we need to allocate the correct size.
     */
    nkeys = dynvar.dtdv_tuple.dtt_nkeys;
    dvarsize = (uintptr_t)&dynvar.dtdv_tuple.dtt_key[nkeys] -
        (uintptr_t)&dynvar;

    dvar = alloca(dvarsize);

    if (mdb_vread(dvar, dvarsize, addr) == -1) {
        mdb_warn("failed to read dtrace_dynvar_t at %p", addr);
        return (WALK_ERR);
    }

    data->dtdvd_next = (uintptr_t)dynvar.dtdv_next;

    return (wsp->walk_callback(addr, dvar, wsp->walk_cbdata));
}

void
dtrace_dynvar_fini(mdb_walk_state_t *wsp)
{
    dtrace_dynvar_data_t *data = wsp->walk_data;
    size_t hsize;

    hsize = data->dtdvd_hashsize * sizeof (dtrace_dynvar_t *);
    mdb_free(data->dtdvd_hash, hsize);
    mdb_free(data, sizeof (dtrace_dynvar_data_t));
}

typedef struct dtrace_hashstat_data {
    size_t *dthsd_counts;
    size_t dthsd_hashsize;
    char *dthsd_data;
    size_t dthsd_size;
    int dthsd_header;
} dtrace_hashstat_data_t;

typedef void (*dtrace_hashstat_func_t)(dtrace_hashstat_data_t *);

static void
dtrace_hashstat_additive(dtrace_hashstat_data_t *data)
{
    int i;
    int hval = 0;

    for (i = 0; i < data->dthsd_size; i++)
        hval += data->dthsd_data[i];

    data->dthsd_counts[hval % data->dthsd_hashsize]++;
}

static void
dtrace_hashstat_shifty(dtrace_hashstat_data_t *data)
{
    uint64_t hval = 0;
    int i;

    if (data->dthsd_size < sizeof (uint64_t)) {
        dtrace_hashstat_additive(data);
        return;
    }

    for (i = 0; i < data->dthsd_size; i += sizeof (uint64_t)) {
        /* LINTED - alignment */
        uint64_t val = *((uint64_t *)&data->dthsd_data[i]);

        hval += (val & ((1 << NBBY) - 1)) +
            ((val >> NBBY) & ((1 << NBBY) - 1)) +
            ((val >> (NBBY << 1)) & ((1 << NBBY) - 1)) +
            ((val >> (NBBY << 2)) & ((1 << NBBY) - 1)) +
            (val & USHRT_MAX) + (val >> (NBBY << 1) & USHRT_MAX);
    }

    data->dthsd_counts[hval % data->dthsd_hashsize]++;
}

static void
dtrace_hashstat_knuth(dtrace_hashstat_data_t *data)
{
    int i;
    int hval = data->dthsd_size;

    for (i = 0; i < data->dthsd_size; i++)
        hval = (hval << 4) ^ (hval >> 28) ^ data->dthsd_data[i];

    data->dthsd_counts[hval % data->dthsd_hashsize]++;
}

static void
dtrace_hashstat_oneatatime(dtrace_hashstat_data_t *data)
{
    int i;
    uint32_t hval = 0;

    for (i = 0; i < data->dthsd_size; i++) {
        hval += data->dthsd_data[i];
        hval += (hval << 10);
        hval ^= (hval >> 6);
    }

    hval += (hval << 3);
    hval ^= (hval >> 11);
    hval += (hval << 15);

    data->dthsd_counts[hval % data->dthsd_hashsize]++;
}

static void
dtrace_hashstat_fnv(dtrace_hashstat_data_t *data)
{
    static const uint32_t prime = 0x01000193;
    uint32_t hval = 0;
    int i;

    for (i = 0; i < data->dthsd_size; i++) {
        hval *= prime;
        hval ^= data->dthsd_data[i];
    }

    data->dthsd_counts[hval % data->dthsd_hashsize]++;
}

static void
dtrace_hashstat_stats(char *name, dtrace_hashstat_data_t *data)
{
    size_t nz = 0, i;
    int longest = 0;
    size_t ttl = 0;
    double sum = 0.0;
    double avg;
    uint_t util, stddev;

    if (!data->dthsd_header) {
        mdb_printf("%15s %11s %11s %11s %11s %11s\n", "NAME",
            "HASHSIZE", "%UTIL", "LONGEST", "AVERAGE", "STDDEV");
        data->dthsd_header = 1;
    }

    for (i = 0; i < data->dthsd_hashsize; i++) {
        if (data->dthsd_counts[i] != 0) {
            nz++;

            if (data->dthsd_counts[i] > longest)
                longest = data->dthsd_counts[i];

            ttl += data->dthsd_counts[i];
        }
    }

    if (nz == 0) {
        mdb_printf("%15s %11d %11s %11s %11s %11s\n", name,
            data->dthsd_hashsize, "-", "-", "-", "-");
        return;
    }

    avg = (double)ttl / (double)nz;

    for (i = 0; i < data->dthsd_hashsize; i++) {
        double delta = (double)data->dthsd_counts[i] - avg;

        if (data->dthsd_counts[i] == 0)
            continue;

        sum += delta * delta;
    }

    util = (nz * 1000) / data->dthsd_hashsize;
    stddev = (uint_t)sqrt(sum / (double)nz) * 10;

    mdb_printf("%15s %11d %9u.%1u %11d %11d %9u.%1u\n", name,
        data->dthsd_hashsize, util / 10, util % 10, longest, ttl / nz,
        stddev / 10, stddev % 10);
}

static struct dtrace_hashstat {
    char *dths_name;
    dtrace_hashstat_func_t dths_func;
} _dtrace_hashstat[] = {
    { "<actual>", NULL },
    { "additive", dtrace_hashstat_additive },
    { "shifty", dtrace_hashstat_shifty },
    { "knuth", dtrace_hashstat_knuth },
    { "one-at-a-time", dtrace_hashstat_oneatatime },
    { "fnv", dtrace_hashstat_fnv },
    { NULL, 0 }
};

typedef struct dtrace_aggstat_data {
    dtrace_hashstat_data_t dtagsd_hash;
    dtrace_hashstat_func_t dtagsd_func;
} dtrace_aggstat_data_t;

static int
dtrace_aggstat_walk(uintptr_t addr, dtrace_aggkey_t *key,
    dtrace_aggstat_data_t *data)
{
    dtrace_hashstat_data_t *hdata = &data->dtagsd_hash;
    size_t size;

    if (data->dtagsd_func == NULL) {
        size_t bucket = key->dtak_hashval % hdata->dthsd_hashsize;

        hdata->dthsd_counts[bucket]++;
        return (WALK_NEXT);
    }

    /*
     * We need to read the data.
     */
    size = key->dtak_size - sizeof (dtrace_aggid_t);
    addr = (uintptr_t)key->dtak_data + sizeof (dtrace_aggid_t);
    hdata->dthsd_data = alloca(size);
    hdata->dthsd_size = size;

    if (mdb_vread(hdata->dthsd_data, size, addr) == -1) {
        mdb_warn("couldn't read data at %p", addr);
        return (WALK_ERR);
    }

    data->dtagsd_func(hdata);

    return (WALK_NEXT);
}

/*ARGSUSED*/
int
dtrace_aggstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    dtrace_buffer_t buf;
    uintptr_t aaddr;
    dtrace_aggbuffer_t agb;
    size_t hsize, i, actual, prime, evenpow;
    dtrace_aggstat_data_t data;
    dtrace_hashstat_data_t *hdata = &data.dtagsd_hash;

    bzero(&data, sizeof (data));

    if (!(flags & DCMD_ADDRSPEC))
        return (DCMD_USAGE);

    if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
        mdb_warn("failed to read aggregation buffer at %p", addr);
        return (DCMD_ERR);
    }

    aaddr = (uintptr_t)buf.dtb_tomax +
        buf.dtb_size - sizeof (dtrace_aggbuffer_t);

    if (mdb_vread(&agb, sizeof (agb), aaddr) == -1) {
        mdb_warn("failed to read dtrace_aggbuffer_t at %p", aaddr);
        return (DCMD_ERR);
    }

    hsize = (actual = agb.dtagb_hashsize) * sizeof (size_t);
    hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC);

    /*
     * Now pick the largest prime smaller than the hash size.  (If the
     * existing size is prime, we'll pick a smaller prime just for the
     * hell of it.)
     */
    for (prime = agb.dtagb_hashsize - 1; prime > 7; prime--) {
        size_t limit = prime / 7;

        for (i = 2; i < limit; i++) {
            if ((prime % i) == 0)
                break;
        }

        if (i == limit)
            break;
    }

    /*
     * And now we want to pick the largest power of two smaller than the
     * hashsize.
     */
    for (i = 0; (1 << i) < agb.dtagb_hashsize; i++)
        continue;

    evenpow = (1 << (i - 1));

    for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) {
        data.dtagsd_func = _dtrace_hashstat[i].dths_func;

        hdata->dthsd_hashsize = actual;
        hsize = hdata->dthsd_hashsize * sizeof (size_t);
        bzero(hdata->dthsd_counts, hsize);

        if (mdb_pwalk("dtrace_aggkey",
            (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
            mdb_warn("failed to walk dtrace_aggkey at %p", addr);
            return (DCMD_ERR);
        }

        dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);

        /*
         * If we were just printing the actual value, we won't try
         * any of the sizing experiments.
         */
        if (data.dtagsd_func == NULL)
            continue;

        hdata->dthsd_hashsize = prime;
        hsize = hdata->dthsd_hashsize * sizeof (size_t);
        bzero(hdata->dthsd_counts, hsize);

        if (mdb_pwalk("dtrace_aggkey",
            (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
            mdb_warn("failed to walk dtrace_aggkey at %p", addr);
            return (DCMD_ERR);
        }

        dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);

        hdata->dthsd_hashsize = evenpow;
        hsize = hdata->dthsd_hashsize * sizeof (size_t);
        bzero(hdata->dthsd_counts, hsize);

        if (mdb_pwalk("dtrace_aggkey",
            (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
            mdb_warn("failed to walk dtrace_aggkey at %p", addr);
            return (DCMD_ERR);
        }

        dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
dtrace_dynstat_walk(uintptr_t addr, dtrace_dynvar_t *dynvar,
    dtrace_aggstat_data_t *data)
{
    dtrace_hashstat_data_t *hdata = &data->dtagsd_hash;
    dtrace_tuple_t *tuple = &dynvar->dtdv_tuple;
    dtrace_key_t *key = tuple->dtt_key;
    size_t size = 0, offs = 0;
    int i, nkeys = tuple->dtt_nkeys;
    char *buf;

    if (data->dtagsd_func == NULL) {
        size_t bucket = dynvar->dtdv_hashval % hdata->dthsd_hashsize;

        hdata->dthsd_counts[bucket]++;
        return (WALK_NEXT);
    }

    /*
     * We want to hand the hashing algorithm a contiguous buffer.  First
     * run through the tuple and determine the size.
     */
    for (i = 0; i < nkeys; i++) {
        if (key[i].dttk_size == 0) {
            size += sizeof (uint64_t);
        } else {
            size += key[i].dttk_size;
        }
    }

    buf = alloca(size);

    /*
     * Now go back through the tuple and copy the data into the buffer.
     */
    for (i = 0; i < nkeys; i++) {
        if (key[i].dttk_size == 0) {
            bcopy(&key[i].dttk_value, &buf[offs],
                sizeof (uint64_t));
            offs += sizeof (uint64_t);
        } else {
            if (mdb_vread(&buf[offs], key[i].dttk_size,
                key[i].dttk_value) == -1) {
                mdb_warn("couldn't read tuple data at %p",
                    key[i].dttk_value);
                return (WALK_ERR);
            }

            offs += key[i].dttk_size;
        }
    }

    hdata->dthsd_data = buf;
    hdata->dthsd_size = size;

    data->dtagsd_func(hdata);

    return (WALK_NEXT);
}

/*ARGSUSED*/
int
dtrace_dynstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    dtrace_dstate_t dstate;
    size_t hsize, i, actual, prime;
    dtrace_aggstat_data_t data;
    dtrace_hashstat_data_t *hdata = &data.dtagsd_hash;

    bzero(&data, sizeof (data));

    if (!(flags & DCMD_ADDRSPEC))
        return (DCMD_USAGE);

    if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) {
        mdb_warn("failed to read dynamic variable state at %p", addr);
        return (DCMD_ERR);
    }

    hsize = (actual = dstate.dtds_hashsize) * sizeof (size_t);
    hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC);

    /*
     * Now pick the largest prime smaller than the hash size.  (If the
     * existing size is prime, we'll pick a smaller prime just for the
     * hell of it.)
     */
    for (prime = dstate.dtds_hashsize - 1; prime > 7; prime--) {
        size_t limit = prime / 7;

        for (i = 2; i < limit; i++) {
            if ((prime % i) == 0)
                break;
        }

        if (i == limit)
            break;
    }

    for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) {
        data.dtagsd_func = _dtrace_hashstat[i].dths_func;

        hdata->dthsd_hashsize = actual;
        hsize = hdata->dthsd_hashsize * sizeof (size_t);
        bzero(hdata->dthsd_counts, hsize);

        if (mdb_pwalk("dtrace_dynvar",
            (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) {
            mdb_warn("failed to walk dtrace_dynvar at %p", addr);
            return (DCMD_ERR);
        }

        dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);

        /*
         * If we were just printing the actual value, we won't try
         * any of the sizing experiments.
         */
        if (data.dtagsd_func == NULL)
            continue;

        hdata->dthsd_hashsize = prime;
        hsize = hdata->dthsd_hashsize * sizeof (size_t);
        bzero(hdata->dthsd_counts, hsize);

        if (mdb_pwalk("dtrace_dynvar",
            (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) {
            mdb_warn("failed to walk dtrace_aggkey at %p", addr);
            return (DCMD_ERR);
        }

        dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
    }

    return (DCMD_OK);
}

typedef struct dtrace_ecb_walk {
    dtrace_ecb_t **dtew_ecbs;
    int dtew_necbs;
    int dtew_curecb;
} dtrace_ecb_walk_t;

static int
dtrace_ecb_init(mdb_walk_state_t *wsp)
{
    uintptr_t addr;
    dtrace_state_t state;
    dtrace_ecb_walk_t *ecbwp;

    if ((addr = wsp->walk_addr) == NULL) {
        mdb_warn("dtrace_ecb walk needs dtrace_state_t\n");
        return (WALK_ERR);
    }

    if (mdb_vread(&state, sizeof (state), addr) == -1) {
        mdb_warn("failed to read dtrace state pointer at %p", addr);
        return (WALK_ERR);
    }

    ecbwp = mdb_zalloc(sizeof (dtrace_ecb_walk_t), UM_SLEEP | UM_GC);

    ecbwp->dtew_ecbs = state.dts_ecbs;
    ecbwp->dtew_necbs = state.dts_necbs;
    ecbwp->dtew_curecb = 0;

    wsp->walk_data = ecbwp;

    return (WALK_NEXT);
}

static int
dtrace_ecb_step(mdb_walk_state_t *wsp)
{
    uintptr_t ecbp, addr;
    dtrace_ecb_walk_t *ecbwp = wsp->walk_data;

    addr = (uintptr_t)ecbwp->dtew_ecbs +
        ecbwp->dtew_curecb * sizeof (dtrace_ecb_t *);

    if (ecbwp->dtew_curecb++ == ecbwp->dtew_necbs)
        return (WALK_DONE);

    if (mdb_vread(&ecbp, sizeof (addr), addr) == -1) {
        mdb_warn("failed to read ecb at entry %d\n",
            ecbwp->dtew_curecb);
        return (WALK_ERR);
    }

    if (ecbp == NULL)
        return (WALK_NEXT);

    return (wsp->walk_callback(ecbp, NULL, wsp->walk_cbdata));
}

const mdb_dcmd_t kernel_dcmds[] = {
    { "id2probe", ":", "translate a dtrace_id_t to a dtrace_probe_t",
        id2probe },
    { "dtrace", ":[-c cpu]", "print dtrace(1M)-like output",
        dtrace, dtrace_help },
    { "dtrace_errhash", ":", "print DTrace error hash", dtrace_errhash },
    { "dtrace_helptrace", ":", "print DTrace helper trace",
        dtrace_helptrace },
    { "dtrace_state", ":", "print active DTrace consumers", dtrace_state,
        dtrace_state_help },
    { "dtrace_aggstat", ":",
        "print DTrace aggregation hash statistics", dtrace_aggstat },
    { "dtrace_dynstat", ":",
        "print DTrace dynamic variable hash statistics", dtrace_dynstat },
    { NULL }
};

const mdb_walker_t kernel_walkers[] = {
    { "dtrace_errhash", "walk hash of DTrace error messasges",
        dtrace_errhash_init, dtrace_errhash_step },
    { "dtrace_helptrace", "walk DTrace helper trace entries",
        dtrace_helptrace_init, dtrace_helptrace_step },
    { "dtrace_state", "walk DTrace per-consumer softstate",
        dtrace_state_init, dtrace_state_step },
    { "dtrace_aggkey", "walk DTrace aggregation keys",
        dtrace_aggkey_init, dtrace_aggkey_step, dtrace_aggkey_fini },
    { "dtrace_dynvar", "walk DTrace dynamic variables",
        dtrace_dynvar_init, dtrace_dynvar_step, dtrace_dynvar_fini },
    { "dtrace_ecb", "walk a DTrace consumer's enabling control blocks",
        dtrace_ecb_init, dtrace_ecb_step },
    { NULL }
};