/*ARGSUSED*/
static int
hotplug_print(uintptr_t addr, struct dev_info *dev, devinfo_cb_data_t *data)
{
ddi_hp_cn_handle_t hdl;
uintptr_t hdlp = (uintptr_t)dev->devi_hp_hdlp;
char cn_type[15];
char cn_name[15];
while (hdlp) {
if (mdb_vread(&hdl, sizeof (ddi_hp_cn_handle_t), hdlp) == -1) {
mdb_warn("Failed to read hdlp!\n");
return (DCMD_ERR);
}
if (!(data->di_flags & DEVINFO_HP_PHYSICAL) ||
hdl.cn_info.cn_type != DDI_HP_CN_TYPE_VIRTUAL_PORT) {
if (mdb_readstr(cn_type, sizeof (cn_type),
(uintptr_t)hdl.cn_info.cn_type_str) == -1) {
mdb_warn("Failed to read cn_type!\n");
return (DCMD_ERR);
}
if (mdb_readstr(cn_name, sizeof (cn_name),
(uintptr_t)hdl.cn_info.cn_name) == -1) {
mdb_warn("Failed to read cn_name!\n");
return (DCMD_ERR);
}
mdb_printf("%?p %?p %-12s %-15s %-15s\n", hdl.cn_dip,
hdlp, ddihp_get_cn_state(hdl.cn_info.cn_state),
cn_type, cn_name);
}
hdlp = (uintptr_t)hdl.next;
};
return (WALK_NEXT);
}
/* ARGSUSED */
static int
xhci_mdb_print_device(uintptr_t addr, uint_t flags, int argc,
const mdb_arg_t *argv)
{
int count;
xhci_device_t xd;
usba_device_t ud;
char product[256], mfg[256];
if (!(flags & DCMD_ADDRSPEC)) {
return (mdb_eval("::walk xhci`xhci | ::walk xhci`xhci_device | "
"::xhci_device"));
}
if (mdb_vread(&xd, sizeof (xd), addr) != sizeof (xd)) {
mdb_warn("failed to read xhci_device_t at 0x%x", addr);
return (DCMD_ERR);
}
if (mdb_vread(&ud, sizeof (ud), (uintptr_t)xd.xd_usbdev) !=
sizeof (ud)) {
mdb_warn("failed to read usba_device_t at %p\n", xd.xd_usbdev);
return (DCMD_ERR);
}
if (ud.usb_mfg_str == NULL || mdb_readstr(mfg, sizeof (mfg),
(uintptr_t)ud.usb_mfg_str) <= 0) {
(void) strlcpy(mfg, "Unknown Manufacturer", sizeof (mfg));
}
if (ud.usb_product_str == NULL || mdb_readstr(product, sizeof (product),
(uintptr_t)ud.usb_product_str) <= 0) {
(void) strlcpy(product, "Unknown Product", sizeof (product));
}
mdb_printf("%<b>%s - %s%</b>\n", mfg, product);
count = 0;
if (mdb_pwalk("xhci`xhci_endpoint", xhci_mdb_endpoint_count, &count,
addr) == -1) {
mdb_warn("failed to walk xhci_endpoint rooted at 0x%x", addr);
return (DCMD_ERR);
}
mdb_printf("Port %02d | Slot %02d | # Endpoints %02d\n", xd.xd_port,
xd.xd_slot, count);
mdb_printf("%<u>%-4s %-10s %-10s %-6s %-6s%</u>\n", "EP", "Type",
"State", "Head", "Tail");
if (mdb_pwalk("xhci`xhci_endpoint", xhci_mdb_print_endpoint_summary,
&xd, addr) == -1) {
mdb_warn("failed to walk xhci_endpoint rooted at 0x%x", addr);
return (DCMD_ERR);
}
mdb_printf("\n");
return (DCMD_OK);
}
static int
fmd_asru_link(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char uuid[48], name[PATH_MAX];
fmd_asru_link_t a;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_asru_link", "fmd_asru_link", argc,
argv) != 0) {
mdb_warn("failed to walk fmd_asru_link hash");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&a, sizeof (a), addr) != sizeof (a)) {
mdb_warn("failed to read fmd_asru_link at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-8s %-36s %s%</u>\n", "ADDR", "UUID", "NAME");
if (mdb_readstr(uuid, sizeof (uuid), (uintptr_t)a.al_uuid) <= 0)
(void) mdb_snprintf(uuid, sizeof (uuid), "<%p>", a.al_uuid);
if (mdb_readstr(name, sizeof (name), (uintptr_t)a.al_rsrc_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>",
a.al_rsrc_name);
mdb_printf("%-8p %-36s %s\n", addr, uuid, name);
return (DCMD_OK);
}
int
hotplug(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
devinfo_cb_data_t data;
uintptr_t devinfo_root; /* Address of root of devinfo tree */
ddi_hp_cn_handle_t hdl;
char cn_type[15];
char cn_name[15];
int status;
data.di_flags = 0;
if (mdb_getopts(argc, argv,
'p', MDB_OPT_SETBITS, DEVINFO_HP_PHYSICAL, &data.di_flags, NULL)
!= argc)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%?s %?s %-12s %-15s %-15s%</u>\n",
"PARENT_DEVINFO", "HANDLE", "STATE", "TYPE", "CN_NAME");
}
if ((flags & DCMD_ADDRSPEC) == 0) {
data.di_flags |= DEVINFO_PARENT | DEVINFO_CHILD;
if (mdb_readvar(&devinfo_root, "top_devinfo") == -1) {
mdb_warn("failed to read 'top_devinfo'");
return (NULL);
}
data.di_base = devinfo_root;
status = mdb_pwalk("devinfo", (mdb_walk_cb_t)hotplug_print,
&data, devinfo_root);
if (status == -1) {
mdb_warn("couldn't walk devinfo tree");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&hdl, sizeof (ddi_hp_cn_handle_t), (uintptr_t)addr)
== -1) {
mdb_warn("Failed to read hdlp!\n");
return (DCMD_ERR);
}
if (mdb_readstr(cn_type, sizeof (cn_type),
(uintptr_t)hdl.cn_info.cn_type_str) == -1) {
mdb_warn("Failed to read cn_type!\n");
return (DCMD_ERR);
}
if (mdb_readstr(cn_name, sizeof (cn_name),
(uintptr_t)hdl.cn_info.cn_name) == -1) {
mdb_warn("Failed to read cn_name!\n");
return (DCMD_ERR);
}
mdb_printf("%?p %?p %-12s %-15s %-15s\n", hdl.cn_dip, addr,
ddihp_get_cn_state(hdl.cn_info.cn_state), cn_type, cn_name);
return (DCMD_OK);
}
/*
* print the address of a unix domain socket
*
* so is the address of a AF_UNIX struct sonode in mdb's address space
* soa is the address of the struct soaddr to print
*
* returns 0 on success, -1 otherwise
*/
static int
netstat_unix_name_pr(const struct sotpi_sonode *st, const struct soaddr *soa)
{
const struct sonode *so = &st->st_sonode;
const char none[] = " (none)";
if ((so->so_state & SS_ISBOUND) && (soa->soa_len != 0)) {
if (st->st_info.sti_faddr_noxlate) {
mdb_printf("%-14s ", " (socketpair)");
} else {
if (soa->soa_len > sizeof (sa_family_t)) {
char addr[MAXPATHLEN + 1];
if (mdb_readstr(addr, sizeof (addr),
(uintptr_t)&soa->soa_sa->sa_data) == -1) {
mdb_warn("failed to read unix address "
"at %p", &soa->soa_sa->sa_data);
return (-1);
}
mdb_printf("%-14s ", addr);
} else {
mdb_printf("%-14s ", none);
}
}
} else {
mdb_printf("%-14s ", none);
}
return (0);
}
/*ARGSUSED*/
static int
fmd_serd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[PATH_MAX];
fmd_serd_eng_t sg;
if (argc != 0)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk("fmd_module", module_serd, 0) == -1) {
mdb_warn("failed to walk 'fmd_module'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&sg, sizeof (sg), addr) != sizeof (sg)) {
mdb_warn("failed to read fmd_serd_eng at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-32s %-3s F >%-2s %-16s%</u>\n",
"ADDR", "NAME", "CNT", "N", "T");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)sg.sg_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", sg.sg_name);
mdb_printf("%-11p %-32s %-3u %c >%-2u %lluns\n",
addr, name, sg.sg_count, (sg.sg_flags & FMD_SERD_FIRED) ? 'F' : ' ',
sg.sg_n, (u_longlong_t)sg.sg_t);
return (DCMD_OK);
}
static int
fmd_module(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
fmd_module_t mod;
char name[PATH_MAX];
if (!(flags & DCMD_ADDRSPEC))
return (mdb_walk_dcmd("fmd_module", "fmd_module", argc, argv));
if (argc != 0)
return (DCMD_USAGE);
if (mdb_vread(&mod, sizeof (mod), addr) != sizeof (mod)) {
mdb_warn("failed to read fmd_module at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-16s %-11s %-4s %-?s %-16s%</u>\n",
"ADDR", "OPS", "DATA", "FLAG", "USTAT", "NAME");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)mod.mod_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", mod.mod_name);
mdb_printf("%-11p %-16a %-11p 0x%02x %-?p %s\n", addr,
mod.mod_ops, mod.mod_data, mod.mod_flags, mod.mod_ustat, name);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
fmd_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[PATH_MAX];
fmd_buf_t b;
if (argc != 0 || !(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_vread(&b, sizeof (b), addr) != sizeof (b)) {
mdb_warn("failed to read fmd_buf at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-32s %-5s %-?s %s%</u>\n",
"ADDR", "NAME", "FLAGS", "DATA", "SIZE");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)b.buf_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", b.buf_name);
mdb_printf("%-11p %-32s %-#5x %-?p %lu\n",
addr, name, b.buf_flags, b.buf_data, b.buf_size);
return (DCMD_OK);
}
/* print out the correct set */
int
print_set(uintptr_t addr)
{
char machine[1024];
if (mdb_vread(&set_db, sizeof (mddb_set_t), addr) == -1) {
if (addr != NULL) {
mdb_warn("failed to read mddb_set_t at 0x%p\n", addr);
return (DCMD_ERR);
} else {
return (DCMD_OK);
}
}
if (set_db.s_setname != 0) {
if (mdb_readstr(machine, 1024,
(uintptr_t)set_db.s_setname) == -1) {
mdb_warn("failed to read setname at 0x%p\n",
set_db.s_setname);
} else {
mdb_printf("Setname: %s Setno: %u\t%p\n",
machine, set_db.s_setno, addr);
}
} else {
mdb_printf("Setname: NULL Setno: %u\t%p\n",
set_db.s_setno, addr);
}
mdb_inc_indent(2);
mdb_printf("s_un = %p\n", mdset[set_db.s_setno].s_un);
mdb_printf("s_hsp = %p\n", mdset[set_db.s_setno].s_hsp);
mdb_dec_indent(2);
return (DCMD_OK);
}
static int
fmd_case(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char uuid[48], name[16];
fmd_case_impl_t ci;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_case", "fmd_case", argc, argv) != 0) {
mdb_warn("failed to walk fmd_case hash");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&ci, sizeof (ci), addr) != sizeof (ci)) {
mdb_warn("failed to read fmd_case at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-5s %-3s %-?s %-36s%</u>\n",
"ADDR", "STATE", "REF", "DATA", "UUID");
}
if (mdb_readstr(uuid, sizeof (uuid), (uintptr_t)ci.ci_uuid) <= 0)
(void) mdb_snprintf(uuid, sizeof (uuid), "<%p>", ci.ci_uuid);
switch (ci.ci_state) {
case FMD_CASE_UNSOLVED:
(void) strcpy(name, "UNSLV");
break;
case FMD_CASE_SOLVED:
(void) strcpy(name, "SOLVE");
break;
case FMD_CASE_CLOSE_WAIT:
(void) strcpy(name, "CWAIT");
break;
case FMD_CASE_CLOSED:
(void) strcpy(name, "CLOSE");
break;
case FMD_CASE_REPAIRED:
(void) strcpy(name, "RPAIR");
break;
case FMD_CASE_RESOLVED:
(void) strcpy(name, "RSLVD");
break;
default:
(void) mdb_snprintf(name, sizeof (name), "%u", ci.ci_state);
}
mdb_printf("%-11p %-5s %-3u %-?p %s\n",
addr, name, ci.ci_refs, ci.ci_data, uuid);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
x86_featureset_cmd(uintptr_t addr, uint_t flags, int argc,
const mdb_arg_t *argv)
{
void *fset;
GElf_Sym sym;
uintptr_t nptr;
char name[128];
int ii;
size_t sz = sizeof (uchar_t) * BT_SIZEOFMAP(NUM_X86_FEATURES);
if (argc != 0)
return (DCMD_USAGE);
if (mdb_lookup_by_name("x86_feature_names", &sym) == -1) {
mdb_warn("couldn't find x86_feature_names");
return (DCMD_ERR);
}
fset = mdb_zalloc(sz, UM_NOSLEEP);
if (fset == NULL) {
mdb_warn("failed to allocate memory for x86_featureset");
return (DCMD_ERR);
}
if (mdb_readvar(fset, "x86_featureset") != sz) {
mdb_warn("failed to read x86_featureset");
mdb_free(fset, sz);
return (DCMD_ERR);
}
for (ii = 0; ii < NUM_X86_FEATURES; ii++) {
if (!BT_TEST((ulong_t *)fset, ii))
continue;
if (mdb_vread(&nptr, sizeof (char *), sym.st_value +
sizeof (void *) * ii) != sizeof (char *)) {
mdb_warn("failed to read feature array %d", ii);
mdb_free(fset, sz);
return (DCMD_ERR);
}
if (mdb_readstr(name, sizeof (name), nptr) == -1) {
mdb_warn("failed to read feature %d", ii);
mdb_free(fset, sz);
return (DCMD_ERR);
}
mdb_printf("%s\n", name);
}
mdb_free(fset, sz);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
fmd_xprt_class(uintptr_t addr, const void *data, void *arg)
{
const fmd_xprt_class_t *xcp = data;
char name[1024];
if (mdb_readstr(name, sizeof (name), (uintptr_t)xcp->xc_class) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", xcp->xc_class);
mdb_printf("%-8p %-4u %s\n", addr, xcp->xc_refs, name);
return (WALK_NEXT);
}
int
cyccover_comp(const void *l, const void *r)
{
cyc_coverage_t *lhs = (cyc_coverage_t *)l;
cyc_coverage_t *rhs = (cyc_coverage_t *)r;
char ly[WHYLEN], ry[WHYLEN];
if (rhs->cyv_why == lhs->cyv_why)
return (0);
if (rhs->cyv_why == NULL)
return (-1);
if (lhs->cyv_why == NULL)
return (1);
(void) mdb_readstr(ly, WHYLEN, (uintptr_t)lhs->cyv_why);
(void) mdb_readstr(ry, WHYLEN, (uintptr_t)rhs->cyv_why);
return (strcmp(ly, ry));
}
int
rctl_dict(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
rctl_dict_entry_t dict;
char name[256], *type = NULL;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("rctl_dict_list", "rctl_dict", argc,
argv) == -1) {
mdb_warn("failed to walk 'rctl_dict_list'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%2s %-27s %?s %7s %s%</u>\n",
"ID", "NAME", "ADDR", "TYPE", "GLOBAL_FLAGS");
if (mdb_vread(&dict, sizeof (dict), addr) == -1) {
mdb_warn("failed to read rctl_dict at %p", addr);
return (DCMD_ERR);
}
if (mdb_readstr(name, 256, (uintptr_t)(dict.rcd_name)) == -1) {
mdb_warn("failed to read rctl_dict name for %p", addr);
return (DCMD_ERR);
}
switch (dict.rcd_entity) {
case RCENTITY_PROCESS:
type = "process";
break;
case RCENTITY_TASK:
type = "task";
break;
case RCENTITY_PROJECT:
type = "project";
break;
case RCENTITY_ZONE:
type = "zone";
break;
default:
type = "unknown";
break;
}
mdb_printf("%2d %-27s %0?p %7s 0x%08x", dict.rcd_id, name, addr,
type, dict.rcd_flagaction);
return (DCMD_OK);
}
int
rctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
rctl_t rctl;
rctl_dict_entry_t dict;
char name[256];
rctl_hndl_t hndl;
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_vread(&rctl, sizeof (rctl_t), addr) == -1) {
mdb_warn("failed to read rctl_t structure at %p", addr);
return (DCMD_ERR);
}
if (argc != 0) {
const mdb_arg_t *argp = &argv[0];
if (argp->a_type == MDB_TYPE_IMMEDIATE)
hndl = (rctl_hndl_t)argp->a_un.a_val;
else
hndl = (rctl_hndl_t)mdb_strtoull(argp->a_un.a_str);
if (rctl.rc_id != hndl)
return (DCMD_OK);
}
if (mdb_vread(&dict, sizeof (rctl_dict_entry_t),
(uintptr_t)rctl.rc_dict_entry) == -1) {
mdb_warn("failed to read dict entry for rctl_t %p at %p",
addr, rctl.rc_dict_entry);
return (DCMD_ERR);
}
if (mdb_readstr(name, 256, (uintptr_t)(dict.rcd_name)) == -1) {
mdb_warn("failed to read name for rctl_t %p", addr);
return (DCMD_ERR);
}
mdb_printf("%0?p\t%3d : %s\n", addr, rctl.rc_id, name);
if (mdb_pwalk("rctl_val", (mdb_walk_cb_t)print_val, &(rctl.rc_cursor),
addr) == -1) {
mdb_warn("failed to walk all values for rctl_t %p", addr);
return (DCMD_ERR);
}
return (DCMD_OK);
}
static void
get_ifname(const ire_t *ire, char *intf)
{
ill_t ill;
*intf = '\0';
if (ire->ire_ill != NULL) {
if (mdb_vread(&ill, sizeof (ill),
(uintptr_t)ire->ire_ill) == -1)
return;
(void) mdb_readstr(intf, MIN(LIFNAMSIZ, ill.ill_name_length),
(uintptr_t)ill.ill_name);
}
}
/* ARGSUSED */
static int
module_ustat(uintptr_t addr, const void *data, void *wsp)
{
fmd_module_t *modp = (fmd_module_t *)data;
char name[PATH_MAX];
const struct fmd_cmd_data *udp = wsp;
if (mdb_readstr(name, sizeof (name), (uintptr_t)modp->mod_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>",
modp->mod_name);
mdb_printf("%s\n", name);
(void) fmd_ustat((uintptr_t)modp->mod_ustat,
DCMD_ADDRSPEC | DCMD_LOOPFIRST, udp->argc, udp->argv);
return (WALK_NEXT);
}
int
sysevent_channel(uintptr_t addr, uint_t flags, int argc,
const mdb_arg_t *argv)
{
ssize_t channel_name_sz;
char channel_name[CHAN_FIELD_MAX];
sysevent_channel_descriptor_t chan_tbl;
if (argc != 0)
return (DCMD_USAGE);
if ((flags & DCMD_ADDRSPEC) == 0) {
if (mdb_walk_dcmd("sysevent_channel", "sysevent_channel",
argc, argv) == -1) {
mdb_warn("can't walk sysevent channel");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-?s %-16s %-8s %-?s%</u>\n",
"ADDR", "NAME", "REF CNT", "CLASS LST ADDR");
if (mdb_vread(&chan_tbl, sizeof (chan_tbl),
(uintptr_t)addr) == -1) {
mdb_warn("failed to read channel table at %p", addr);
return (DCMD_ERR);
}
if ((channel_name_sz = mdb_readstr(channel_name, CHAN_FIELD_MAX,
(uintptr_t)chan_tbl.scd_channel_name)) == -1) {
mdb_warn("failed to read channel name at %p",
chan_tbl.scd_channel_name);
return (DCMD_ERR);
}
if (channel_name_sz >= CHAN_FIELD_MAX - 1)
(void) strcpy(&channel_name[CHAN_FIELD_MAX - 4], "...");
mdb_printf("%-?p %-16s %-8lu %-?p\n",
addr, channel_name, chan_tbl.scd_ref_cnt,
addr + offsetof(sysevent_channel_descriptor_t,
scd_class_list_tbl));
return (DCMD_OK);
}
/*ARGSUSED*/
static int
trprint_cpp(uintptr_t addr, const fmd_tracerec_t *trp, uintptr_t tid)
{
char file[64];
if (tid == 0)
mdb_printf("%3lu ", trp->tr_stack[trp->tr_depth]);
else if (trp->tr_stack[trp->tr_depth] != tid)
return (WALK_NEXT);
if (mdb_readstr(file, sizeof (file), (uintptr_t)trp->tr_file) <= 0)
(void) strcpy(file, "???");
mdb_printf("%016llx %04x %s: %u\n",
trp->tr_time, 1 << trp->tr_tag, file, trp->tr_line);
return (WALK_NEXT);
}
/*ARGSUSED*/
int
cyccover(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
cyc_coverage_t cv[CY_NCOVERAGE];
char c[WHYLEN];
GElf_Sym sym;
int i;
if ((flags & DCMD_ADDRSPEC) || argc != 0)
return (DCMD_USAGE);
if (mdb_lookup_by_name("cyc_coverage", &sym) == -1) {
mdb_warn("couldn't find coverage information");
return (DCMD_ABORT);
}
addr = (uintptr_t)sym.st_value;
if (mdb_vread(cv, sizeof (cyc_coverage_t) * CY_NCOVERAGE, addr) == -1) {
mdb_warn("couldn't read coverage array at %p", addr);
return (DCMD_ABORT);
}
mdb_printf("%-*s %8s %8s %8s %15s %15s\n",
WHYLEN, "POINT", "HIGH", "LOCK", "LOW/PASV", "ARG0", "ARG1");
qsort(cv, CY_NCOVERAGE, sizeof (cyc_coverage_t), cyccover_comp);
for (i = 0; i < CY_NCOVERAGE; i++) {
if (cv[i].cyv_why != NULL) {
(void) mdb_readstr(c, WHYLEN, (uintptr_t)cv[i].cyv_why);
mdb_printf("%-*s %8d %8d %8d %15llx %15llx\n",
WHYLEN, c,
cv[i].cyv_count[CY_HIGH_LEVEL],
cv[i].cyv_count[CY_LOCK_LEVEL],
cv[i].cyv_passive_count != 0 ?
cv[i].cyv_passive_count :
cv[i].cyv_count[CY_LOW_LEVEL],
cv[i].cyv_arg0, cv[i].cyv_arg1);
}
}
return (DCMD_OK);
}
int
sysevent_class_list(uintptr_t addr, uint_t flags, int argc,
const mdb_arg_t *argv)
{
int class_name_sz;
char class_name[CLASS_LIST_FIELD_MAX];
class_lst_t clist;
if ((flags & DCMD_ADDRSPEC) == 0)
return (DCMD_USAGE);
if ((flags & DCMD_LOOP) == 0) {
if (mdb_pwalk_dcmd("sysevent_class_list", "sysevent_class_list",
argc, argv, addr) == -1) {
mdb_warn("can't walk sysevent class list");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-?s %-24s %-?s%</u>\n",
"ADDR", "NAME", "SUBCLASS LIST ADDR");
if (mdb_vread(&clist, sizeof (clist),
(uintptr_t)addr) == -1) {
mdb_warn("failed to read class clist at %p", addr);
return (DCMD_ERR);
}
if ((class_name_sz = mdb_readstr(class_name, CLASS_LIST_FIELD_MAX,
(uintptr_t)clist.cl_name)) == -1) {
mdb_warn("failed to read class name at %p",
clist.cl_name);
return (DCMD_ERR);
}
if (class_name_sz >= CLASS_LIST_FIELD_MAX - 1)
(void) strcpy(&class_name[CLASS_LIST_FIELD_MAX - 4], "...");
mdb_printf("%-?p %-24s %-?p\n", addr, class_name,
clist.cl_subclass_list);
return (DCMD_OK);
}
static void
print_ksid(const ksid_t *ks)
{
char str[80];
ksiddomain_t kd;
uintptr_t da, sa;
/* in case of errors */
strcpy(str, "(domain?)");
da = (uintptr_t)ks->ks_domain;
if (da == 0 || mdb_vread(&kd, sizeof (kd), da) < 0)
bzero(&kd, sizeof (kd));
sa = (uintptr_t)kd.kd_name;
if (sa != 0)
(void) mdb_readstr(str, sizeof (str), sa);
mdb_printf("%s-%u,\n", str, ks->ks_rid);
}
/*
* Display a single sv_glcient_t structure.
* If called with no address, performs a global walk of all sv_gclients.
*/
static int
sv_gclient(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
sv_gclient_t sg;
char name[64];
if (argc != 0)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
/*
* paranoid mode on: qualify walker name with module name
* using '`' syntax.
*/
if (mdb_walk_dcmd("sv`sv_gclient",
"sv`sv_gclient", argc, argv) == -1) {
mdb_warn("failed to walk 'sv_gclient'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&sg, sizeof (sg), addr) != sizeof (sg)) {
mdb_warn("failed to read sv_gclient at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%-?s %8T%-?s %8T%-16s %8T%s\n",
"ADDR", "NEXT", "ID", "NAME");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)sg.sg_name) == -1) {
mdb_warn("failed to read sv_gclient name at %p", addr);
return (DCMD_ERR);
}
mdb_printf("%p %8T%p %8T%llx %8T%s",
addr, sg.sg_next, sg.sg_id, name);
return (DCMD_OK);
}
int
cyctrace_walk(uintptr_t addr, const cyc_tracerec_t *rec, cyc_cpu_t *cpu)
{
int i;
char c[WHYLEN];
for (i = 0; cpu != NULL && i < CY_LEVELS; i++)
if (addr < (uintptr_t)&cpu->cyp_trace[i + 1].cyt_buf[0])
break;
(void) mdb_readstr(c, WHYLEN, (uintptr_t)rec->cyt_why);
mdb_printf("%08p %4s %15llx %-*s %15llx %15llx\n",
addr & UINT_MAX, cpu == NULL ? "pasv" :
i == CY_HIGH_LEVEL ? "high" : i == CY_LOCK_LEVEL ? "lock" :
i == CY_LOW_LEVEL ? "low" : "????", rec->cyt_tstamp, WHYLEN, c,
rec->cyt_arg0, rec->cyt_arg1);
return (0);
}
static int
fmd_timer(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[32], func[MDB_SYM_NAMLEN];
fmd_timer_t t;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_timerq", "fmd_timer", argc, argv) != 0) {
mdb_warn("failed to walk fmd_timerq");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&t, sizeof (t), addr) != sizeof (t)) {
mdb_warn("failed to read fmd_timer at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-8s %-20s %-4s %-18s %-8s %s%</u>\n",
"ADDR", "MODULE", "ID", "HRTIME", "ARG", "FUNC");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)
t.tmr_ids + OFFSETOF(fmd_idspace_t, ids_name)) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", t.tmr_ids);
if (mdb_lookup_by_addr((uintptr_t)t.tmr_func, MDB_SYM_FUZZY,
func, sizeof (func), NULL) != 0)
(void) mdb_snprintf(func, sizeof (func), "<%p>", t.tmr_func);
mdb_printf("%-8p %-20s %4d 0x%-16llx %-8p %s\n",
addr, name, t.tmr_id, t.tmr_hrt, t.tmr_arg, func);
return (DCMD_OK);
}
/*
* Utility routine to read in a filesystem name given a vfs pointer. If
* no vfssw entry for the vfs is available (as is the case with some pseudo-
* filesystems), we check against some known problem fs's: doorfs and
* portfs. If that fails, we try to guess the filesystem name using
* symbol names. fsname should be a buffer of size _ST_FSTYPSZ.
*/
static int
read_fsname(uintptr_t vfsp, char *fsname)
{
vfs_t vfs;
struct vfssw vfssw_entry;
GElf_Sym vfssw_sym, test_sym;
char testname[MDB_SYM_NAMLEN];
if (mdb_vread(&vfs, sizeof (vfs), vfsp) == -1) {
mdb_warn("failed to read vfs %p", vfsp);
return (-1);
}
if (mdb_lookup_by_name("vfssw", &vfssw_sym) == -1) {
mdb_warn("failed to find vfssw");
return (-1);
}
/*
* vfssw is an array; we need vfssw[vfs.vfs_fstype].
*/
if (mdb_vread(&vfssw_entry, sizeof (vfssw_entry),
vfssw_sym.st_value + (sizeof (struct vfssw) * vfs.vfs_fstype))
== -1) {
mdb_warn("failed to read vfssw index %d", vfs.vfs_fstype);
return (-1);
}
if (vfs.vfs_fstype != 0) {
if (mdb_readstr(fsname, _ST_FSTYPSZ,
(uintptr_t)vfssw_entry.vsw_name) == -1) {
mdb_warn("failed to find fs name %p",
vfssw_entry.vsw_name);
return (-1);
}
return (0);
}
/*
* Do precise detection for certain filesystem types that we
* know do not appear in vfssw[], and that we depend upon in other
* parts of the code: doorfs and portfs.
*/
if (mdb_lookup_by_name("door_vfs", &test_sym) != -1) {
if (test_sym.st_value == vfsp) {
strcpy(fsname, "doorfs");
return (0);
}
}
if (mdb_lookup_by_name("port_vfs", &test_sym) != -1) {
if (test_sym.st_value == vfsp) {
strcpy(fsname, "portfs");
return (0);
}
}
/*
* Heuristic detection for other filesystems that don't have a
* vfssw[] entry. These tend to be named <fsname>_vfs, so we do a
* lookup_by_addr and see if we find a symbol of that name.
*/
if (mdb_lookup_by_addr(vfsp, MDB_SYM_EXACT, testname, sizeof (testname),
&test_sym) != -1) {
if ((strlen(testname) > 4) &&
(strcmp(testname + strlen(testname) - 4, "_vfs") == 0)) {
testname[strlen(testname) - 4] = '\0';
strncpy(fsname, testname, _ST_FSTYPSZ);
return (0);
}
}
mdb_warn("unknown filesystem type for vfs %p", vfsp);
return (-1);
}
int
zoneprt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
zone_t zn;
char name[ZONE_NAMELEN];
char path[ZONE_PATHLEN];
int len;
uint_t vopt_given;
uint_t ropt_given;
if (argc > 2)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("zone", "zone", argc, argv) == -1) {
mdb_warn("can't walk zones");
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* Get the optional -r (reference counts) and -v (verbose output)
* arguments.
*/
vopt_given = FALSE;
ropt_given = FALSE;
if (argc > 0 && mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE,
&vopt_given, 'r', MDB_OPT_SETBITS, TRUE, &ropt_given, NULL) != argc)
return (DCMD_USAGE);
/*
* -v can only be specified with -r.
*/
if (vopt_given == TRUE && ropt_given == FALSE)
return (DCMD_USAGE);
/*
* Print a table header, if necessary.
*/
if (DCMD_HDRSPEC(flags)) {
if (ropt_given == FALSE)
mdb_printf("%<u>%?s %6s %-13s %-20s %-s%</u>\n",
"ADDR", "ID", "STATUS", "NAME", "PATH");
else
mdb_printf("%<u>%?s %6s %10s %10s %-20s%</u>\n",
"ADDR", "ID", "REFS", "CREFS", "NAME");
}
/*
* Read the zone_t structure at the given address and read its name.
*/
if (mdb_vread(&zn, sizeof (zone_t), addr) == -1) {
mdb_warn("can't read zone_t structure at %p", addr);
return (DCMD_ERR);
}
len = mdb_readstr(name, ZONE_NAMELEN, (uintptr_t)zn.zone_name);
if (len > 0) {
if (len == ZONE_NAMELEN)
(void) strcpy(&name[len - 4], "...");
} else {
(void) strcpy(name, "??");
}
if (ropt_given == FALSE) {
char *statusp;
/*
* Default display
* Fetch the zone's path and print the results.
*/
len = mdb_readstr(path, ZONE_PATHLEN,
(uintptr_t)zn.zone_rootpath);
if (len > 0) {
if (len == ZONE_PATHLEN)
(void) strcpy(&path[len - 4], "...");
} else {
(void) strcpy(path, "??");
}
if (zn.zone_status >= ZONE_IS_UNINITIALIZED && zn.zone_status <=
ZONE_IS_DEAD)
statusp = zone_status_names[zn.zone_status];
else
statusp = "???";
mdb_printf("%0?p %6d %-13s %-20s %s\n", addr, zn.zone_id,
statusp, name, path);
} else {
/*
* Display the zone's reference counts.
* Display the zone's subsystem-specific reference counts if
* the user specified the '-v' option.
*/
mdb_printf("%0?p %6d %10u %10u %-20s\n", addr, zn.zone_id,
zn.zone_ref, zn.zone_cred_ref, name);
if (vopt_given == TRUE) {
GElf_Sym subsys_names_sym;
uintptr_t **zone_ref_subsys_names;
uint_t num_subsys;
uint_t n;
/*
* Read zone_ref_subsys_names from the kernel image.
*/
if (mdb_lookup_by_name("zone_ref_subsys_names",
&subsys_names_sym) != 0) {
mdb_warn("can't find zone_ref_subsys_names");
return (DCMD_ERR);
}
if (subsys_names_sym.st_size != ZONE_REF_NUM_SUBSYS *
sizeof (char *)) {
mdb_warn("number of subsystems in target "
"differs from what mdb expects (mismatched"
" kernel versions?)");
if (subsys_names_sym.st_size <
ZONE_REF_NUM_SUBSYS * sizeof (char *))
num_subsys = subsys_names_sym.st_size /
sizeof (char *);
else
num_subsys = ZONE_REF_NUM_SUBSYS;
} else {
num_subsys = ZONE_REF_NUM_SUBSYS;
}
if ((zone_ref_subsys_names = mdb_alloc(
subsys_names_sym.st_size, UM_GC)) == NULL) {
mdb_warn("out of memory");
return (DCMD_ERR);
}
if (mdb_readvar(zone_ref_subsys_names,
"zone_ref_subsys_names") == -1) {
mdb_warn("can't find zone_ref_subsys_names");
return (DCMD_ERR);
}
/*
* Display each subsystem's reference count if it's
* nonzero.
*/
mdb_inc_indent(7);
for (n = 0; n < num_subsys; ++n) {
char subsys_name[16];
/*
* Skip subsystems lacking outstanding
* references.
*/
if (zn.zone_subsys_ref[n] == 0)
continue;
/*
* Each subsystem's name must be read from
* the target's image.
*/
if (mdb_readstr(subsys_name,
sizeof (subsys_name),
(uintptr_t)zone_ref_subsys_names[n]) ==
-1) {
mdb_warn("unable to read subsystem name"
" from zone_ref_subsys_names[%u]",
n);
return (DCMD_ERR);
}
mdb_printf("%15s: %10u\n", subsys_name,
zn.zone_subsys_ref[n]);
}
mdb_dec_indent(7);
}
}
return (DCMD_OK);
}
/*ARGSUSED*/
int
fsinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
vfs_t vfs;
int len;
int opt_v = 0;
char buf[MAXPATHLEN];
char fsname[_ST_FSTYPSZ];
mntopt_t *mntopts;
size_t size;
int i;
int first = 1;
char opt[MAX_MNTOPT_STR];
uintptr_t global_zone;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("vfs", "fsinfo", argc, argv) == -1) {
mdb_warn("failed to walk file system list");
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("%<u>%?s %-15s %s%</u>\n",
"VFSP", "FS", "MOUNT");
if (mdb_vread(&vfs, sizeof (vfs), addr) == -1) {
mdb_warn("failed to read vfs_t %p", addr);
return (DCMD_ERR);
}
if ((len = mdb_read_refstr((uintptr_t)vfs.vfs_mntpt, buf,
sizeof (buf))) <= 0)
strcpy(buf, "??");
else if (!opt_v && (len >= FSINFO_MNTLEN))
/*
* In normal mode, we truncate the path to keep the output
* clean. In -v mode, we just print the full path.
*/
strcpy(&buf[FSINFO_MNTLEN - 4], "...");
if (read_fsname(addr, fsname) == -1)
return (DCMD_ERR);
mdb_printf("%0?p %-15s %s\n", addr, fsname, buf);
if (!opt_v)
return (DCMD_OK);
/*
* Print 'resource' string; this shows what we're mounted upon.
*/
if (mdb_read_refstr((uintptr_t)vfs.vfs_resource, buf,
MAXPATHLEN) <= 0)
strcpy(buf, "??");
mdb_printf("%?s %s\n", "R:", buf);
/*
* Print mount options array; it sucks to be a mimic, but we copy
* the same logic as in mntvnops.c for adding zone= tags, and we
* don't bother with the obsolete dev= option.
*/
size = vfs.vfs_mntopts.mo_count * sizeof (mntopt_t);
mntopts = mdb_alloc(size, UM_SLEEP | UM_GC);
if (mdb_vread(mntopts, size,
(uintptr_t)vfs.vfs_mntopts.mo_list) == -1) {
mdb_warn("failed to read mntopts %p", vfs.vfs_mntopts.mo_list);
return (DCMD_ERR);
}
for (i = 0; i < vfs.vfs_mntopts.mo_count; i++) {
if (mntopts[i].mo_flags & MO_SET) {
if (mdb_readstr(opt, sizeof (opt),
(uintptr_t)mntopts[i].mo_name) == -1) {
mdb_warn("failed to read mntopt name %p",
mntopts[i].mo_name);
return (DCMD_ERR);
}
if (first) {
mdb_printf("%?s ", "O:");
first = 0;
} else {
mdb_printf(",");
}
mdb_printf("%s", opt);
if (mntopts[i].mo_flags & MO_HASVALUE) {
if (mdb_readstr(opt, sizeof (opt),
(uintptr_t)mntopts[i].mo_arg) == -1) {
mdb_warn("failed to read mntopt "
"value %p", mntopts[i].mo_arg);
return (DCMD_ERR);
}
mdb_printf("=%s", opt);
}
}
}
if (mdb_readvar(&global_zone, "global_zone") == -1) {
mdb_warn("failed to locate global_zone");
return (DCMD_ERR);
}
if ((vfs.vfs_zone != NULL) &&
((uintptr_t)vfs.vfs_zone != global_zone)) {
zone_t z;
if (mdb_vread(&z, sizeof (z), (uintptr_t)vfs.vfs_zone) == -1) {
mdb_warn("failed to read zone");
return (DCMD_ERR);
}
/*
* zone names are much shorter than MAX_MNTOPT_STR
*/
if (mdb_readstr(opt, sizeof (opt),
(uintptr_t)z.zone_name) == -1) {
mdb_warn("failed to read zone name");
return (DCMD_ERR);
}
if (first) {
mdb_printf("%?s ", "O:");
} else {
mdb_printf(",");
}
mdb_printf("zone=%s", opt);
}
return (DCMD_OK);
}
/*ARGSUSED*/
static int
fmd_stat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char buf[512];
fmd_stat_t s;
if (argc != 0)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-11s %-4s %-32s %s%</u>\n",
"ADDR", "TYPE", "NAME", "VALUE");
if (!(flags & DCMD_ADDRSPEC)) {
struct fmd_cmd_data ud;
ud.argc = argc;
ud.argv = argv;
if (mdb_walk("fmd_module", module_stat, &ud) == -1) {
mdb_warn("failed to walk 'fmd_module'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) {
mdb_warn("failed to read statistic at %p", addr);
return (DCMD_ERR);
}
switch (s.fmds_type) {
case FMD_TYPE_BOOL:
mdb_printf("%-11p %-4s %-32s %s\n", addr, "bool",
s.fmds_name, s.fmds_value.bool ? "true" : "false");
break;
case FMD_TYPE_INT32:
mdb_printf("%-11p %-4s %-32s %d\n", addr, "i32",
s.fmds_name, s.fmds_value.i32);
break;
case FMD_TYPE_UINT32:
mdb_printf("%-11p %-4s %-32s %u\n", addr, "ui32",
s.fmds_name, s.fmds_value.i32);
break;
case FMD_TYPE_INT64:
mdb_printf("%-11p %-4s %-32s %lld\n", addr, "i64",
s.fmds_name, s.fmds_value.i64);
break;
case FMD_TYPE_UINT64:
mdb_printf("%-11p %-4s %-32s %llu\n", addr, "ui64",
s.fmds_name, s.fmds_value.ui64);
break;
case FMD_TYPE_STRING:
if (mdb_readstr(buf, sizeof (buf),
(uintptr_t)s.fmds_value.str) < 0) {
(void) mdb_snprintf(buf, sizeof (buf), "<%p>",
s.fmds_value.str);
}
mdb_printf("%-11p %-4s %-32s %s\n", addr, "str",
s.fmds_name, buf);
break;
case FMD_TYPE_TIME:
mdb_printf("%-11p %-4s %-32s %llu\n", addr, "time",
s.fmds_name, s.fmds_value.ui64);
break;
case FMD_TYPE_SIZE:
mdb_printf("%-11p %-4s %-32s %llu\n", addr, "size",
s.fmds_name, s.fmds_value.ui64);
break;
default:
mdb_printf("%-11p %-4u %-32s ???\n", addr,
s.fmds_type, s.fmds_name);
break;
}
return (DCMD_OK);
}
/* ARGSUSED */
static int
module_stat(uintptr_t addr, const void *data, void *wsp)
{
fmd_module_t *modp = (fmd_module_t *)data;
char name[PATH_MAX];
const struct fmd_cmd_data *udp = wsp;
fmd_modstat_t *mod_stats;
if (mdb_readstr(name, sizeof (name), (uintptr_t)modp->mod_name) <= 0) {
(void) mdb_snprintf(name, sizeof (name), "<%p>",
modp->mod_name);
}
mdb_printf("%s\n", name);
mod_stats = modp->mod_stats;
(void) fmd_stat((uintptr_t)&mod_stats->ms_loadtime,
DCMD_ADDRSPEC | DCMD_LOOPFIRST, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_snaptime,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_accepted,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_debugdrop,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_memtotal,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_memlimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_buftotal,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_buflimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_thrtotal,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_thrlimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_doorthrtotal,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_doorthrlimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_caseopen,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_casesolved,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_caseclosed,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_ckpt_save,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_ckpt_restore,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_ckpt_zeroed,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_ckpt_cnt,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_ckpt_time,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_xprtopen,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_xprtlimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
(void) fmd_stat((uintptr_t)&mod_stats->ms_xprtqlimit,
DCMD_ADDRSPEC | DCMD_LOOP, udp->argc, udp->argv);
return (WALK_NEXT);
}
