/*
 * 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.
 *
 * Copyright 2019 Joyent, Inc.
 */

#include <sys/mdb_modapi.h>

#include <lut.h>
#include <itree.h>
#include "ipath_impl.h"
#include "lut_impl.h"
#include "config_impl.h"
#include "stats_impl.h"

#define LUT_SIZE_INIT   300
#define LUT_SIZE_INCR   100

struct lut_cp {
        uintptr_t lutcp_addr;
        struct lut lutcp_lut;
};

#define LCPSZ   sizeof (struct lut_cp)

struct lut_dump_desc {
        struct lut_cp *ld_array;
        int ld_arraysz;
        int ld_nents;
};

static void
lut_dump_array_alloc(struct lut_dump_desc *lddp)
{
        struct lut_cp *new;

        if (lddp->ld_array == NULL) {
                lddp->ld_arraysz = LUT_SIZE_INIT;
                lddp->ld_array = mdb_zalloc(LUT_SIZE_INIT * LCPSZ, UM_SLEEP);
                return;
        }

        new = mdb_zalloc((lddp->ld_arraysz + LUT_SIZE_INCR) * LCPSZ, UM_SLEEP);
        bcopy(lddp->ld_array, new, lddp->ld_arraysz * LCPSZ);
        mdb_free(lddp->ld_array, lddp->ld_arraysz * LCPSZ);
        lddp->ld_array = new;
        lddp->ld_arraysz += LUT_SIZE_INCR;
}

static void
lut_dump_array_free(struct lut_dump_desc *lddp)
{
        if (lddp->ld_array != NULL) {
                mdb_free(lddp->ld_array, lddp->ld_arraysz * LCPSZ);
                lddp->ld_array = NULL;
        }
}

static void
lut_collect_addent(uintptr_t addr, struct lut *ent, struct lut_dump_desc *lddp)
{
        struct lut_cp *lcp;

        if (lddp->ld_nents == lddp->ld_arraysz)
                lut_dump_array_alloc(lddp);

        lcp = &lddp->ld_array[lddp->ld_nents++];

        lcp->lutcp_addr = addr;
        bcopy(ent, &lcp->lutcp_lut, sizeof (struct lut));
}

static int
eft_lut_walk(uintptr_t root, struct lut_dump_desc *lddp)
{
        struct lut lutent;

        if (root) {
                if (mdb_vread(&lutent, sizeof (struct lut), root) !=
                    sizeof (struct lut)) {
                        mdb_warn("failed to read struct lut at %p", root);
                        return (WALK_ERR);
                }

                if (eft_lut_walk((uintptr_t)lutent.lut_left, lddp) != WALK_NEXT)
                        return (WALK_ERR);

                lut_collect_addent(root, &lutent, lddp);

                if (eft_lut_walk((uintptr_t)lutent.lut_right, lddp) !=
                    WALK_NEXT)
                        return (WALK_ERR);
        }
        return (WALK_NEXT);
}

static int
lut_collect(uintptr_t addr, struct lut_dump_desc *lddp)
{
        lut_dump_array_alloc(lddp);

        if (eft_lut_walk(addr, lddp) != WALK_NEXT) {
                lut_dump_array_free(lddp);
                return (WALK_ERR);
        } else {
                return (WALK_NEXT);     /* caller must free dump array */
        }
}

static int
lut_walk_init(mdb_walk_state_t *wsp)
{
        if (wsp->walk_addr == 0) {
                mdb_warn("lut walker requires a lut table address\n");
                return (WALK_ERR);
        }

        wsp->walk_data = mdb_zalloc(sizeof (struct lut_dump_desc), UM_SLEEP);
        wsp->walk_arg = 0;

        if (lut_collect(wsp->walk_addr, wsp->walk_data) == WALK_NEXT) {
                return (WALK_NEXT);
        } else {
                mdb_warn("failed to suck in full lut\n");
                mdb_free(wsp->walk_data, sizeof (struct lut_dump_desc));
                return (WALK_ERR);
        }
}

static int
lut_walk_step(mdb_walk_state_t *wsp)
{
        struct lut_dump_desc *lddp = wsp->walk_data;
        int *ip = (int *)&wsp->walk_arg;
        struct lut_cp *lcp = &lddp->ld_array[*ip];

        if (*ip == lddp->ld_nents)
                return (WALK_DONE);

        ++*ip;

        return (wsp->walk_callback(lcp->lutcp_addr, &lcp->lutcp_lut,
            wsp->walk_cbdata));
}

static int
ipath_walk_init(mdb_walk_state_t *wsp)
{
        struct ipath *ipath;

        ipath = mdb_alloc(sizeof (struct ipath), UM_SLEEP);

        if (mdb_vread((void *)ipath, sizeof (struct ipath),
            wsp->walk_addr) != sizeof (struct ipath)) {
                mdb_warn("failed to read struct ipath at %p", wsp->walk_addr);
                return (WALK_ERR);
        }
        wsp->walk_data = (void *)ipath;

        if (ipath->s == NULL)
                return (WALK_DONE);
        else
                return (WALK_NEXT);
}

static void
ipath_walk_fini(mdb_walk_state_t *wsp)
{
        mdb_free(wsp->walk_data, sizeof (struct ipath));
}

static int
ipath_walk_step(mdb_walk_state_t *wsp)
{
        int status;
        struct ipath *ipath = (struct ipath *)wsp->walk_data;
        struct ipath *ip = (struct ipath *)wsp->walk_addr;

        if (ip == NULL || ipath->s == NULL)
                return (WALK_DONE);

        status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
            wsp->walk_cbdata);

        wsp->walk_addr = (uintptr_t)(ip + 1);

        if (mdb_vread(wsp->walk_data, sizeof (struct ipath),
            wsp->walk_addr) != sizeof (struct ipath)) {
                mdb_warn("failed to read struct ipath at %p", wsp->walk_addr);
                return (WALK_ERR);
        }

        return (status);
}

static void
lut_walk_fini(mdb_walk_state_t *wsp)
{
        struct lut_dump_desc *lddp = wsp->walk_data;

        lut_dump_array_free(lddp);
        mdb_free(lddp, sizeof (struct lut_dump_desc));
}

/*ARGSUSED*/
static int
ipath_node(uintptr_t addr, const void *data, void *arg)
{
        struct ipath *ipath = (struct ipath *)data;
        char buf[128];

        if (mdb_readstr(buf, (size_t)sizeof (buf), (uintptr_t)ipath->s) < 0)
                (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                    ipath->s);

        mdb_printf("/%s=%d", buf, ipath->i);
        return (DCMD_OK);
}

/*ARGSUSED*/
static int
ipath(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        if (argc)
                return (DCMD_USAGE);
        if (!(flags & DCMD_ADDRSPEC))
                addr = mdb_get_dot();
        if (mdb_pwalk("eft_ipath", ipath_node, NULL, addr) != 0)
                return (DCMD_ERR);
        return (DCMD_OK);
}

/*ARGSUSED*/
static int
eft_count(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        struct lut lut;
        struct istat_entry istat_entry;
        struct stats count;
        GElf_Sym sym;
        char buf[128];

        if (argc)
                return (DCMD_USAGE);
        if (!(flags & DCMD_ADDRSPEC)) {
                if (mdb_lookup_by_obj(MDB_OBJ_EVERY, "Istats", &sym) == -1 ||
                    sym.st_size != sizeof (addr))
                        return (DCMD_ERR);
                if (mdb_vread(&addr, sizeof (addr),
                    (uintptr_t)sym.st_value) != sizeof (addr))
                        return (DCMD_ERR);
                if (addr == 0)
                        return (DCMD_OK);
                if (mdb_pwalk_dcmd("lut", "eft_count", argc, argv, addr) != 0)
                        return (DCMD_ERR);
                return (DCMD_OK);
        }

        if (mdb_vread(&lut, sizeof (struct lut), addr) != sizeof (struct lut)) {
                mdb_warn("failed to read struct lut at %p", addr);
                return (DCMD_ERR);
        }
        if (mdb_vread(&istat_entry, sizeof (struct istat_entry),
            (uintptr_t)lut.lut_lhs) != sizeof (struct istat_entry)) {
                mdb_warn("failed to read struct istat_entry at %p", addr);
                return (DCMD_ERR);
        }
        if (mdb_vread(&count, sizeof (struct stats),
            (uintptr_t)lut.lut_rhs) != sizeof (struct stats)) {
                mdb_warn("failed to read struct stats at %p", addr);
                return (DCMD_ERR);
        }

        if (mdb_readstr(buf, (size_t)sizeof (buf),
            (uintptr_t)istat_entry.ename) < 0)
                (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                    istat_entry.ename);

        mdb_printf("%s@", buf);
        (void) ipath((uintptr_t)istat_entry.ipath, DCMD_ADDRSPEC, 0, NULL);
        mdb_printf(" %d\n", count.fmd_stats.fmds_value.i32);
        return (DCMD_OK);
}

/*ARGSUSED*/
static int
eft_time(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        unsigned long long val;
        unsigned long long ull;
        int opt_p = 0;

        if (!(flags & DCMD_ADDRSPEC))
                addr = mdb_get_dot();
        ull = addr;
        if (argc) {
                if (mdb_getopts(argc, argv,
                    'l', MDB_OPT_UINT64, &ull,
                    'p', MDB_OPT_SETBITS, TRUE, &opt_p, MDB_OPT_UINT64,
                    NULL) != argc) {
                        return (DCMD_USAGE);
                }
        }
        if (opt_p) {
                if (mdb_vread(&ull, sizeof (ull), addr) != sizeof (ull)) {
                        mdb_warn("failed to read timeval at %p", addr);
                        return (DCMD_ERR);
                }
        }
#define NOREMAINDER(den, num, val) (((val) = ((den) / (num))) * (num) == (den))
        if (ull == 0)
                mdb_printf("0us");
        else if (ull >= TIMEVAL_EVENTUALLY)
                mdb_printf("infinity");
        else if (NOREMAINDER(ull, 1000000000ULL*60*60*24*365, val))
                mdb_printf("%lluyear%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL*60*60*24*30, val))
                mdb_printf("%llumonth%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL*60*60*24*7, val))
                mdb_printf("%lluweek%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL*60*60*24, val))
                mdb_printf("%lluday%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL*60*60, val))
                mdb_printf("%lluhour%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL*60, val))
                mdb_printf("%lluminute%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000000ULL, val))
                mdb_printf("%llusecond%s", val, (val == 1) ? "" : "s");
        else if (NOREMAINDER(ull, 1000000ULL, val))
                mdb_printf("%llums", val);
        else if (NOREMAINDER(ull, 1000ULL, val))
                mdb_printf("%lluus", val);
        else
                mdb_printf("%lluns", ull);

        return (DCMD_OK);
}

/*ARGSUSED*/
static int
eft_node(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        struct node node;
        int opt_v = 0;
        char buf[128];

        if (!(flags & DCMD_ADDRSPEC))
                addr = mdb_get_dot();
        if (argc) {
                if (mdb_getopts(argc, argv,
                    'v', MDB_OPT_SETBITS, TRUE, &opt_v,
                    NULL) != argc) {
                        return (DCMD_USAGE);
                }
        }
        if (addr == 0)
                return (DCMD_OK);
        if (mdb_vread(&node, sizeof (node), addr) != sizeof (node)) {
                mdb_warn("failed to read struct node at %p", addr);
                return (DCMD_ERR);
        }
        if (opt_v) {
                if (mdb_readstr(buf, (size_t)sizeof (buf),
                    (uintptr_t)node.file) < 0)
                        (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                            node.file);

                mdb_printf("%s len %d\n", buf, node.line);
        }
        switch (node.t) {
        case T_NOTHING:                 /* used to keep going on error cases */
                mdb_printf("nothing");
                break;
        case T_NAME:                    /* identifiers, sometimes chained */
                if (mdb_readstr(buf, (size_t)sizeof (buf),
                    (uintptr_t)node.u.name.s) < 0)
                        (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                            node.u.name.s);

                mdb_printf("%s", buf);
                if (node.u.name.cp) {
                        struct config cp;
                        if (mdb_vread(&cp, sizeof (cp),
                            (uintptr_t)node.u.name.cp) != sizeof (cp)) {
                                mdb_warn("failed to read struct config at %p",
                                    node.u.name.cp);
                                return (DCMD_ERR);
                        }
                        mdb_printf("%d", cp.num);
                } else if (node.u.name.it == IT_HORIZONTAL) {
                        if (node.u.name.child && !node.u.name.childgen) {
                                mdb_printf("<");
                                (void) eft_node((uintptr_t)node.u.name.child,
                                    DCMD_ADDRSPEC, 0, NULL);
                                mdb_printf(">");
                        } else {
                                mdb_printf("<> ");
                        }
                } else if (node.u.name.child) {
                        mdb_printf("[");
                        (void) eft_node((uintptr_t)node.u.name.child,
                            DCMD_ADDRSPEC, 0, NULL);
                        mdb_printf("]");
                }
                if (node.u.name.next) {
                        if (node.u.name.it == IT_ENAME)
                                mdb_printf(".");
                        else
                                mdb_printf("/");
                        (void) eft_node((uintptr_t)node.u.name.next,
                            DCMD_ADDRSPEC, 0, NULL);
                }
                break;
        case T_GLOBID:                  /* globals (e.g. $a) */
                if (mdb_readstr(buf, (size_t)sizeof (buf),
                    (uintptr_t)node.u.globid.s) < 0)
                        (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                            node.u.globid.s);

                mdb_printf("$%s", buf);
                break;
        case T_EVENT:                   /* class@path{expr} */
                (void) eft_node((uintptr_t)node.u.event.ename, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf("@");
                (void) eft_node((uintptr_t)node.u.event.epname, DCMD_ADDRSPEC,
                    0, NULL);
                if (node.u.event.eexprlist) {
                        mdb_printf(" { ");
                        (void) eft_node((uintptr_t)node.u.event.eexprlist,
                            DCMD_ADDRSPEC, 0, NULL);
                        mdb_printf(" }");
                }
                break;
        case T_ENGINE:                  /* upset threshold engine (e.g. SERD) */
                mdb_printf("engine ");
                (void) eft_node((uintptr_t)node.u.event.ename, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_ASRU:                    /* ASRU declaration */
                mdb_printf("asru ");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_FRU:                     /* FRU declaration */
                mdb_printf("fru ");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_TIMEVAL:                 /* num w/time suffix (ns internally) */
                {
                        mdb_arg_t mdb_arg[2];
                        mdb_arg[0].a_type = MDB_TYPE_STRING;
                        mdb_arg[0].a_un.a_str = "-l";
                        mdb_arg[1].a_type = MDB_TYPE_IMMEDIATE;
                        mdb_arg[1].a_un.a_val = node.u.ull;
                        (void) eft_time((uintptr_t)0, 0, 2, mdb_arg);
                        break;
                }
        case T_NUM:                     /* num (ull internally) */
                mdb_printf("%llu", node.u.ull);
                break;
        case T_QUOTE:                   /* quoted string */
                if (mdb_readstr(buf, (size_t)sizeof (buf),
                    (uintptr_t)node.u.quote.s) < 0)
                        (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                            node.u.quote.s);

                mdb_printf("\"%s\"", buf);
                break;
        case T_FUNC:                    /* func(arglist) */
                if (mdb_readstr(buf, (size_t)sizeof (buf),
                    (uintptr_t)node.u.func.s) < 0)
                        (void) mdb_snprintf(buf, (size_t)sizeof (buf), "<%p>",
                            node.u.func.s);

                mdb_printf("%s(", buf);
                (void) eft_node((uintptr_t)node.u.func.arglist, DCMD_ADDRSPEC,
                    0, NULL);
                mdb_printf(")");
                break;
        case T_NVPAIR:                  /* name=value pair in decl */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" = ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_ASSIGN:                  /* assignment statement */
                mdb_printf("(");
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" = ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(")");
                break;
        case T_CONDIF:                  /* a and T_CONDELSE in (a ? b : c ) */
                mdb_printf("(");
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" ? ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(")");
                break;
        case T_CONDELSE:                /* lists b and c in (a ? b : c ) */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" : ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_NOT:                     /* boolean ! operator */
                mdb_printf("!");
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_AND:                     /* boolean && operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" && ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_OR:                      /* boolean || operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" || ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_EQ:                      /* boolean == operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" == ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_NE:                      /* boolean != operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" != ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_SUB:                     /* integer - operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" - ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_ADD:                     /* integer + operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" + ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_MUL:                     /* integer * operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" * ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_DIV:                     /* integer / operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" / ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_MOD:                     /* integer % operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" % ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_LT:                      /* boolean < operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" < ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_LE:                      /* boolean <= operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" <= ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_GT:                      /* boolean > operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" > ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_GE:                      /* boolean >= operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" >= ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_BITAND:                  /* bitwise & operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" & ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_BITOR:                   /* bitwise | operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" | ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_BITXOR:                  /* bitwise ^ operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" ^ ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_BITNOT:                  /* bitwise ~ operator */
                mdb_printf(" ~");
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_LSHIFT:                  /* bitwise << operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" << ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_RSHIFT:                  /* bitwise >> operator */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(" >> ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_ARROW:                   /* lhs (N)->(K) rhs */
                (void) eft_node((uintptr_t)node.u.arrow.lhs, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.arrow.nnp) {
                        mdb_printf("(");
                        (void) eft_node((uintptr_t)node.u.arrow.nnp,
                            DCMD_ADDRSPEC, 0, NULL);
                        mdb_printf(")");
                }
                mdb_printf("->");
                if (node.u.arrow.knp) {
                        mdb_printf("(");
                        (void) eft_node((uintptr_t)node.u.arrow.knp,
                            DCMD_ADDRSPEC, 0, NULL);
                        mdb_printf(")");
                }
                (void) eft_node((uintptr_t)node.u.arrow.rhs, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_LIST:                    /* comma-separated list */
                (void) eft_node((uintptr_t)node.u.expr.left, DCMD_ADDRSPEC, 0,
                    NULL);
                mdb_printf(", ");
                (void) eft_node((uintptr_t)node.u.expr.right, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_FAULT:                   /* fault declaration */
                mdb_printf("fault.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_UPSET:                   /* upset declaration */
                mdb_printf("upset.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_DEFECT:                  /* defect declaration */
                mdb_printf("defect.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_ERROR:                   /* error declaration */
                mdb_printf("error.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_EREPORT:                 /* ereport declaration */
                mdb_printf("ereport.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        case T_SERD:                    /* SERD engine declaration */
                mdb_printf("serd.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                } else if (node.u.stmt.lutp) {
                        if (mdb_pwalk_dcmd("lut", "eft_node", 0, NULL,
                            (uintptr_t)node.u.stmt.lutp) != 0)
                                return (DCMD_ERR);
                }
                break;
        case T_STAT:                    /* STAT engine declaration */
                mdb_printf("stat.");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                } else if (node.u.stmt.lutp) {
                        if (mdb_pwalk_dcmd("lut", "eft_node", 0, NULL,
                            (uintptr_t)node.u.stmt.lutp) != 0)
                                return (DCMD_ERR);
                }
                break;
        case T_PROP:                    /* prop statement */
                mdb_printf("prop ");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_MASK:                    /* mask statement */
                mdb_printf("mask ");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                break;
        case T_CONFIG:                  /* config statement */
                mdb_printf("config ");
                (void) eft_node((uintptr_t)node.u.stmt.np, DCMD_ADDRSPEC, 0,
                    NULL);
                if (node.u.stmt.nvpairs) {
                        mdb_printf(" ");
                        (void) eft_node((uintptr_t)node.u.stmt.nvpairs,
                            DCMD_ADDRSPEC, 0, NULL);

                }
                break;
        default:
                mdb_printf("not a eversholt node\n");
                break;
        }
        return (DCMD_OK);
}

static const mdb_walker_t walkers[] = {
        { "lut", "walk a lookup table", lut_walk_init, lut_walk_step,
            lut_walk_fini, NULL },
        { "eft_ipath", "walk ipath", ipath_walk_init, ipath_walk_step,
            ipath_walk_fini, NULL },
        { NULL, NULL, NULL, NULL, NULL, NULL }
};

static const mdb_dcmd_t dcmds[] = {
        { "eft_ipath", "?", "print an ipath", ipath },
        { "eft_count", "?", "print eversholt stats", eft_count },
        { "eft_node", "?[-v]", "print eversholt node", eft_node },
        { "eft_time", "?[-p][-l time]", "print eversholt timeval", eft_time },
        { NULL }
};

static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };

const mdb_modinfo_t *
_mdb_init(void)
{
        return (&modinfo);
}