/*ARGSUSED*/
int
cycid(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av)
{
cyc_id_t id;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("cyclic_id_cache", "cycid", ac, av) == -1) {
mdb_warn("can't walk cyclic_id_cache");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %4s %3s %?s %s\n", "ADDR", "CPU", "NDX",
"CYCLIC", "HANDLER");
}
if (mdb_vread(&id, sizeof (id), addr) == -1) {
mdb_warn("couldn't read cyc_id_t at %p", addr);
return (DCMD_ERR);
}
if (id.cyi_cpu == NULL) {
/*
* This is an omnipresent cyclic.
*/
mdb_printf("%?p %4s %3s %?s %a\n", addr, "omni", "-", "-",
id.cyi_omni_hdlr.cyo_online);
mdb_printf("%?s |\n", "");
mdb_printf("%?s +-->%4s %3s %?s %s\n", "",
"CPU", "NDX", "CYCLIC", "HANDLER");
if (mdb_pwalk("cycomni",
(mdb_walk_cb_t)cycid_walk_omni, NULL, addr) == -1) {
mdb_warn("couldn't walk cycomni for %p", addr);
return (DCMD_ERR);
}
mdb_printf("\n");
return (DCMD_OK);
}
mdb_printf("%?p ", addr);
return (cycid_cpu(id.cyi_cpu, id.cyi_ndx));
}
/*ARGSUSED*/
int
snode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
snode_cbdata_t sd;
struct snode snode;
uintptr_t major = 0, dev = 0;
sd.sd_major = -1;
sd.sd_minor = -1;
sd.sd_verbose = !(flags & DCMD_PIPE_OUT);
if (mdb_getopts(argc, argv,
'm', MDB_OPT_UINTPTR, &major,
'd', MDB_OPT_UINTPTR, &dev, NULL) != argc)
return (DCMD_USAGE);
if (dev != 0) {
sd.sd_major = getmajor(dev);
sd.sd_minor = getminor(dev);
}
if (major != 0)
sd.sd_major = major;
if (DCMD_HDRSPEC(flags) && !(flags & DCMD_PIPE_OUT)) {
mdb_printf("%<u>%?s %?s %6s %16s %-15s%</u>\n",
"ADDR", "VNODE", "COUNT", "DEV", "FLAG");
}
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk("snode", (mdb_walk_cb_t)snode_cb, &sd) == -1) {
mdb_warn("can't walk snodes");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&snode, sizeof (snode), addr) == -1) {
mdb_warn("failed to read snode structure at %p", addr);
return (DCMD_ERR);
}
snode_cb(addr, &snode, &sd);
return (DCMD_OK);
}
/*ARGSUSED*/
int
dof_sec(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
const char *name;
dof_sec_t s;
if (!(flags & DCMD_ADDRSPEC))
mdb_printf("%<u>%-3s ", "NDX");
if (!(flags & DCMD_ADDRSPEC) || DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%?s %-10s %-5s %-5s %-5s %-6s %-5s%</u>\n",
"ADDR", "TYPE", "ALIGN", "FLAGS", "ENTSZ", "OFFSET",
"SIZE");
}
if (!(flags & DCMD_ADDRSPEC)) {
int sec = 0;
if (mdb_walk("dof_sec",
(mdb_walk_cb_t)dof_sec_walk, &sec) == -1) {
mdb_warn("failed to walk dof_sec");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (argc != 0)
return (DCMD_USAGE);
if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) {
mdb_warn("failed to read section header at %p", addr);
return (DCMD_ERR);
}
mdb_printf("%?p ", addr);
if ((name = dof_sec_name(s.dofs_type)) != NULL)
mdb_printf("%-10s ", name);
else
mdb_printf("%-10u ", s.dofs_type);
mdb_printf("%-5u %-#5x %-#5x %-6llx %-#5llx\n", s.dofs_align,
s.dofs_flags, s.dofs_entsize, s.dofs_offset, s.dofs_size);
return (DCMD_OK);
}
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);
}
static int
fcip(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
fcip_port_info_t pinfo;
if (argc != 0) {
return (DCMD_USAGE);
}
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fcip", "fcip",
argc, argv) == -1) {
mdb_warn("failed to walk 'fcip_port_head'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%12s %12s %12s %16s %16s\n",
"FCIP Struct", "Handle", "DIP", "Port WWN", "Node WWN");
/*
* For each port, we just need to read the fc_fca_port_t struct, read
* the port_handle
*/
if (mdb_vread(&pinfo, sizeof (fcip_port_info_t), addr) ==
sizeof (fcip_port_info_t)) {
mdb_printf("%12p %12p %12p %02x%02x%02x%02x%02x%02x%02x%02x "
"%02x%02x%02x%02x%02x%02x%02x%02x\n",
pinfo.fcipp_fcip, pinfo.fcipp_handle, pinfo.fcipp_dip,
pinfo.fcipp_pwwn.raw_wwn[0], pinfo.fcipp_pwwn.raw_wwn[1],
pinfo.fcipp_pwwn.raw_wwn[2], pinfo.fcipp_pwwn.raw_wwn[3],
pinfo.fcipp_pwwn.raw_wwn[4], pinfo.fcipp_pwwn.raw_wwn[5],
pinfo.fcipp_pwwn.raw_wwn[6], pinfo.fcipp_pwwn.raw_wwn[7],
pinfo.fcipp_nwwn.raw_wwn[0], pinfo.fcipp_nwwn.raw_wwn[1],
pinfo.fcipp_nwwn.raw_wwn[2], pinfo.fcipp_nwwn.raw_wwn[3],
pinfo.fcipp_nwwn.raw_wwn[4], pinfo.fcipp_nwwn.raw_wwn[5],
pinfo.fcipp_nwwn.raw_wwn[6], pinfo.fcipp_nwwn.raw_wwn[7]);
} else
mdb_warn("failed to read port info at %p", addr);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
gate_desc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
gate_desc_t gate;
if (argc != 0 || !(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_vread(&gate, sizeof (gate_desc_t), addr) !=
sizeof (gate_desc_t)) {
mdb_warn("failed to read gate descriptor at %p\n", addr);
return (DCMD_ERR);
}
gate_desc_dump(&gate, "", DCMD_HDRSPEC(flags));
return (DCMD_OK);
}
/*ARGSUSED*/
static int
configd_thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
thread_info_t t;
char state[20];
char oldstate[20];
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
argv) == -1) {
mdb_warn("can't walk 'configd_threads'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (argc != 0)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-?s %5s %-12s %-12s %-?s %-?s %-?s%</u>\n",
"ADDR", "TID", "STATE", "PREV_STATE", "CLIENT", "CLIENTRQ",
"MAINREQ");
}
if (mdb_vread(&t, sizeof (t), addr) == -1) {
mdb_warn("failed to read thread_info_t at %p", addr);
return (DCMD_ERR);
}
enum_lookup(state, sizeof (state), thread_state_enum,
t.ti_state, "TI_", "");
make_lower(state, sizeof (state));
enum_lookup(oldstate, sizeof (oldstate), thread_state_enum,
t.ti_prev_state, "TI_", "");
make_lower(oldstate, sizeof (oldstate));
mdb_printf("%0?p %5d %-12s %-12s %?p %?p %?p\n",
(void *)addr, t.ti_thread, state, oldstate,
t.ti_active_client, t.ti_client_request, t.ti_main_door_request);
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);
}
/*
* 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);
}
static int
mac_ring_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
mac_ring_t ring;
mac_group_t group;
flow_entry_t flent;
mac_soft_ring_set_t srs;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("mac_ring", "mac_ring", argc, argv) == -1) {
mdb_warn("failed to walk 'mac_ring'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&ring, sizeof (ring), addr) == -1) {
mdb_warn("failed to read struct mac_ring_s at %p", addr);
return (DCMD_ERR);
}
bzero(&flent, sizeof (flent));
if (mdb_vread(&srs, sizeof (srs), (uintptr_t)ring.mr_srs) != -1) {
(void) mdb_vread(&flent, sizeof (flent),
(uintptr_t)srs.srs_flent);
}
(void) mdb_vread(&group, sizeof (group), (uintptr_t)ring.mr_gh);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%?s %4s %5s %4s %?s "
"%5s %?s %?s %s %</u>\n",
"ADDR", "TYPE", "STATE", "FLAG", "GROUP",
"CLASS", "MIP", "SRS", "FLOW NAME");
}
mdb_printf("%?p %-4s "
"%5s %04x "
"%?p %-5s "
"%?p %?p %s\n",
addr, ((ring.mr_type == 1)? "RX" : "TX"),
mac_ring_state2str(ring.mr_state), ring.mr_flag,
ring.mr_gh, mac_ring_classify2str(ring.mr_classify_type),
group.mrg_mh, ring.mr_srs, flent.fe_flow_name);
return (DCMD_OK);
}
/* ARGSUSED */
int
group(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
group_t group;
int opt_q = 0; /* display only address. */
/* Should provide an address */
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_getopts(argc, argv,
'q', MDB_OPT_SETBITS, TRUE, &opt_q,
NULL) != argc)
return (DCMD_USAGE);
if (flags & DCMD_PIPE_OUT)
opt_q = B_TRUE;
if (DCMD_HDRSPEC(flags) && !opt_q) {
mdb_printf("%?s %6s %9s %?s\n",
"ADDR",
"SIZE",
"CAPACITY",
"SET");
}
if (mdb_vread(&group, sizeof (struct group), addr) == -1) {
mdb_warn("unable to read 'group' at %p", addr);
return (DCMD_ERR);
}
if (opt_q) {
mdb_printf("%0?p\n", addr);
return (DCMD_OK);
}
mdb_printf("%?p %6d %9d %?p\n",
addr, group.grp_size, group.grp_capacity, group.grp_set);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
uutil_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uu_list_t ul;
if (!(flags & DCMD_ADDRSPEC) || argc != 0)
return (DCMD_USAGE);
if (mdb_vread(&ul, sizeof (uu_list_t), addr) == -1) {
mdb_warn("failed to read uu_list\n");
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%-?s %-?s %-?s %6s %5s\n",
"ADDR", "POOL", "PARENT", "NODES", "FLAGS");
mdb_printf("%0?p %0?p %0?p %6u %c%c\n",
addr, ul.ul_pool, UU_PTR_DECODE(ul.ul_parent_enc),
ul.ul_numnodes, ul.ul_sorted ? 'S' : ' ', ul.ul_debug? 'D' : ' ');
return (DCMD_OK);
}
/*
* Print the core TCP-related fields in an NCA nca_conn_t. With the "-t"
* argument, skips all nca_conn_t's that are in the TIME_WAIT state.
*/
static int
nca_tcpconn(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
nca_conn_t conn;
unsigned int show_timewait = TRUE;
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_getopts(argc, argv, 't', MDB_OPT_CLRBITS, TRUE, &show_timewait,
NULL) != argc)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-*s %21s %5s %8s %5s %8s %5s %-9s%</u>\n",
NCA_ADDR_WIDTH, "ADDR", "REMOTE_ADDR", "SWIND", "SUNASEQ",
"SNSEQ", "RACKSEQ", "RNSEQ", "STATE");
}
if (mdb_vread(&conn, sizeof (nca_conn_t), addr) == -1) {
mdb_warn("cannot read nca_conn_t at %p", addr);
return (DCMD_ERR);
}
if (!show_timewait && conn.tcp_state == TCPS_TIME_WAIT)
return (DCMD_OK);
mdb_nhconvert(&conn.conn_fport, &conn.conn_fport, sizeof (in_port_t));
mdb_printf("%0*p %15I:%05hu %5u %08x %+5d %08x %+5d %-9s\n",
NCA_ADDR_WIDTH, addr, conn.faddr, conn.conn_fport, conn.tcp_swnd,
conn.tcp_suna, conn.tcp_snxt - conn.tcp_suna, conn.tcp_rack,
conn.tcp_rnxt - conn.tcp_rack, state2name(conn.tcp_state));
return (DCMD_OK);
}
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);
}
/*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);
}
int
mi(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t opts = 0;
MI_O mio;
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_getopts(argc, argv,
'p', MDB_OPT_SETBITS, MI_PAYLOAD, &opts,
'd', MDB_OPT_SETBITS, MI_DEVICE, &opts,
'm', MDB_OPT_SETBITS, MI_MODULE, &opts,
NULL) != argc)
return (DCMD_USAGE);
if ((opts & (MI_DEVICE | MI_MODULE)) == (MI_DEVICE | MI_MODULE)) {
mdb_warn("at most one filter, d for devices or m "
"for modules, may be specified\n");
return (DCMD_USAGE);
}
if ((opts == 0) && (DCMD_HDRSPEC(flags))) {
mdb_printf("%<u>%-?s %-?s %-?s IsDev Dev%</u>\n",
"MI_O", "Next", "Prev");
}
if (mdb_vread(&mio, sizeof (mio), addr) == -1) {
mdb_warn("failed to read mi object MI_O at %p", addr);
return (DCMD_ERR);
}
if (opts != 0) {
if (mio.mi_o_isdev == B_FALSE) {
/* mio is a module */
if (!(opts & MI_MODULE) && (opts & MI_DEVICE))
return (DCMD_OK);
} else {
/* mio is a device */
if (!(opts & MI_DEVICE) && (opts & MI_MODULE))
return (DCMD_OK);
}
if (opts & MI_PAYLOAD)
mdb_printf("%p\n", addr + sizeof (MI_O));
else
mdb_printf("%p\n", addr);
return (DCMD_OK);
}
mdb_printf("%0?p %0?p %0?p ", addr, mio.mi_o_next, mio.mi_o_prev);
if (mio.mi_o_isdev == B_FALSE)
mdb_printf("FALSE");
else
mdb_printf("TRUE ");
mdb_printf(" %0?p\n", mio.mi_o_dev);
return (DCMD_OK);
}
int
sonode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
const char *optf = NULL;
const char *optt = NULL;
const char *optp = NULL;
int family, type, proto;
int filter = 0;
struct sonode so;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("genunix`sonode", "genunix`sonode", argc,
argv) == -1) {
mdb_warn("failed to walk sonode");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'f', MDB_OPT_STR, &optf,
't', MDB_OPT_STR, &optt,
'p', MDB_OPT_STR, &optp,
NULL) != argc)
return (DCMD_USAGE);
if (optf != NULL) {
if (strcmp("inet", optf) == 0)
family = AF_INET;
else if (strcmp("inet6", optf) == 0)
family = AF_INET6;
else if (strcmp("unix", optf) == 0)
family = AF_UNIX;
else
family = mdb_strtoull(optf);
filter = 1;
}
if (optt != NULL) {
if (strcmp("stream", optt) == 0)
type = SOCK_STREAM;
else if (strcmp("dgram", optt) == 0)
type = SOCK_DGRAM;
else if (strcmp("raw", optt) == 0)
type = SOCK_RAW;
else
type = mdb_strtoull(optt);
filter = 1;
}
if (optp != NULL) {
proto = mdb_strtoull(optp);
filter = 1;
}
if (DCMD_HDRSPEC(flags) && !filter) {
mdb_printf("%<u>%-?s Family Type Proto State Mode Flag "
"AccessVP%</u>\n", "Sonode:");
}
if (mdb_vread(&so, sizeof (so), addr) == -1) {
mdb_warn("failed to read sonode at %p", addr);
return (DCMD_ERR);
}
if ((optf != NULL) && (so.so_family != family))
return (DCMD_OK);
if ((optt != NULL) && (so.so_type != type))
return (DCMD_OK);
if ((optp != NULL) && (so.so_protocol != proto))
return (DCMD_OK);
if (filter) {
mdb_printf("%0?p\n", addr);
return (DCMD_OK);
}
mdb_printf("%0?p ", addr);
switch (so.so_family) {
case AF_UNIX:
mdb_printf("unix ");
break;
case AF_INET:
mdb_printf("inet ");
break;
case AF_INET6:
mdb_printf("inet6 ");
break;
default:
mdb_printf("%6hi", so.so_family);
}
switch (so.so_type) {
case SOCK_STREAM:
mdb_printf(" strm");
break;
case SOCK_DGRAM:
mdb_printf(" dgrm");
break;
case SOCK_RAW:
mdb_printf(" raw ");
break;
default:
mdb_printf(" %4hi", so.so_type);
}
mdb_printf(" %5hi %05x %04x %04hx\n",
so.so_protocol, so.so_state, so.so_mode,
so.so_flag);
return (DCMD_OK);
}
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);
}
static int
request_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
request_log_entry_t cur;
hrtime_t dur;
hrtime_t dursec;
hrtime_t durnsec;
char durstr[20];
char stampstr[20];
char requstr[30];
char respstr[30];
char typestr[30];
uintptr_t node = 0;
uintptr_t client = 0;
uint64_t clientid = 0;
int idx;
int opt_v = FALSE; /* verbose */
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("configd_log", "configd_log", argc,
argv) == -1) {
mdb_warn("can't walk 'configd_log'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'c', MDB_OPT_UINTPTR, &client,
'i', MDB_OPT_UINT64, &clientid,
'n', MDB_OPT_UINTPTR, &node,
'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-?s %-4s %-14s %9s %-22s %-17s\n%</u>",
"ADDR", "THRD", "START", "DURATION", "REQUEST",
"RESPONSE");
}
if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
mdb_warn("couldn't read log entry at %p", addr);
return (DCMD_ERR);
}
/*
* apply filters, if any.
*/
if (clientid != 0 && clientid != cur.rl_clientid)
return (DCMD_OK);
if (client != 0 && client != (uintptr_t)cur.rl_client)
return (DCMD_OK);
if (node != 0) {
for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
if ((uintptr_t)cur.rl_ptrs[idx].rlp_data == node) {
node = 0; /* found it */
break;
}
}
if (node != 0)
return (DCMD_OK);
}
enum_lookup(requstr, sizeof (requstr), request_enum, cur.rl_request,
"REP_PROTOCOL_", "");
if (cur.rl_end != 0) {
enum_lookup(respstr, sizeof (respstr), response_enum,
cur.rl_response, "REP_PROTOCOL_", "FAIL_");
dur = cur.rl_end - cur.rl_start;
dursec = dur / NANOSEC;
durnsec = dur % NANOSEC;
if (dursec <= 9)
mdb_snprintf(durstr, sizeof (durstr),
"%lld.%06lld",
dursec, durnsec / (NANOSEC / MICROSEC));
else if (dursec <= 9999)
mdb_snprintf(durstr, sizeof (durstr),
"%lld.%03lld",
dursec, NSEC2MSEC(durnsec));
else
mdb_snprintf(durstr, sizeof (durstr),
"%lld", dursec);
} else {
(void) strcpy(durstr, "-");
(void) strcpy(respstr, "-");
}
if (max_time_seen != 0 && max_time_seen >= cur.rl_start) {
dur = max_time_seen - cur.rl_start;
dursec = dur / NANOSEC;
durnsec = dur % NANOSEC;
if (dursec <= 99ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%09lld", dursec, durnsec);
else if (dursec <= 99999ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%06lld",
dursec, durnsec / (NANOSEC / MICROSEC));
else if (dursec <= 99999999ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%03lld",
dursec, NSEC2MSEC(durnsec));
else
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld", dursec);
} else {
(void) strcpy(stampstr, "-");
}
mdb_printf("%0?x %4d T%13s %9s %-22s %-17s\n",
addr, cur.rl_tid, stampstr, durstr, requstr, respstr);
if (opt_v) {
mdb_printf("\tclient: %?p (%d)\tptrs: %d\tstamp: %llx\n",
cur.rl_client, cur.rl_clientid, cur.rl_num_ptrs,
cur.rl_start);
for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
enum_lookup(typestr, sizeof (typestr), ptr_type_enum,
cur.rl_ptrs[idx].rlp_type, "RC_PTR_TYPE_", "");
mdb_printf("\t\t%-7s %5d %?p %?p\n", typestr,
cur.rl_ptrs[idx].rlp_id, cur.rl_ptrs[idx].rlp_ptr,
cur.rl_ptrs[idx].rlp_data);
}
mdb_printf("\n");
}
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*/
int
usba_device(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
int status;
char pathname[MAXNAMELEN];
char dname[MODMAXNAMELEN + 1] = "<unatt>"; /* Driver name */
char drv_statep[MODMAXNAMELEN+ 10];
uint_t usb_flag = NULL;
boolean_t no_driver_attached = FALSE;
uintptr_t dip_addr;
struct dev_info devinfo;
if (!(flags & DCMD_ADDRSPEC)) {
/* Global walk */
if (mdb_walk_dcmd("usba_device", "usba_device", argc,
argv) == -1) {
mdb_warn("failed to walk usba_device");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'p', MDB_OPT_SETBITS, USB_DUMP_ACTIVE_PIPES, &usb_flag,
'v', MDB_OPT_SETBITS, USB_DUMP_VERBOSE, &usb_flag, NULL) != argc) {
return (DCMD_USAGE);
}
if (usb_flag && !(DCMD_HDRSPEC(flags))) {
mdb_printf("\n");
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-15s %4s %-?s %-42s%</u>\n",
"NAME", "INST", "DIP", "PATH ");
}
status = usba_device2dip(addr, &dip_addr);
/*
* -1 = error
* 0 = no error, no match
* 1 = no error, match
*/
if (status != 1) {
if (status == -1) {
mdb_warn("error looking for dip for usba_device %p",
addr);
} else {
mdb_warn("failed to find dip for usba_device %p\n",
addr);
}
mdb_warn("dip and statep unobtainable\n");
return (DCMD_ERR);
}
/* Figure out what driver (name) is attached to this node. */
(void) mdb_devinfo2driver(dip_addr, (char *)dname, sizeof (dname));
if (mdb_vread(&devinfo, sizeof (struct dev_info),
dip_addr) == -1) {
mdb_warn("failed to read devinfo");
return (DCMD_ERR);
}
if (!(DDI_CF2(&devinfo))) {
no_driver_attached = TRUE;
}
(void) mdb_ddi_pathname(dip_addr, pathname, sizeof (pathname));
mdb_printf("%-15s %2d %-?p %s\n", dname, devinfo.devi_instance,
dip_addr, pathname);
if (usb_flag & USB_DUMP_VERBOSE) {
int i;
uintptr_t statep = NULL;
char *string_descr;
char **config_cloud, **conf_str_descr;
usb_dev_descr_t usb_dev_descr;
usba_device_t usba_device_struct;
if (mdb_vread(&usba_device_struct,
sizeof (usba_device_t), addr) == -1) {
mdb_warn("failed to read usba_device struct");
return (DCMD_ERR);
}
mdb_printf(" usba_device: %-16p\n\n", (usba_device_t *)addr);
if (mdb_vread(&usb_dev_descr, sizeof (usb_dev_descr),
(uintptr_t)usba_device_struct.usb_dev_descr) == -1) {
mdb_warn("failed to read usb_dev_descr_t struct");
return (DCMD_ERR);
}
mdb_printf("\n idVendor: 0x%04x idProduct: 0x%04x "
"usb_addr: 0x%02x\n", usb_dev_descr.idVendor,
usb_dev_descr.idProduct, usba_device_struct.usb_addr);
/* Get the string descriptor string into local space. */
string_descr = (char *)mdb_alloc(USB_MAXSTRINGLEN, UM_GC);
if (usba_device_struct.usb_mfg_str == NULL) {
(void) strcpy(string_descr, "<No Manufacturer String>");
} else {
if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
(uintptr_t)usba_device_struct.usb_mfg_str) == -1) {
mdb_warn("failed to read manufacturer "
"string descriptor");
(void) strcpy(string_descr, "???");
}
}
mdb_printf("\n Manufacturer String:\t%s\n", string_descr);
if (usba_device_struct.usb_product_str == NULL) {
(void) strcpy(string_descr, "<No Product String>");
} else {
if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
(uintptr_t)usba_device_struct.usb_product_str) ==
-1) {
mdb_warn("failed to read product string "
"descriptor");
(void) strcpy(string_descr, "???");
}
}
mdb_printf(" Product String:\t\t%s\n", string_descr);
if (usba_device_struct.usb_serialno_str == NULL) {
(void) strcpy(string_descr, "<No SerialNumber String>");
} else {
if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
(uintptr_t)usba_device_struct.usb_serialno_str) ==
-1) {
mdb_warn("failed to read serial number string "
"descriptor");
(void) strcpy(string_descr, "???");
}
}
mdb_printf(" SerialNumber String:\t%s\n", string_descr);
if (no_driver_attached) {
mdb_printf("\n");
} else {
mdb_printf(" state_p: ");
/*
* Given the dip, find the associated statep. The
* convention to generate this soft state anchor is:
* <driver_name>_statep
*/
(void) mdb_snprintf(drv_statep, sizeof (drv_statep),
"%s_statep", dname);
if (mdb_devinfo2statep(dip_addr, drv_statep,
&statep) == -1) {
mdb_warn("failed to find %s state struct for "
"dip %p", drv_statep, dip_addr);
return (DCMD_ERR);
}
mdb_printf("%-?p\n", statep);
}
config_cloud = (char **)mdb_alloc(sizeof (void *) *
usba_device_struct.usb_n_cfgs, UM_GC);
conf_str_descr = (char **)mdb_alloc(sizeof (void *) *
usba_device_struct.usb_n_cfgs, UM_GC);
if ((usba_device_struct.usb_cfg_array) &&
(usba_device_struct.usb_cfg_str_descr)) {
if ((mdb_vread(config_cloud, sizeof (void *) *
usba_device_struct.usb_n_cfgs,
(uintptr_t)usba_device_struct.usb_cfg_array) ==
-1) || (mdb_vread(conf_str_descr, sizeof (void *)
* usba_device_struct.usb_n_cfgs, (uintptr_t)
usba_device_struct.usb_cfg_str_descr)) == -1) {
mdb_warn("failed to read config cloud pointers");
} else {
mdb_printf("\n Device Config Clouds:\n"
" Index\tConfig\t\tConfiguration "
"String\n"
" -----\t------\t\t"
"--------------------\n");
for (i = 0; i < usba_device_struct.usb_n_cfgs;
i++) {
if (mdb_readstr(string_descr,
USB_MAXSTRINGLEN,
(uintptr_t)conf_str_descr[i]) ==
-1) {
(void) strcpy(string_descr,
"<No Configuration "
"String>");
}
mdb_printf(" %4d\t0x%p\t%s\n", i,
config_cloud[i], string_descr);
}
}
}
mdb_printf("\n Active configuration index: %d\n",
usba_device_struct.usb_active_cfg_ndx);
}
if (usb_flag & USB_DUMP_ACTIVE_PIPES) {
if (mdb_pwalk_dcmd("usb_pipe_handle", "usb_pipe_handle",
0, NULL, addr) == -1) {
mdb_warn("failed to walk usb_pipe_handle");
return (DCMD_ERR);
}
}
return (DCMD_OK);
}
/*
* dcmd to print sockparams info.
*
* If no address is given then the default is to print all sockparams on the
* global list (i.e., installed with soconfig(1)). To also print the ephemeral
* entries the '-e' flag should be used. Only ephemeral entries can be printed
* by specifying the '-E' flag.
*/
static int
sockparams_prt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
struct sockparams sp;
if ((flags & DCMD_ADDRSPEC) == 0) {
uint_t opt_e = 0;
uint_t opt_E = 0;
/*
* Determine what lists should be printed
*/
if (mdb_getopts(argc, argv,
'e', MDB_OPT_SETBITS, 1, &opt_e,
'E', MDB_OPT_SETBITS, 1, &opt_E) != argc)
return (DCMD_USAGE);
if (!opt_E) {
if (!sockparams_walk_list("sphead", argc, argv))
return (DCMD_ERR);
}
if (opt_e || opt_E) {
if (!sockparams_walk_list("sp_ephem_list", argc, argv))
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* If we are piping the output, then just print out the address,
* otherwise summarize the sockparams info.
*/
if ((flags & DCMD_PIPE_OUT) != 0) {
mdb_printf("%#lr\n", addr);
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%-?s %3s %3s %3s %15s %15s %6s %6s\n",
"ADDR", "FAM", "TYP", "PRO", "STRDEV", "SOCKMOD", "REFS",
"FLGS");
}
if (mdb_vread(&sp, sizeof (sp), addr) == -1) {
mdb_warn("failed to read sockparams at %0?p", addr);
return (DCMD_ERR);
}
mdb_printf("%0?p %3u %3u %3u %15s %15s %6u %#6x\n",
addr,
sp.sp_family, sp.sp_type, sp.sp_protocol,
(sp.sp_sdev_info.sd_devpath != 0) ?
sp.sp_sdev_info.sd_devpath : "-",
sp.sp_smod_name, sp.sp_refcnt,
sp.sp_flags);
return (DCMD_OK);
}
static int
mac_srs_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t args = MAC_SRS_NONE;
mac_soft_ring_set_t srs;
mac_client_impl_t mci;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("mac_srs", "mac_srs", argc, argv) == -1) {
mdb_warn("failed to walk 'mac_srs'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'r', MDB_OPT_SETBITS, MAC_SRS_RX, &args,
't', MDB_OPT_SETBITS, MAC_SRS_TX, &args,
'c', MDB_OPT_SETBITS, MAC_SRS_CPU, &args,
'v', MDB_OPT_SETBITS, MAC_SRS_VERBOSE, &args,
'i', MDB_OPT_SETBITS, MAC_SRS_INTR, &args,
's', MDB_OPT_SETBITS, MAC_SRS_STAT, &args,
NULL) != argc) {
return (DCMD_USAGE);
}
if (argc > 2)
return (DCMD_USAGE);
if (mdb_vread(&srs, sizeof (srs), addr) == -1) {
mdb_warn("failed to read struct mac_soft_ring_set_s at %p",
addr);
return (DCMD_ERR);
}
if (mdb_vread(&mci, sizeof (mci), (uintptr_t)srs.srs_mcip) == -1) {
mdb_warn("failed to read struct mac_client_impl_t at %p "
"for SRS %p", srs.srs_mcip, addr);
return (DCMD_ERR);
}
switch (args) {
case MAC_SRS_RX: {
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-20s %-8s %-8s %8s "
"%8s %3s\n",
"", "", "", "", "MBLK",
"Q", "SR");
mdb_printf("%<u>%?s %-20s %-8s %-8s %8s "
"%8s %3s%</u>\n",
"ADDR", "LINK_NAME", "STATE", "TYPE", "CNT",
"BYTES", "CNT");
}
if (srs.srs_type & SRST_TX)
return (DCMD_OK);
mdb_printf("%?p %-20s %08x %08x "
"%8d %8d %3d\n",
addr, mci.mci_name, srs.srs_state, srs.srs_type,
srs.srs_count, srs.srs_size, srs.srs_soft_ring_count);
break;
}
case MAC_SRS_TX: {
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-16s %-4s %-8s "
"%-8s %8s %8s %3s\n",
"", "", "TX", "",
"", "MBLK", "Q", "SR");
mdb_printf("%<u>%?s %-16s %-4s %-8s "
"%-8s %8s %8s %3s%</u>\n",
"ADDR", "LINK_NAME", "MODE", "STATE",
"TYPE", "CNT", "BYTES", "CNT");
}
if (!(srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-16s %-4s "
"%08x %08x %8d %8d %3d\n",
addr, mci.mci_name, mac_srs_txmode2str(srs.srs_tx.st_mode),
srs.srs_state, srs.srs_type, srs.srs_count, srs.srs_size,
srs.srs_tx_ring_count);
break;
}
case MAC_SRS_RXCPU: {
mac_cpus_t mc = srs.srs_cpu;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-20s %-4s %-4s "
"%-6s %-4s %-7s\n",
"", "", "NUM", "POLL",
"WORKER", "INTR", "FANOUT");
mdb_printf("%<u>%?s %-20s %-4s %-4s "
"%-6s %-4s %-7s%</u>\n",
"ADDR", "LINK_NAME", "CPUS", "CPU",
"CPU", "CPU", "CPU_CNT");
}
if ((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-20s %-4d %-4d "
"%-6d %-4d %-7d\n",
addr, mci.mci_name, mc.mc_ncpus, mc.mc_rx_pollid,
mc.mc_rx_workerid, mc.mc_rx_intr_cpu, mc.mc_rx_fanout_cnt);
break;
}
case MAC_SRS_TXCPU: {
mac_cpus_t mc = srs.srs_cpu;
mac_soft_ring_t *s_ringp, s_ring;
boolean_t first = B_TRUE;
int i;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-12s %?s %8s %8s %8s\n",
"", "", "SOFT", "WORKER", "INTR", "RETARGETED");
mdb_printf("%<u>%?s %-12s %?s %8s %8s %8s%</u>\n",
"ADDR", "LINK_NAME", "RING", "CPU", "CPU", "CPU");
}
if (!(srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-12s ", addr, mci.mci_name);
/*
* Case of no soft rings, print the info from
* mac_srs_tx_t.
*/
if (srs.srs_tx_ring_count == 0) {
mdb_printf("%?p %8d %8d %8d\n",
0, mc.mc_tx_fanout_cpus[0],
mc.mc_tx_intr_cpu[0],
mc.mc_tx_retargeted_cpu[0]);
break;
}
for (s_ringp = srs.srs_soft_ring_head, i = 0; s_ringp != NULL;
s_ringp = s_ring.s_ring_next, i++) {
(void) mdb_vread(&s_ring, sizeof (s_ring),
(uintptr_t)s_ringp);
if (first) {
mdb_printf("%?p %8d %8d %8d\n",
s_ringp, mc.mc_tx_fanout_cpus[i],
mc.mc_tx_intr_cpu[i],
mc.mc_tx_retargeted_cpu[i]);
first = B_FALSE;
continue;
}
mdb_printf("%?s %-12s %?p %8d %8d %8d\n",
"", "", s_ringp, mc.mc_tx_fanout_cpus[i],
mc.mc_tx_intr_cpu[i], mc.mc_tx_retargeted_cpu[i]);
}
break;
}
case MAC_SRS_TXINTR: {
mac_cpus_t mc = srs.srs_cpu;
mac_soft_ring_t *s_ringp, s_ring;
mac_ring_t *m_ringp, m_ring;
boolean_t first = B_TRUE;
int i;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-12s %?s %8s %?s %6s %6s\n",
"", "", "SOFT", "WORKER", "MAC", "", "INTR");
mdb_printf("%<u>%?s %-12s %?s %8s %?s %6s %6s%</u>\n",
"ADDR", "LINK_NAME", "RING", "CPU", "RING",
"SHARED", "CPU");
}
if (!(srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-12s ", addr, mci.mci_name);
/*
* Case of no soft rings, print the info from
* mac_srs_tx_t.
*/
if (srs.srs_tx_ring_count == 0) {
m_ringp = srs.srs_tx.st_arg2;
if (m_ringp != NULL) {
(void) mdb_vread(&m_ring, sizeof (m_ring),
(uintptr_t)m_ringp);
mdb_printf("%?p %8d %?p %6d %6d\n",
0, mc.mc_tx_fanout_cpus[0], m_ringp,
m_ring.mr_info.mri_intr.mi_ddi_shared,
mc.mc_tx_retargeted_cpu[0]);
} else {
mdb_printf("%?p %8d %?p %6d %6d\n",
0, mc.mc_tx_fanout_cpus[0], 0,
0, mc.mc_tx_retargeted_cpu[0]);
}
break;
}
for (s_ringp = srs.srs_soft_ring_head, i = 0; s_ringp != NULL;
s_ringp = s_ring.s_ring_next, i++) {
(void) mdb_vread(&s_ring, sizeof (s_ring),
(uintptr_t)s_ringp);
m_ringp = s_ring.s_ring_tx_arg2;
(void) mdb_vread(&m_ring, sizeof (m_ring),
(uintptr_t)m_ringp);
if (first) {
mdb_printf("%?p %8d %?p %6d %6d\n",
s_ringp, mc.mc_tx_fanout_cpus[i],
m_ringp,
m_ring.mr_info.mri_intr.mi_ddi_shared,
mc.mc_tx_retargeted_cpu[i]);
first = B_FALSE;
continue;
}
mdb_printf("%?s %-12s %?p %8d %?p %6d %6d\n",
"", "", s_ringp, mc.mc_tx_fanout_cpus[i],
m_ringp, m_ring.mr_info.mri_intr.mi_ddi_shared,
mc.mc_tx_retargeted_cpu[i]);
}
break;
}
case MAC_SRS_RXINTR: {
mac_cpus_t mc = srs.srs_cpu;
mac_ring_t *m_ringp, m_ring;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-12s %?s %8s %6s %6s\n",
"", "", "MAC", "", "POLL", "INTR");
mdb_printf("%<u>%?s %-12s %?s %8s %6s %6s%</u>\n",
"ADDR", "LINK_NAME", "RING", "SHARED", "CPU",
"CPU");
}
if ((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-12s ", addr, mci.mci_name);
m_ringp = srs.srs_ring;
if (m_ringp != NULL) {
(void) mdb_vread(&m_ring, sizeof (m_ring),
(uintptr_t)m_ringp);
mdb_printf("%?p %8d %6d %6d\n",
m_ringp, m_ring.mr_info.mri_intr.mi_ddi_shared,
mc.mc_rx_pollid, mc.mc_rx_intr_cpu);
} else {
mdb_printf("%?p %8d %6d %6d\n",
0, 0, mc.mc_rx_pollid, mc.mc_rx_intr_cpu);
}
break;
}
case MAC_SRS_RXCPUVERBOSE:
case MAC_SRS_TXCPUVERBOSE: {
mac_cpus_t mc = srs.srs_cpu;
int cpu_index = 0, fanout_index = 0, len = 0;
boolean_t cpu_done = B_FALSE, fanout_done = B_FALSE;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-20s %-20s %-20s\n",
"", "", "CPU_COUNT", "FANOUT_CPU_COUNT");
mdb_printf("%<u>%?s %-20s "
"%-20s %-20s%</u>\n",
"ADDR", "LINK_NAME",
"(CPU_LIST)", "(CPU_LIST)");
}
if (((args & MAC_SRS_TX) && !(srs.srs_type & SRST_TX)) ||
((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX)))
return (DCMD_OK);
mdb_printf("%?p %-20s %-20d %-20d\n", addr, mci.mci_name,
mc.mc_ncpus, mc.mc_rx_fanout_cnt);
if (mc.mc_ncpus == 0 && mc.mc_rx_fanout_cnt == 0)
break;
/* print all cpus and cpus for soft rings */
while (!cpu_done || !fanout_done) {
boolean_t old_value = cpu_done;
if (!cpu_done) {
mdb_printf("%?s %20s ", "", "");
cpu_done = mac_srs_print_cpu(&cpu_index,
mc.mc_ncpus, mc.mc_cpus, &len);
}
if (!fanout_done) {
if (old_value)
mdb_printf("%?s %-40s", "", "");
else
mdb_printf("%*s", len, "");
fanout_done = mac_srs_print_cpu(&fanout_index,
mc.mc_rx_fanout_cnt,
mc.mc_rx_fanout_cpus, NULL);
}
mdb_printf("\n");
}
break;
}
case MAC_SRS_RXSTAT: {
mac_rx_stats_t *mac_rx_stat = &srs.srs_rx.sr_stat;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-16s %8s %8s "
"%8s %8s %8s\n",
"", "", "INTR", "POLL",
"CHAIN", "CHAIN", "CHAIN");
mdb_printf("%<u>%?s %-16s %8s %8s "
"%8s %8s %8s%</u>\n",
"ADDR", "LINK_NAME", "COUNT", "COUNT",
"<10", "10-50", ">50");
}
if (srs.srs_type & SRST_TX)
return (DCMD_OK);
mdb_printf("%?p %-16s %8d "
"%8d %8d "
"%8d %8d\n",
addr, mci.mci_name, mac_rx_stat->mrs_intrcnt,
mac_rx_stat->mrs_pollcnt, mac_rx_stat->mrs_chaincntundr10,
mac_rx_stat->mrs_chaincnt10to50,
mac_rx_stat->mrs_chaincntover50);
break;
}
case MAC_SRS_TXSTAT: {
mac_tx_stats_t *mac_tx_stat = &srs.srs_tx.st_stat;
mac_soft_ring_t *s_ringp, s_ring;
boolean_t first = B_TRUE;
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%?s %-20s %?s %8s %8s %8s\n",
"", "", "SOFT", "DROP", "BLOCK", "UNBLOCK");
mdb_printf("%<u>%?s %-20s %?s %8s %8s %8s%</u>\n",
"ADDR", "LINK_NAME", "RING", "COUNT", "COUNT",
"COUNT");
}
if (!(srs.srs_type & SRST_TX))
return (DCMD_OK);
mdb_printf("%?p %-20s ", addr, mci.mci_name);
/*
* Case of no soft rings, print the info from
* mac_srs_tx_t.
*/
if (srs.srs_tx_ring_count == 0) {
mdb_printf("%?p %8d %8d %8d\n",
0, mac_tx_stat->mts_sdrops,
mac_tx_stat->mts_blockcnt,
mac_tx_stat->mts_unblockcnt);
break;
}
for (s_ringp = srs.srs_soft_ring_head; s_ringp != NULL;
s_ringp = s_ring.s_ring_next) {
(void) mdb_vread(&s_ring, sizeof (s_ring),
(uintptr_t)s_ringp);
mac_tx_stat = &s_ring.s_st_stat;
if (first) {
mdb_printf("%?p %8d %8d %8d\n",
s_ringp, mac_tx_stat->mts_sdrops,
mac_tx_stat->mts_blockcnt,
mac_tx_stat->mts_unblockcnt);
first = B_FALSE;
continue;
}
mdb_printf("%?s %-20s %?p %8d %8d %8d\n",
"", "", s_ringp, mac_tx_stat->mts_sdrops,
mac_tx_stat->mts_blockcnt,
mac_tx_stat->mts_unblockcnt);
}
break;
}
case MAC_SRS_NONE: {
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%?s %-20s %?s %?s %-3s%</u>\n",
"ADDR", "LINK_NAME", "FLENT", "HW RING", "DIR");
}
mdb_printf("%?p %-20s %?p %?p "
"%-3s ",
addr, mci.mci_name, srs.srs_flent, srs.srs_ring,
(srs.srs_type & SRST_TX ? "TX" : "RX"));
break;
}
default:
return (DCMD_USAGE);
}
return (DCMD_OK);
}
/*
* Display selected fields of the flow_entry_t structure
*/
static int
mac_flow_dcmd_output(uintptr_t addr, uint_t flags, uint_t args)
{
static const mdb_bitmask_t flow_type_bits[] = {
{"P", FLOW_PRIMARY_MAC, FLOW_PRIMARY_MAC},
{"V", FLOW_VNIC_MAC, FLOW_VNIC_MAC},
{"M", FLOW_MCAST, FLOW_MCAST},
{"O", FLOW_OTHER, FLOW_OTHER},
{"U", FLOW_USER, FLOW_USER},
{"V", FLOW_VNIC, FLOW_VNIC},
{"NS", FLOW_NO_STATS, FLOW_NO_STATS},
{ NULL, 0, 0 }
};
#define FLOW_MAX_TYPE (sizeof (flow_type_bits) / sizeof (mdb_bitmask_t))
static const mdb_bitmask_t flow_flag_bits[] = {
{"Q", FE_QUIESCE, FE_QUIESCE},
{"W", FE_WAITER, FE_WAITER},
{"T", FE_FLOW_TAB, FE_FLOW_TAB},
{"G", FE_G_FLOW_HASH, FE_G_FLOW_HASH},
{"I", FE_INCIPIENT, FE_INCIPIENT},
{"C", FE_CONDEMNED, FE_CONDEMNED},
{"NU", FE_UF_NO_DATAPATH, FE_UF_NO_DATAPATH},
{"NC", FE_MC_NO_DATAPATH, FE_MC_NO_DATAPATH},
{ NULL, 0, 0 }
};
#define FLOW_MAX_FLAGS (sizeof (flow_flag_bits) / sizeof (mdb_bitmask_t))
flow_entry_t fe;
mac_client_impl_t mcip;
mac_impl_t mip;
if (mdb_vread(&fe, sizeof (fe), addr) == -1) {
mdb_warn("failed to read struct flow_entry_s at %p", addr);
return (DCMD_ERR);
}
if (args & MAC_FLOW_USER) {
args &= ~MAC_FLOW_USER;
if (fe.fe_type & FLOW_MCAST) {
if (DCMD_HDRSPEC(flags))
mac_flow_print_header(args);
return (DCMD_OK);
}
}
if (DCMD_HDRSPEC(flags))
mac_flow_print_header(args);
bzero(&mcip, sizeof (mcip));
bzero(&mip, sizeof (mip));
if (fe.fe_mcip != NULL && mdb_vread(&mcip, sizeof (mcip),
(uintptr_t)fe.fe_mcip) == sizeof (mcip)) {
(void) mdb_vread(&mip, sizeof (mip), (uintptr_t)mcip.mci_mip);
}
switch (args) {
case MAC_FLOW_NONE: {
mdb_printf("%?p %-20s %4d %?p "
"%?p %-16s\n",
addr, fe.fe_flow_name, fe.fe_link_id, fe.fe_mcip,
mcip.mci_mip, mip.mi_name);
break;
}
case MAC_FLOW_ATTR: {
struct in_addr in4;
uintptr_t desc_addr;
flow_desc_t fdesc;
desc_addr = addr + OFFSETOF(flow_entry_t, fe_flow_desc);
if (mdb_vread(&fdesc, sizeof (fdesc), desc_addr) == -1) {
mdb_warn("failed to read struct flow_description at %p",
desc_addr);
return (DCMD_ERR);
}
mdb_printf("%?p %-32s "
"%-7s %6d "
"%4d:%-4d ",
addr, fe.fe_flow_name,
mac_flow_proto2str(fdesc.fd_protocol), fdesc.fd_local_port,
fdesc.fd_dsfield, fdesc.fd_dsfield_mask);
if (fdesc.fd_ipversion == IPV4_VERSION) {
IN6_V4MAPPED_TO_INADDR(&fdesc.fd_local_addr, &in4);
mdb_printf("%I", in4.s_addr);
} else if (fdesc.fd_ipversion == IPV6_VERSION) {
mdb_printf("%N", &fdesc.fd_local_addr);
} else {
mdb_printf("%s", "--");
}
mdb_printf("\n");
break;
}
case MAC_FLOW_PROP: {
uintptr_t prop_addr;
char bwstr[STRSIZE];
mac_resource_props_t fprop;
prop_addr = addr + OFFSETOF(flow_entry_t, fe_resource_props);
if (mdb_vread(&fprop, sizeof (fprop), prop_addr) == -1) {
mdb_warn("failed to read struct mac_resoource_props "
"at %p", prop_addr);
return (DCMD_ERR);
}
mdb_printf("%?p %-32s "
"%8s %9s\n",
addr, fe.fe_flow_name,
mac_flow_bw2str(fprop.mrp_maxbw, bwstr, STRSIZE),
mac_flow_priority2str(fprop.mrp_priority));
break;
}
case MAC_FLOW_MISC: {
char flow_flags[2 * FLOW_MAX_FLAGS];
char flow_type[2 * FLOW_MAX_TYPE];
GElf_Sym sym;
char func_name[MDB_SYM_NAMLEN] = "";
uintptr_t func, match_addr;
match_addr = addr + OFFSETOF(flow_entry_t, fe_match);
(void) mdb_vread(&func, sizeof (func), match_addr);
(void) mdb_lookup_by_addr(func, MDB_SYM_EXACT, func_name,
MDB_SYM_NAMLEN, &sym);
mdb_snprintf(flow_flags, 2 * FLOW_MAX_FLAGS, "%hb",
fe.fe_flags, flow_flag_bits);
mdb_snprintf(flow_type, 2 * FLOW_MAX_TYPE, "%hb",
fe.fe_type, flow_type_bits);
mdb_printf("%?p %-24s %10s %10s %20s\n",
addr, fe.fe_flow_name, flow_type, flow_flags, func_name);
break;
}
case MAC_FLOW_RX: {
uintptr_t rxaddr, rx_srs[MAX_RINGS_PER_GROUP] = {0};
int i;
rxaddr = addr + OFFSETOF(flow_entry_t, fe_rx_srs);
(void) mdb_vread(rx_srs, MAC_RX_SRS_SIZE, rxaddr);
mdb_printf("%?p %-24s %3d ",
addr, fe.fe_flow_name, fe.fe_rx_srs_cnt);
for (i = 0; i < MAX_RINGS_PER_GROUP; i++) {
if (rx_srs[i] == 0)
continue;
mdb_printf("%p ", rx_srs[i]);
}
mdb_printf("\n");
break;
}
case MAC_FLOW_TX: {
uintptr_t tx_srs = 0, txaddr;
txaddr = addr + OFFSETOF(flow_entry_t, fe_tx_srs);
(void) mdb_vread(&tx_srs, sizeof (uintptr_t), txaddr);
mdb_printf("%?p %-32s %?p\n",
addr, fe.fe_flow_name, fe.fe_tx_srs);
break;
}
case MAC_FLOW_STATS: {
uint64_t totibytes = 0;
uint64_t totobytes = 0;
mac_soft_ring_set_t *mac_srs;
mac_rx_stats_t mac_rx_stat;
mac_tx_stats_t mac_tx_stat;
int i;
/*
* Sum bytes for all Rx SRS.
*/
for (i = 0; i < fe.fe_rx_srs_cnt; i++) {
mac_srs = (mac_soft_ring_set_t *)(fe.fe_rx_srs[i]);
if (mdb_vread(&mac_rx_stat, sizeof (mac_rx_stats_t),
(uintptr_t)&mac_srs->srs_rx.sr_stat) == -1) {
mdb_warn("failed to read mac_rx_stats_t at %p",
&mac_srs->srs_rx.sr_stat);
return (DCMD_ERR);
}
totibytes += mac_rx_stat.mrs_intrbytes +
mac_rx_stat.mrs_pollbytes +
mac_rx_stat.mrs_lclbytes;
}
/*
* Sum bytes for Tx SRS.
*/
mac_srs = (mac_soft_ring_set_t *)(fe.fe_tx_srs);
if (mac_srs != NULL) {
if (mdb_vread(&mac_tx_stat, sizeof (mac_tx_stats_t),
(uintptr_t)&mac_srs->srs_tx.st_stat) == -1) {
mdb_warn("failed to read max_tx_stats_t at %p",
&mac_srs->srs_tx.st_stat);
return (DCMD_ERR);
}
totobytes = mac_tx_stat.mts_obytes;
}
mdb_printf("%?p %-32s %16llu %16llu\n",
addr, fe.fe_flow_name, totibytes, totobytes);
break;
}
}
return (DCMD_OK);
}
static int
fmd_xprt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t opt_s = FALSE, opt_l = FALSE, opt_r = FALSE, opt_u = FALSE;
fmd_xprt_impl_t xi;
if (mdb_getopts(argc, argv,
'l', MDB_OPT_SETBITS, TRUE, &opt_l,
'r', MDB_OPT_SETBITS, TRUE, &opt_r,
's', MDB_OPT_SETBITS, TRUE, &opt_s,
'u', MDB_OPT_SETBITS, TRUE, &opt_u, NULL) != argc)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_xprt", "fmd_xprt", argc, argv) != 0) {
mdb_warn("failed to walk fmd_xprt");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&xi, sizeof (xi), addr) != sizeof (xi)) {
mdb_warn("failed to read fmd_xprt at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-8s %-4s %-4s %-5s %s%</u>\n",
"ADDR", "ID", "VERS", "FLAGS", "STATE");
}
mdb_printf("%-8p %-4d %-4u %-5x %a\n",
addr, xi.xi_id, xi.xi_version, xi.xi_flags, xi.xi_state);
if (opt_l | opt_s) {
(void) mdb_inc_indent(4);
mdb_printf("Local subscriptions requested by peer:\n");
mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
addr + OFFSETOF(fmd_xprt_impl_t, xi_lsub));
(void) mdb_dec_indent(4);
}
if (opt_r | opt_s) {
(void) mdb_inc_indent(4);
mdb_printf("Remote subscriptions requested of peer:\n");
mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
addr + OFFSETOF(fmd_xprt_impl_t, xi_rsub));
(void) mdb_dec_indent(4);
}
if (opt_u | opt_s) {
(void) mdb_inc_indent(4);
mdb_printf("Pending unsubscription acknowledgements:\n");
mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
addr + OFFSETOF(fmd_xprt_impl_t, xi_usub));
(void) mdb_dec_indent(4);
}
return (DCMD_OK);
}
int
cycinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
cyc_cpu_t cpu;
cpu_t c;
cyc_index_t root, i, *heap;
size_t hsize;
cyclic_t *cyc;
uintptr_t caddr;
uint_t verbose = FALSE, Verbose = FALSE;
int header = 0;
cyc_level_t lev;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("cyccpu", "cycinfo", argc, argv) == -1) {
mdb_warn("can't walk 'cyccpu'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'v', MDB_OPT_SETBITS, TRUE, &verbose,
'V', MDB_OPT_SETBITS, TRUE, &Verbose, NULL) != argc)
return (DCMD_USAGE);
if (!DCMD_HDRSPEC(flags) && (verbose || Verbose))
mdb_printf("\n\n");
if (DCMD_HDRSPEC(flags) || verbose || Verbose)
mdb_printf("%3s %*s %7s %6s %*s %15s %s\n", "CPU",
CYC_ADDR_WIDTH, "CYC_CPU", "STATE", "NELEMS",
CYC_ADDR_WIDTH, "ROOT", "FIRE", "HANDLER");
if (mdb_vread(&cpu, sizeof (cpu), addr) == -1) {
mdb_warn("couldn't read cyc_cpu at %p", addr);
return (DCMD_ERR);
}
if (mdb_vread(&c, sizeof (c), (uintptr_t)cpu.cyp_cpu) == -1) {
mdb_warn("couldn't read cpu at %p", cpu.cyp_cpu);
return (DCMD_ERR);
}
cyc = mdb_alloc(sizeof (cyclic_t) * cpu.cyp_size, UM_SLEEP | UM_GC);
caddr = (uintptr_t)cpu.cyp_cyclics;
if (mdb_vread(cyc, sizeof (cyclic_t) * cpu.cyp_size, caddr) == -1) {
mdb_warn("couldn't read cyclic at %p", caddr);
return (DCMD_ERR);
}
hsize = sizeof (cyc_index_t) * cpu.cyp_size;
heap = mdb_alloc(hsize, UM_SLEEP | UM_GC);
if (mdb_vread(heap, hsize, (uintptr_t)cpu.cyp_heap) == -1) {
mdb_warn("couldn't read heap at %p", cpu.cyp_heap);
return (DCMD_ERR);
}
root = heap[0];
mdb_printf("%3d %0*p %7s %6d ", c.cpu_id, CYC_ADDR_WIDTH, addr,
cpu.cyp_state == CYS_ONLINE ? "online" :
cpu.cyp_state == CYS_OFFLINE ? "offline" :
cpu.cyp_state == CYS_EXPANDING ? "expand" :
cpu.cyp_state == CYS_REMOVING ? "remove" :
cpu.cyp_state == CYS_SUSPENDED ? "suspend" : "????",
cpu.cyp_nelems);
if (cpu.cyp_nelems > 0)
mdb_printf("%0*p %15llx %a\n", CYC_ADDR_WIDTH,
caddr, cyc[root].cy_expire, cyc[root].cy_handler);
else
mdb_printf("%*s %15s %s\n", CYC_ADDR_WIDTH, "-", "-", "-");
if (!verbose && !Verbose)
return (DCMD_OK);
mdb_printf("\n");
cyclic_pretty_dump(&cpu);
mdb_inc_indent(2);
for (i = 0; i < cpu.cyp_size; i++) {
int j;
for (j = 0; j < cpu.cyp_size; j++) {
if (heap[j] == i)
break;
}
if (!Verbose && j >= cpu.cyp_nelems)
continue;
if (!header) {
header = 1;
mdb_printf("\n%*s %3s %4s %4s %5s %15s %7s %s\n",
CYC_ADDR_WIDTH, "ADDR", "NDX", "HEAP", "LEVL",
"PEND", "FIRE", "USECINT", "HANDLER");
}
mdb_printf("%0*p %3d ", CYC_ADDR_WIDTH,
caddr + i * sizeof (cyclic_t), i);
mdb_printf("%4d ", j);
if (j >= cpu.cyp_nelems) {
mdb_printf("%4s %5s %15s %7s %s\n", "-", "-",
"-", "-", "-");
continue;
}
mdb_printf("%4s %5d %15llx ",
cyc[i].cy_level == CY_HIGH_LEVEL ? "high" :
cyc[i].cy_level == CY_LOCK_LEVEL ? "lock" :
cyc[i].cy_level == CY_LOW_LEVEL ? "low" : "????",
cyc[i].cy_pend, cyc[i].cy_expire);
if (cyc[i].cy_interval + cyc[i].cy_expire != INT64_MAX)
mdb_printf("%7lld ", cyc[i].cy_interval /
(uint64_t)(NANOSEC / MICROSEC));
else
mdb_printf("%7s ", "-");
mdb_printf("%a\n", cyc[i].cy_handler);
}
if (!Verbose)
goto out;
for (lev = CY_LOW_LEVEL; lev < CY_LOW_LEVEL + CY_SOFT_LEVELS; lev++) {
cyc_softbuf_t *softbuf = &cpu.cyp_softbuf[lev];
char which = softbuf->cys_hard, shared = 1;
cyc_pcbuffer_t *pc;
size_t bufsiz;
cyc_index_t *buf;
if (softbuf->cys_hard != softbuf->cys_soft)
shared = 0;
again:
pc = &softbuf->cys_buf[which];
bufsiz = (pc->cypc_sizemask + 1) * sizeof (cyc_index_t);
buf = mdb_alloc(bufsiz, UM_SLEEP | UM_GC);
if (mdb_vread(buf, bufsiz, (uintptr_t)pc->cypc_buf) == -1) {
mdb_warn("couldn't read cypc_buf at %p", pc->cypc_buf);
continue;
}
mdb_printf("\n%3s %4s %4s %4s %*s %4s %*s\n", "CPU",
"LEVL", "USER", "NDX", CYC_ADDR_WIDTH, "ADDR", "CYC",
CYC_ADDR_WIDTH, "CYC_ADDR", "PEND");
for (i = 0; i <= pc->cypc_sizemask &&
i <= pc->cypc_prodndx; i++) {
uintptr_t cyc_addr = caddr + buf[i] * sizeof (cyclic_t);
mdb_printf("%3d %4s %4s ", c.cpu_id,
lev == CY_HIGH_LEVEL ? "high" :
lev == CY_LOCK_LEVEL ? "lock" :
lev == CY_LOW_LEVEL ? "low" : "????",
shared ? "shrd" : which == softbuf->cys_hard ?
"hard" : "soft");
mdb_printf("%4d %0*p ", i, CYC_ADDR_WIDTH,
(uintptr_t)&buf[i] - (uintptr_t)&buf[0] +
(uintptr_t)pc->cypc_buf, buf[i],
caddr + buf[i] * sizeof (cyclic_t));
if (i >= pc->cypc_prodndx)
mdb_printf("%4s %*s %5s ",
"-", CYC_ADDR_WIDTH, "-", "-");
else {
cyclic_t c;
if (mdb_vread(&c, sizeof (c), cyc_addr) == -1) {
mdb_warn("\ncouldn't read cyclic at "
"%p", cyc_addr);
continue;
}
mdb_printf("%4d %0*p %5d ", buf[i],
CYC_ADDR_WIDTH, cyc_addr, c.cy_pend);
}
if (i == (pc->cypc_consndx & pc->cypc_sizemask)) {
mdb_printf("<-- consndx");
if (i == (pc->cypc_prodndx & pc->cypc_sizemask))
mdb_printf(",prodndx");
mdb_printf("\n");
continue;
}
if (i == (pc->cypc_prodndx & pc->cypc_sizemask)) {
mdb_printf("<-- prodndx\n");
continue;
}
mdb_printf("\n");
if (i >= pc->cypc_prodndx)
break;
}
if (!shared && which == softbuf->cys_hard) {
which = softbuf->cys_soft;
goto again;
}
}
out:
mdb_dec_indent(2);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
fmd_event(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char type[16], name[16];
fmd_event_impl_t ev;
if (argc != 0)
return (DCMD_USAGE);
if (mdb_vread(&ev, sizeof (ev), addr) != sizeof (ev)) {
mdb_warn("failed to read fmd_event at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-4s %-5s %-3s %-?s%</u>\n",
"ADDR", "TYPE", "STATE", "REF", "NVPAIR");
}
switch (ev.ev_type) {
case FMD_EVT_PROTOCOL:
(void) strcpy(type, "PROT");
break;
case FMD_EVT_GC:
(void) strcpy(type, "GC");
break;
case FMD_EVT_CLOSE:
(void) strcpy(type, "CLSE");
break;
case FMD_EVT_TIMEOUT:
(void) strcpy(type, "TIME");
break;
case FMD_EVT_STATS:
(void) strcpy(type, "STAT");
break;
case FMD_EVT_PUBLISH:
(void) strcpy(type, "PUBL");
break;
case FMD_EVT_TOPO:
(void) strcpy(type, "TOPO");
break;
default:
(void) mdb_snprintf(type, sizeof (type), "%u", ev.ev_type);
}
switch (ev.ev_state) {
case FMD_EVS_RECEIVED:
(void) strcpy(name, "RECVD");
break;
case FMD_EVS_ACCEPTED:
(void) strcpy(name, "ACCPT");
break;
case FMD_EVS_DISCARDED:
(void) strcpy(name, "DSCRD");
break;
case FMD_EVS_DIAGNOSED:
(void) strcpy(name, "DIAGN");
break;
default:
(void) mdb_snprintf(name, sizeof (name), "%u", ev.ev_state);
}
mdb_printf("%-11p %-4s %-5s %-3u %p\n",
addr, type, name, ev.ev_refs, ev.ev_nvl);
return (DCMD_OK);
}
int
sysevent_buf(uintptr_t addr, uint_t flags, uint_t opt_flags)
{
sysevent_hdr_t evh;
sysevent_impl_t *ev;
int size;
if (DCMD_HDRSPEC(flags)) {
if ((opt_flags & SYSEVENT_VERBOSE) == 0) {
mdb_printf("%<u>%-?s %-16s %-9s %-10s "
"%-?s%</u>\n", "ADDRESS", "SEQUENCE ID",
"CLASS", "SUBCLASS", "NVPAIR BUF ADDR");
}
}
/*
* Read in the sysevent buffer header first. After extracting
* the size of the buffer, re-read the buffer in its entirety.
*/
if (mdb_vread(&evh, sizeof (sysevent_hdr_t), addr) == -1) {
mdb_warn("failed to read event header at %p", addr);
return (DCMD_ERR);
}
size = SE_SIZE((sysevent_impl_t *)&evh);
ev = mdb_alloc(size, UM_SLEEP | UM_GC);
if (mdb_vread(ev, size, addr) == -1) {
mdb_warn("can not read sysevent at %p", addr);
return (DCMD_ERR);
}
if ((opt_flags & SYSEVENT_VERBOSE) == 0) {
char ev_class[CLASS_FIELD_MAX];
char ev_subclass[SUBCLASS_FIELD_MAX];
if (mdb_snprintf(ev_class, CLASS_FIELD_MAX, "%s",
SE_CLASS_NAME(ev)) >= CLASS_FIELD_MAX - 1)
(void) strcpy(&ev_class[CLASS_FIELD_MAX - 4], "...");
if (mdb_snprintf(ev_subclass, SUBCLASS_FIELD_MAX, "%s",
SE_SUBCLASS_NAME(ev)) >= SUBCLASS_FIELD_MAX - 1)
(void) strcpy(&ev_subclass[SUBCLASS_FIELD_MAX - 4],
"...");
mdb_printf("%-?p %-16llu %-9s %-10s %-?p%\n",
addr, SE_SEQ(ev), ev_class, ev_subclass,
addr + SE_ATTR_OFF(ev));
} else {
mdb_printf("%<b>Sequence ID\t : %llu%</b>\n", SE_SEQ(ev));
mdb_printf("%16s : %s\n", "publisher", SE_PUB_NAME(ev));
mdb_printf("%16s : %p\n", "event address", (caddr_t)addr);
mdb_printf("%16s : %s\n", "class", SE_CLASS_NAME(ev));
mdb_printf("%16s : %s\n", "subclass", SE_SUBCLASS_NAME(ev));
mdb_printf("%16s : %llu\n", "time stamp", SE_TIME(ev));
mdb_printf("%16s : %p\n", "nvpair buf addr",
addr + SE_ATTR_OFF(ev));
}
return (DCMD_OK);
}
/*ARGSUSED*/
int
usb_pipe_handle(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char *dir, *type, *state;
usb_ep_descr_t ept_descr;
usba_pipe_handle_data_t pipe_handle;
usba_ph_impl_t ph_impl;
if (!(flags & DCMD_ADDRSPEC)) {
return (DCMD_USAGE);
}
if (mdb_vread(&pipe_handle,
sizeof (usba_pipe_handle_data_t), addr) == -1) {
mdb_warn("failed to read pipe handle at %p", addr);
return (DCMD_ERR);
}
if (mdb_vread(&ph_impl, sizeof (usba_ph_impl_t),
(uintptr_t)pipe_handle.p_ph_impl) == -1) {
state = "*******";
} else {
switch (ph_impl.usba_ph_state) {
case USB_PIPE_STATE_CLOSED:
state = "CLOSED ";
break;
case USB_PIPE_STATE_IDLE:
state = "IDLE ";
break;
case USB_PIPE_STATE_ACTIVE:
state = "ACTIVE ";
break;
case USB_PIPE_STATE_ERROR:
state = "ERROR ";
break;
case USB_PIPE_STATE_CLOSING:
state = "CLOSING";
break;
default:
state = "ILLEGAL";
break;
}
}
bcopy(&pipe_handle.p_ep, &ept_descr, sizeof (usb_ep_descr_t));
if (DCMD_HDRSPEC(flags)) {
mdb_printf("\n %<u>%-3s %5s %3s %7s %-?s %-?s %-?s%</u>\n",
"EP", "TYPE ", "DIR", "STATE ", "P_HANDLE", "P_POLICY",
"EP DESCR");
}
dir = ((ept_descr.bEndpointAddress & USB_EP_DIR_MASK) &
USB_EP_DIR_IN) ? "In " : "Out";
switch (ept_descr.bmAttributes & USB_EP_ATTR_MASK) {
case USB_EP_ATTR_CONTROL:
type = "Cntrl";
break;
case USB_EP_ATTR_ISOCH:
type = "Isoch";
break;
case USB_EP_ATTR_BULK:
type = "Bulk ";
break;
case USB_EP_ATTR_INTR:
type = "Intr ";
break;
default:
type = "*****";
break;
}
mdb_printf(" %3d %5s %3s %7s %-?p %-?p %-?p\n",
ept_descr.bEndpointAddress & USB_EP_NUM_MASK, type, dir, state,
addr, addr + offsetof(usba_pipe_handle_data_t, p_policy),
addr + offsetof(usba_pipe_handle_data_t, p_ep));
return (DCMD_OK);
}
int
zsd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
zone_t zone;
const mdb_arg_t *argp;
int argcindex;
struct zsd_cb_data cbd;
char name[ZONE_NAMELEN];
int len;
/*
* Walk all zones if necessary.
*/
if (argc > 2)
return (DCMD_USAGE);
if ((flags & DCMD_ADDRSPEC) == 0) {
if (mdb_walk_dcmd("zone", "zsd", argc, argv) == -1) {
mdb_warn("failed to walk zone\n");
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* Make sure a zone_t can be read from the specified address.
*/
if (mdb_vread(&zone, sizeof (zone), addr) == -1) {
mdb_warn("couldn't read zone_t at %p", (void *)addr);
return (DCMD_ERR);
}
/*
* Get the optional arguments (key or -v or both). Note that
* mdb_getopts() will not parse a key argument because it is not
* preceded by an option letter. We'll get around this by requiring
* that all options precede the optional key argument.
*/
cbd.keygiven = FALSE;
cbd.voptgiven = FALSE;
if (argc > 0 && (argcindex = mdb_getopts(argc, argv, 'v',
MDB_OPT_SETBITS, TRUE, &cbd.voptgiven, NULL)) != argc) {
/*
* No options may appear after the key.
*/
if (argcindex != argc - 1)
return (DCMD_USAGE);
/*
* The missed argument should be a key.
*/
argp = &argv[argcindex];
if (argp->a_type == MDB_TYPE_IMMEDIATE)
cbd.key = argp->a_un.a_val;
else
cbd.key = mdb_strtoull(argp->a_un.a_str);
cbd.keygiven = TRUE;
cbd.found = FALSE;
}
/*
* Prepare to output the specified zone's ZSD information.
*/
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-20s %?s %?s %8s%</u>\n", "ZONE", "KEY",
"VALUE", "FLAGS");
len = mdb_readstr(name, ZONE_NAMELEN, (uintptr_t)zone.zone_name);
if (len > 0) {
if (len == ZONE_NAMELEN)
(void) strcpy(&name[len - 4], "...");
} else {
(void) strcpy(name, "??");
}
mdb_printf("%-20s ", name);
/*
* Display the requested ZSD entries.
*/
mdb_inc_indent(21);
if (mdb_pwalk("zsd", zsd_print, &cbd, addr) != 0) {
mdb_warn("failed to walk zsd\n");
mdb_dec_indent(21);
return (DCMD_ERR);
}
if (cbd.keygiven == TRUE && cbd.found == FALSE) {
mdb_printf("no corresponding ZSD entry found\n");
mdb_dec_indent(21);
return (DCMD_ERR);
}
mdb_dec_indent(21);
return (DCMD_OK);
}
