/*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); }