int rctl_val_walk_step(mdb_walk_state_t *wsp) { rctl_val_t val; int status; if (mdb_vread(&val, sizeof (rctl_val_t), wsp->walk_addr) == -1) { mdb_warn("failed to read rctl_val at %p", wsp->walk_addr); return (WALK_DONE); } status = wsp->walk_callback(wsp->walk_addr, &val, wsp->walk_cbdata); if ((wsp->walk_addr = (uintptr_t)val.rcv_next) == NULL) return (WALK_DONE); return (status); }
/*ARGSUSED*/ static int stmf_remote_port(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { stmf_remote_port_t rpt; int ret = DCMD_OK; if (!(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_vread(&rpt, sizeof (stmf_remote_port_t), addr) == -1) { mdb_warn("failed to read stmf_remote_port_t at %p\n", addr); return (DCMD_ERR); } ret = print_transport_id((uintptr_t)rpt.rport_tptid, rpt.rport_tptid_sz, " "); return (ret); }
/*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); }
/* * dcmd ::credsid - display a credsid_t */ int cmd_credsid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { credsid_t kr; uint_t opts = FALSE; int rv = DCMD_OK; if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, OPT_VERBOSE, &opts, NULL) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { return (DCMD_USAGE); } if (mdb_vread(&kr, sizeof (kr), addr) == -1) { mdb_warn("error reading credsid_t at %p", addr); return (DCMD_ERR); } if (opts & OPT_VERBOSE) mdb_printf("kr_ref = 0x%x\n", kr.kr_ref); mdb_printf("kr_sidx[USER] = "); print_ksid(&kr.kr_sidx[KSID_USER]); mdb_printf("kr_sidx[GROUP] = "); print_ksid(&kr.kr_sidx[KSID_GROUP]); mdb_printf("kr_sidx[OWNER] = "); print_ksid(&kr.kr_sidx[KSID_OWNER]); mdb_printf("kr_sidlist = %p\n", kr.kr_sidlist); if (kr.kr_sidlist != NULL && (opts & OPT_VERBOSE) != 0) { mdb_printf("*kr_sidlist = {\n"); mdb_inc_indent(4); rv = mdb_call_dcmd("ksidlist", (uintptr_t)kr.kr_sidlist, flags, argc, argv); mdb_dec_indent(4); mdb_printf("}\n"); } return (rv); }
/* ARGSUSED */ static int srpt_print_ioc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { srpt_ioc_t ioc; char mask[9]; int i; if (addr == NULL) { mdb_warn("address of srpt_ioc should be specified\n"); return (DCMD_ERR); } if (mdb_vread(&ioc, sizeof (srpt_ioc_t), addr) == -1) { mdb_warn("failed to read srpt_ioc at %p", addr); return (DCMD_ERR); } mdb_printf("IOC %p\n", addr); mdb_printf(" guid: %x\n", ioc.ioc_guid); mdb_printf(" target port: %p\n", ioc.ioc_tgt_port); mdb_printf(" srq handle: %p\n", ioc.ioc_srq_hdl); mdb_printf(" current srq size: %u\n", ioc.ioc_num_iu_entries); mdb_printf(" max srq size: %d\n", ioc.ioc_srq_attr.srq_wr_sz); mdb_printf(" iu pool: %p\n", ioc.ioc_iu_pool); mdb_printf(" profile send qdepth: %d\n", SRPT_BSWAP_16(ioc.ioc_profile.ioc_send_msg_qdepth)); mdb_printf(" profile rmda read qdepth: %d\n", ioc.ioc_profile.ioc_rdma_read_qdepth); mdb_printf(" profile send msg size: %d\n", SRPT_BSWAP_32(ioc.ioc_profile.ioc_send_msg_sz)); mdb_printf(" profile rmda xfer size: %d\n", SRPT_BSWAP_32(ioc.ioc_profile.ioc_rdma_xfer_sz)); for (i = 0; i < 8; i++) { if (ioc.ioc_profile.ioc_ctrl_opcap_mask & 1<<i) { mask[i] = 'x'; } else { mask[i] = '-'; } } mask[i] = '\0'; mdb_printf(" profile opcap mask: %s\n", mask); return (DCMD_OK); }
/*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); }
/*ARGSUSED*/ int dof_relohdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { dof_relohdr_t r; if (argc != 0 || !(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_vread(&r, sizeof (r), addr) != sizeof (r)) { mdb_warn("failed to read relohdr at %p", addr); return (DCMD_ERR); } mdb_printf("dofr_strtab = %d\n", r.dofr_strtab); mdb_printf("dofr_relsec = %d\n", r.dofr_relsec); mdb_printf("dofr_tgtsec = %d\n", r.dofr_tgtsec); return (DCMD_OK); }
static void dis_setx(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) { uint_t intptr = DIF_INSTR_INTEGER(instr); mdb_printf("%-4s DIF_INTEGER[%u], %%r%u", name, intptr, DIF_INSTR_RD(instr)); if (dp != NULL && intptr < dp->dtdo_intlen) { uint64_t *ip = mdb_alloc(dp->dtdo_intlen * sizeof (uint64_t), UM_SLEEP | UM_GC); if (mdb_vread(ip, dp->dtdo_intlen * sizeof (uint64_t), (uintptr_t)dp->dtdo_inttab) == -1) mdb_warn("failed to read data at %p", dp->dtdo_inttab); else mdb_printf("\t\t! 0x%llx", ip[intptr]); } }
/* * SCTP interface for geting the primary peer address of a sctp_t. */ static int sctp_getpeeraddr(sctp_t *sctp, struct sockaddr *addr) { struct sockaddr_in *sin4; struct sockaddr_in6 *sin6; sctp_faddr_t sctp_primary; in6_addr_t faddr; conn_t *connp = sctp->sctp_connp; if (sctp->sctp_faddrs == NULL) return (-1); addr->sa_family = connp->conn_family; if (mdb_vread(&sctp_primary, sizeof (sctp_faddr_t), (uintptr_t)sctp->sctp_primary) == -1) { mdb_warn("failed to read sctp primary faddr"); return (-1); } faddr = sctp_primary.sf_faddr; switch (connp->conn_family) { case AF_INET: /* LINTED: alignment */ sin4 = (struct sockaddr_in *)addr; IN6_V4MAPPED_TO_INADDR(&faddr, &sin4->sin_addr); sin4->sin_port = connp->conn_fport; sin4->sin_family = AF_INET; break; case AF_INET6: /* LINTED: alignment */ sin6 = (struct sockaddr_in6 *)addr; sin6->sin6_addr = faddr; sin6->sin6_port = connp->conn_fport; sin6->sin6_family = AF_INET6; sin6->sin6_flowinfo = 0; sin6->sin6_scope_id = 0; sin6->__sin6_src_id = 0; break; } return (0); }
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); }
static int mac_group_count_clients(mac_group_t *mgp) { int clients = 0; uintptr_t mcp = (uintptr_t)mgp->mrg_clients; while (mcp != 0) { mac_grp_client_t c; if (mdb_vread(&c, sizeof (c), mcp) == -1) { mdb_warn("failed to read mac_grp_client_t at %p", mcp); return (-1); } clients++; mcp = (uintptr_t)c.mgc_next; } return (clients); }
/* * At each step, read a TD into our private storage, and then invoke * the callback function. We terminate when we reach a QH, or * link_ptr is NULL. */ int uhci_td_walk_step(mdb_walk_state_t *wsp) { int status; uhci_state_t *uhcip = (uhci_state_t *)wsp->walk_arg; if (mdb_vread(wsp->walk_data, sizeof (uhci_td_t), wsp->walk_addr) == -1) { mdb_warn("failed to read td at %p", wsp->walk_addr); return (WALK_DONE); } status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); /* Next td. */ wsp->walk_addr = ((uhci_td_t *)wsp->walk_data)->link_ptr; /* Check if we're at the last element */ if (wsp->walk_addr == NULL || wsp->walk_addr & HC_END_OF_LIST) return (WALK_DONE); /* Make sure next element is a TD. If a QH, stop. */ if (((((uhci_td_t *)wsp->walk_data)->link_ptr) & HC_QUEUE_HEAD) == HC_QUEUE_HEAD) { return (WALK_DONE); } /* Strip terminate etc. bits. */ wsp->walk_addr &= QH_LINK_PTR_MASK; /* there is no TD_LINK_PTR_MASK */ if (wsp->walk_addr == NULL) return (WALK_DONE); /* * Convert link_ptr paddr to vaddr * Note: uhcip needed by TD_VADDR macro */ wsp->walk_addr = (uintptr_t)TD_VADDR(wsp->walk_addr); return (status); }
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); }
void cyclic_pretty_dump(cyc_cpu_t *cpu) { char **c; int i, j; int width = 80; int depth; cyc_index_t *heap; size_t 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", (uintptr_t)cpu->cyp_heap); return; } for (depth = 0; (1 << depth) < cpu->cyp_nelems; depth++) continue; depth++; depth = (depth + 1) * LINES_PER_LEVEL; c = mdb_zalloc(sizeof (char *) * depth, UM_SLEEP|UM_GC); for (i = 0; i < depth; i++) c[i] = mdb_zalloc(width, UM_SLEEP|UM_GC); cyclic_dump_node(cpu, heap, c, width, 0, 1, width - 2, 0); for (i = 0; i < depth; i++) { int dump = 0; for (j = 0; j < width - 1; j++) { if (c[i][j] == '\0') c[i][j] = ' '; else dump = 1; } c[i][width - 2] = '\n'; if (dump) mdb_printf(c[i]); } }
/* * 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); }
/*ARGSUSED*/ int dof_relodesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { dof_relodesc_t r; if (argc != 0 || !(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_vread(&r, sizeof (r), addr) != sizeof (r)) { mdb_warn("failed to read relodesc at %p", addr); return (DCMD_ERR); } mdb_printf("dofr_name = %u\n", r.dofr_name); mdb_printf("dofr_type = %u\n", r.dofr_type); mdb_printf("dofr_offset = 0x%llx\n", r.dofr_offset); mdb_printf("dofr_data = 0x%llx\n", r.dofr_data); return (DCMD_OK); }
static int sv_gclient_wstep(mdb_walk_state_t *wsp) { int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (mdb_vread(wsp->walk_data, sizeof (sv_gclient_t), wsp->walk_addr) == -1) { mdb_warn("failed to read sv_gclient at %p", wsp->walk_addr); return (WALK_DONE); } status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr = (uintptr_t)(((sv_gclient_t *)wsp->walk_data)->sg_next); return (status); }
/*ARGSUSED*/ int dof_ecbdesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { dof_ecbdesc_t e; if (argc != 0 || !(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_vread(&e, sizeof (e), addr) != sizeof (e)) { mdb_warn("failed to read ecbdesc at %p", addr); return (DCMD_ERR); } mdb_printf("dofe_probes = %d\n", e.dofe_probes); mdb_printf("dofe_actions = %d\n", e.dofe_actions); mdb_printf("dofe_pred = %d\n", e.dofe_pred); mdb_printf("dofe_uarg = 0x%llx\n", e.dofe_uarg); return (DCMD_OK); }
int swap_walk_step(mdb_walk_state_t *wsp) { uintptr_t sip; struct swapinfo si; sip = wsp->walk_addr; if (sip == NULL) return (WALK_DONE); if (mdb_vread(&si, sizeof (struct swapinfo), sip) == -1) { mdb_warn("unable to read swapinfo at %#lx", sip); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)si.si_next; return (wsp->walk_callback(sip, &si, wsp->walk_cbdata)); }
/* * Walk the NCA timer list; done as a layered walk on top of "nca_cpu". */ static int nca_timer_walk_step(mdb_walk_state_t *wsp) { const nca_cpu_t *nca_cpu = wsp->walk_layer; ti_t ti; /* * Just skip CPUs that don't have any timers running. */ if (nca_cpu->tcp_ti == NULL) return (WALK_NEXT); if (mdb_vread(&ti, sizeof (ti_t), (uintptr_t)nca_cpu->tcp_ti) == -1) { mdb_warn("cannot read ti_t at %p", nca_cpu->tcp_ti); return (WALK_ERR); } return (wsp->walk_callback((uintptr_t)nca_cpu->tcp_ti, &ti, wsp->walk_cbdata)); }
static int case_walk_step(mdb_walk_state_t *wsp) { uintptr_t addr = wsp->walk_addr; fmd_case_impl_t ci; if (wsp->walk_data != NULL) return (hash_walk_step(wsp)); if (addr == NULL) return (WALK_DONE); if (mdb_vread(&ci, sizeof (ci), addr) != sizeof (ci)) { mdb_warn("failed to read fmd_case at %p", addr); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)ci.ci_list.l_next; return (wsp->walk_callback(addr, &ci, wsp->walk_cbdata)); }
int memlist_walk_step(mdb_walk_state_t *wsp) { uintptr_t mlp; struct memlist ml; mlp = wsp->walk_addr; if (mlp == NULL) return (WALK_DONE); if (mdb_vread(&ml, sizeof (struct memlist), mlp) == -1) { mdb_warn("unable to read memlist at %#lx", mlp); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)ml.ml_next; return (wsp->walk_callback(mlp, &ml, wsp->walk_cbdata)); }
int vfs_walk_step(mdb_walk_state_t *wsp) { vfs_t vfs; int status; if (mdb_vread(&vfs, sizeof (vfs), wsp->walk_addr) == -1) { mdb_warn("failed to read vfs_t at %p", wsp->walk_addr); return (WALK_DONE); } status = wsp->walk_callback(wsp->walk_addr, &vfs, wsp->walk_cbdata); if (vfs.vfs_next == wsp->walk_data) return (WALK_DONE); wsp->walk_addr = (uintptr_t)vfs.vfs_next; return (status); }
/*ARGSUSED*/ static int fcf_serd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { fcf_serd_t fcfd; if (argc != 0) return (DCMD_USAGE); if (mdb_vread(&fcfd, sizeof (fcfd), addr) != sizeof (fcfd)) { mdb_warn("failed to read serd at %p", addr); return (DCMD_ERR); } mdb_printf("fcfd_name = 0x%x\n", fcfd.fcfd_name); mdb_printf("fcfd_events = %u\n", fcfd.fcfd_events); mdb_printf("fcfd_n = >%u\n", fcfd.fcfd_n); mdb_printf("fcfd_t = %lluns\n", fcfd.fcfd_t); return (DCMD_OK); }
static int ulwp_walk_init(mdb_walk_state_t *wsp) { uintptr_t addr = wsp->walk_addr; uintptr_t uber_addr; if (addr == NULL && ((uber_addr = uberdata_addr()) == NULL || mdb_vread(&addr, sizeof (addr), uber_addr + OFFSETOF(uberdata_t, all_lwps)) != sizeof (addr))) { mdb_warn("cannot find 'uberdata.all_lwps'"); return (WALK_ERR); } if (addr == NULL) return (WALK_DONE); wsp->walk_addr = addr; wsp->walk_data = (void *)addr; return (WALK_NEXT); }
/* 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); }
/* * Given a usba_device pointer, figure out which dip is associated with it. * Relies on usba_device.usb_root_hub_dip being accurate. * * - usb_dev_addr is a pointer to a usba_device_t in core. * - dip_addr is the address of a uintptr_t to receive the address in core * of the found dip (if any). * * Returns: * 0 on success (no match found) * 1 on success (match found) * -1 on errors. */ static int usba_device2dip(uintptr_t usb_dev_addr, uintptr_t *dip_addr) { usba_device_t usb_dev; usba_device2devinfo_cbdata_t cb_data; /* * Walk all USB children of the root hub devinfo. * The callback func looks for a match on the usba_device address. */ cb_data.u2d_target_usb_dev_p = usb_dev_addr; cb_data.u2d_dip_addr = dip_addr; cb_data.u2d_found = FALSE; if (mdb_vread(&usb_dev, sizeof (usba_device_t), usb_dev_addr) == -1) { mdb_warn("failed to read usba_device struct"); return (-1); } /* * Walk devinfo children starting with the root hub node, * looking for a match on the usba_device pointer (which is what * find_dip does). * Result is placed in cb_data.dip_addr. */ if (mdb_pwalk("devinfo_children", find_dip, &cb_data, (uintptr_t)usb_dev.usb_root_hub_dip) != 0) { mdb_warn("failed to walk devinfo_children"); return (-1); } if (cb_data.u2d_found == TRUE) { return (1); } return (0); }
/*ARGSUSED*/ static int fcf_case(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { fcf_case_t fcfc; if (argc != 0) return (DCMD_USAGE); if (mdb_vread(&fcfc, sizeof (fcfc), addr) != sizeof (fcfc)) { mdb_warn("failed to read case at %p", addr); return (DCMD_ERR); } mdb_printf("fcfc_uuid = 0x%x\n", fcfc.fcfc_uuid); mdb_printf("fcfc_state = %u\n", fcfc.fcfc_state); mdb_printf("fcfc_bufs = %u\n", fcfc.fcfc_bufs); mdb_printf("fcfc_events = %u\n", fcfc.fcfc_events); mdb_printf("fcfc_suspects = %u\n", fcfc.fcfc_suspects); return (DCMD_OK); }
int sysevent_walk_step(mdb_walk_state_t *wsp) { int status; uintptr_t ev_arg_addr; if (wsp->walk_addr == NULL) return (WALK_DONE); if (mdb_vread(wsp->walk_data, sizeof (log_eventq_t), wsp->walk_addr) == -1) { mdb_warn("failed to read event queue at %p", wsp->walk_addr); return (WALK_ERR); } ev_arg_addr = wsp->walk_addr + offsetof(log_eventq_t, arg.buf); status = wsp->walk_callback(ev_arg_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr = (uintptr_t)(((log_eventq_t *)wsp->walk_data)->next); return (status); }