17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5ac448965Sahl * Common Development and Distribution License (the "License"). 6ac448965Sahl * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21ac448965Sahl 227c478bd9Sstevel@tonic-gate /* 23c9a6ea2eSBryan Cantrill * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 24*7994dfddSDan Kimmel * Copyright (c) 2013 by Delphix. All rights reserved. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * explicitly define DTRACE_ERRDEBUG to pull in definition of dtrace_errhash_t 297c478bd9Sstevel@tonic-gate * explicitly define _STDARG_H to avoid stdarg.h/varargs.h u/k defn conflict 307c478bd9Sstevel@tonic-gate */ 317c478bd9Sstevel@tonic-gate #define DTRACE_ERRDEBUG 327c478bd9Sstevel@tonic-gate #define _STDARG_H 337c478bd9Sstevel@tonic-gate 347c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h> 357c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h> 367c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h> 377c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h> 387c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h> 397c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 407c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 417c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 427c478bd9Sstevel@tonic-gate #include <dtrace.h> 437c478bd9Sstevel@tonic-gate #include <alloca.h> 447c478bd9Sstevel@tonic-gate #include <ctype.h> 457c478bd9Sstevel@tonic-gate #include <errno.h> 467c478bd9Sstevel@tonic-gate #include <math.h> 47*7994dfddSDan Kimmel #include <stdio.h> 48*7994dfddSDan Kimmel #include <unistd.h> 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 517c478bd9Sstevel@tonic-gate int 527c478bd9Sstevel@tonic-gate id2probe(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 537c478bd9Sstevel@tonic-gate { 547c478bd9Sstevel@tonic-gate uintptr_t probe = NULL; 557c478bd9Sstevel@tonic-gate uintptr_t probes; 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 587c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate if (addr == DTRACE_IDNONE || addr > UINT32_MAX) 617c478bd9Sstevel@tonic-gate goto out; 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate if (mdb_readvar(&probes, "dtrace_probes") == -1) { 647c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'"); 657c478bd9Sstevel@tonic-gate return (DCMD_ERR); 667c478bd9Sstevel@tonic-gate } 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate probes += (addr - 1) * sizeof (dtrace_probe_t *); 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (uintptr_t), probes) == -1) { 717c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_probes[%d]", addr - 1); 727c478bd9Sstevel@tonic-gate return (DCMD_ERR); 737c478bd9Sstevel@tonic-gate } 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate out: 767c478bd9Sstevel@tonic-gate mdb_printf("%p\n", probe); 777c478bd9Sstevel@tonic-gate return (DCMD_OK); 787c478bd9Sstevel@tonic-gate } 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate void 817c478bd9Sstevel@tonic-gate dtrace_help(void) 827c478bd9Sstevel@tonic-gate { 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure that represents a " 857c478bd9Sstevel@tonic-gate "DTrace consumer, prints\n" 867c478bd9Sstevel@tonic-gate "dtrace(1M)-like output for in-kernel DTrace data. (The " 877c478bd9Sstevel@tonic-gate "dtrace_state_t\n" 887c478bd9Sstevel@tonic-gate "structures for all DTrace consumers may be obtained by running " 897c478bd9Sstevel@tonic-gate "the \n" 907c478bd9Sstevel@tonic-gate "::dtrace_state dcmd.) When data is present on multiple CPUs, " 917c478bd9Sstevel@tonic-gate "data are\n" 927c478bd9Sstevel@tonic-gate "presented in CPU order, with records within each CPU ordered " 937c478bd9Sstevel@tonic-gate "oldest to \n" 947c478bd9Sstevel@tonic-gate "youngest. Options:\n\n" 957c478bd9Sstevel@tonic-gate "-c cpu Only provide output for specified CPU.\n"); 967c478bd9Sstevel@tonic-gate } 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate static int 997c478bd9Sstevel@tonic-gate dtracemdb_eprobe(dtrace_state_t *state, dtrace_eprobedesc_t *epd) 1007c478bd9Sstevel@tonic-gate { 1017c478bd9Sstevel@tonic-gate dtrace_epid_t epid = epd->dtepd_epid; 1027c478bd9Sstevel@tonic-gate dtrace_probe_t probe; 1037c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb; 1047c478bd9Sstevel@tonic-gate uintptr_t addr, paddr, ap; 1057c478bd9Sstevel@tonic-gate dtrace_action_t act; 1067c478bd9Sstevel@tonic-gate int nactions, nrecs; 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_ecbs + 1097c478bd9Sstevel@tonic-gate (epid - 1) * sizeof (dtrace_ecb_t *); 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) { 1127c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for epid %d", epid); 1137c478bd9Sstevel@tonic-gate return (-1); 1147c478bd9Sstevel@tonic-gate } 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate if (addr == NULL) { 1177c478bd9Sstevel@tonic-gate mdb_warn("epid %d doesn't match an ecb\n", epid); 1187c478bd9Sstevel@tonic-gate return (-1); 1197c478bd9Sstevel@tonic-gate } 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), addr) == -1) { 1227c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb at %p", addr); 1237c478bd9Sstevel@tonic-gate return (-1); 1247c478bd9Sstevel@tonic-gate } 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate paddr = (uintptr_t)ecb.dte_probe; 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) { 1297c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe for ecb %p", addr); 1307c478bd9Sstevel@tonic-gate return (-1); 1317c478bd9Sstevel@tonic-gate } 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate /* 1347c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions, 1357c478bd9Sstevel@tonic-gate * we need to first walk through them. 1367c478bd9Sstevel@tonic-gate */ 1377c478bd9Sstevel@tonic-gate for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) { 1387c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 1397c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p", 1407c478bd9Sstevel@tonic-gate ap, addr); 1417c478bd9Sstevel@tonic-gate return (-1); 1427c478bd9Sstevel@tonic-gate } 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) 1457c478bd9Sstevel@tonic-gate nactions++; 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 1487c478bd9Sstevel@tonic-gate } 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate nrecs = epd->dtepd_nrecs; 1517c478bd9Sstevel@tonic-gate epd->dtepd_nrecs = nactions; 1527c478bd9Sstevel@tonic-gate epd->dtepd_probeid = probe.dtpr_id; 1537c478bd9Sstevel@tonic-gate epd->dtepd_uarg = ecb.dte_uarg; 1547c478bd9Sstevel@tonic-gate epd->dtepd_size = ecb.dte_size; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) { 1577c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 1587c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p", 1597c478bd9Sstevel@tonic-gate ap, addr); 1607c478bd9Sstevel@tonic-gate return (-1); 1617c478bd9Sstevel@tonic-gate } 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) { 1647c478bd9Sstevel@tonic-gate if (nrecs-- == 0) 1657c478bd9Sstevel@tonic-gate break; 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate epd->dtepd_rec[nactions++] = act.dta_rec; 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate return (0); 1747c478bd9Sstevel@tonic-gate } 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1777c478bd9Sstevel@tonic-gate static int 1787c478bd9Sstevel@tonic-gate dtracemdb_probe(dtrace_state_t *state, dtrace_probedesc_t *pd) 1797c478bd9Sstevel@tonic-gate { 1807c478bd9Sstevel@tonic-gate uintptr_t base, addr, paddr, praddr; 1817c478bd9Sstevel@tonic-gate int nprobes, i; 1827c478bd9Sstevel@tonic-gate dtrace_probe_t probe; 1837c478bd9Sstevel@tonic-gate dtrace_provider_t prov; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate if (pd->dtpd_id == DTRACE_IDNONE) 1867c478bd9Sstevel@tonic-gate pd->dtpd_id++; 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate if (mdb_readvar(&base, "dtrace_probes") == -1) { 1897c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'"); 1907c478bd9Sstevel@tonic-gate return (-1); 1917c478bd9Sstevel@tonic-gate } 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) { 1947c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_nprobes'"); 1957c478bd9Sstevel@tonic-gate return (-1); 1967c478bd9Sstevel@tonic-gate } 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate for (i = pd->dtpd_id; i <= nprobes; i++) { 1997c478bd9Sstevel@tonic-gate addr = base + (i - 1) * sizeof (dtrace_probe_t *); 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate if (mdb_vread(&paddr, sizeof (paddr), addr) == -1) { 2027c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe pointer at %p", addr); 2037c478bd9Sstevel@tonic-gate return (-1); 2047c478bd9Sstevel@tonic-gate } 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate if (paddr != NULL) 2077c478bd9Sstevel@tonic-gate break; 2087c478bd9Sstevel@tonic-gate } 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate if (paddr == NULL) { 2117c478bd9Sstevel@tonic-gate errno = ESRCH; 2127c478bd9Sstevel@tonic-gate return (-1); 2137c478bd9Sstevel@tonic-gate } 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) { 2167c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe at %p", paddr); 2177c478bd9Sstevel@tonic-gate return (-1); 2187c478bd9Sstevel@tonic-gate } 2197c478bd9Sstevel@tonic-gate 2207c478bd9Sstevel@tonic-gate pd->dtpd_id = probe.dtpr_id; 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_name, DTRACE_NAMELEN, 2237c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_name) == -1) { 2247c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe name for probe %p", paddr); 2257c478bd9Sstevel@tonic-gate return (-1); 2267c478bd9Sstevel@tonic-gate } 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_func, DTRACE_FUNCNAMELEN, 2297c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_func) == -1) { 2307c478bd9Sstevel@tonic-gate mdb_warn("failed to read function name for probe %p", paddr); 2317c478bd9Sstevel@tonic-gate return (-1); 2327c478bd9Sstevel@tonic-gate } 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_mod, DTRACE_MODNAMELEN, 2357c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_mod) == -1) { 2367c478bd9Sstevel@tonic-gate mdb_warn("failed to read module name for probe %p", paddr); 2377c478bd9Sstevel@tonic-gate return (-1); 2387c478bd9Sstevel@tonic-gate } 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate praddr = (uintptr_t)probe.dtpr_provider; 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate if (mdb_vread(&prov, sizeof (prov), praddr) == -1) { 2437c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider for probe %p", paddr); 2447c478bd9Sstevel@tonic-gate return (-1); 2457c478bd9Sstevel@tonic-gate } 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_provider, DTRACE_PROVNAMELEN, 2487c478bd9Sstevel@tonic-gate (uintptr_t)prov.dtpv_name) == -1) { 2497c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider name for probe %p", paddr); 2507c478bd9Sstevel@tonic-gate return (-1); 2517c478bd9Sstevel@tonic-gate } 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate return (0); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2577c478bd9Sstevel@tonic-gate static int 2587c478bd9Sstevel@tonic-gate dtracemdb_aggdesc(dtrace_state_t *state, dtrace_aggdesc_t *agd) 2597c478bd9Sstevel@tonic-gate { 2607c478bd9Sstevel@tonic-gate dtrace_aggid_t aggid = agd->dtagd_id; 2617c478bd9Sstevel@tonic-gate dtrace_aggregation_t agg; 2627c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb; 2637c478bd9Sstevel@tonic-gate uintptr_t addr, eaddr, ap, last; 2647c478bd9Sstevel@tonic-gate dtrace_action_t act; 2657c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec; 2667c478bd9Sstevel@tonic-gate int nactions, nrecs; 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_aggregations + 2697c478bd9Sstevel@tonic-gate (aggid - 1) * sizeof (dtrace_aggregation_t *); 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) { 2727c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation for aggid %d", aggid); 2737c478bd9Sstevel@tonic-gate return (-1); 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate if (addr == NULL) { 2777c478bd9Sstevel@tonic-gate mdb_warn("aggid %d doesn't match an aggregation\n", aggid); 2787c478bd9Sstevel@tonic-gate return (-1); 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate if (mdb_vread(&agg, sizeof (agg), addr) == -1) { 2827c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation at %p", addr); 2837c478bd9Sstevel@tonic-gate return (-1); 2847c478bd9Sstevel@tonic-gate } 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate eaddr = (uintptr_t)agg.dtag_ecb; 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), eaddr) == -1) { 2897c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for aggregation %p", addr); 2907c478bd9Sstevel@tonic-gate return (-1); 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate last = (uintptr_t)addr + offsetof(dtrace_aggregation_t, dtag_action); 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate /* 2967c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions, 2977c478bd9Sstevel@tonic-gate * we need to first walk through them. 2987c478bd9Sstevel@tonic-gate */ 2997c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first; 3007c478bd9Sstevel@tonic-gate nactions = 0; 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate for (;;) { 3037c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 3047c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p", 3057c478bd9Sstevel@tonic-gate ap, addr); 3067c478bd9Sstevel@tonic-gate return (-1); 3077c478bd9Sstevel@tonic-gate } 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate nactions++; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate if (ap == last) 3127c478bd9Sstevel@tonic-gate break; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 3157c478bd9Sstevel@tonic-gate } 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate lrec = &act.dta_rec; 3187c478bd9Sstevel@tonic-gate agd->dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - agg.dtag_base; 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate nrecs = agd->dtagd_nrecs; 3217c478bd9Sstevel@tonic-gate agd->dtagd_nrecs = nactions; 3227c478bd9Sstevel@tonic-gate agd->dtagd_epid = ecb.dte_epid; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first; 3257c478bd9Sstevel@tonic-gate nactions = 0; 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate for (;;) { 3287c478bd9Sstevel@tonic-gate dtrace_recdesc_t rec; 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 3317c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p", 3327c478bd9Sstevel@tonic-gate ap, addr); 3337c478bd9Sstevel@tonic-gate return (-1); 3347c478bd9Sstevel@tonic-gate } 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate if (nrecs-- == 0) 3377c478bd9Sstevel@tonic-gate break; 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate rec = act.dta_rec; 3407c478bd9Sstevel@tonic-gate rec.dtrd_offset -= agg.dtag_base; 3417c478bd9Sstevel@tonic-gate rec.dtrd_uarg = 0; 3427c478bd9Sstevel@tonic-gate agd->dtagd_rec[nactions++] = rec; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate if (ap == last) 3457c478bd9Sstevel@tonic-gate break; 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 3487c478bd9Sstevel@tonic-gate } 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate return (0); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate static int 3547c478bd9Sstevel@tonic-gate dtracemdb_bufsnap(dtrace_buffer_t *which, dtrace_bufdesc_t *desc) 3557c478bd9Sstevel@tonic-gate { 3567c478bd9Sstevel@tonic-gate uintptr_t addr; 3577c478bd9Sstevel@tonic-gate size_t bufsize; 3587c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 3597c478bd9Sstevel@tonic-gate caddr_t data = desc->dtbd_data; 3607c478bd9Sstevel@tonic-gate processorid_t max_cpuid, cpu = desc->dtbd_cpu; 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) { 3637c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'"); 3647c478bd9Sstevel@tonic-gate errno = EIO; 3657c478bd9Sstevel@tonic-gate return (-1); 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate if (cpu < 0 || cpu > max_cpuid) { 3697c478bd9Sstevel@tonic-gate errno = EINVAL; 3707c478bd9Sstevel@tonic-gate return (-1); 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate addr = (uintptr_t)which + cpu * sizeof (dtrace_buffer_t); 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 3767c478bd9Sstevel@tonic-gate mdb_warn("failed to read buffer description at %p", addr); 3777c478bd9Sstevel@tonic-gate errno = EIO; 3787c478bd9Sstevel@tonic-gate return (-1); 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate if (buf.dtb_tomax == NULL) { 3827c478bd9Sstevel@tonic-gate errno = ENOENT; 3837c478bd9Sstevel@tonic-gate return (-1); 3847c478bd9Sstevel@tonic-gate } 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) { 3877c478bd9Sstevel@tonic-gate bufsize = buf.dtb_size; 3887c478bd9Sstevel@tonic-gate } else { 3897c478bd9Sstevel@tonic-gate bufsize = buf.dtb_offset; 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate if (mdb_vread(data, bufsize, (uintptr_t)buf.dtb_tomax) == -1) { 3937c478bd9Sstevel@tonic-gate mdb_warn("couldn't read buffer for CPU %d", cpu); 3947c478bd9Sstevel@tonic-gate errno = EIO; 3957c478bd9Sstevel@tonic-gate return (-1); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_size) { 3997c478bd9Sstevel@tonic-gate mdb_warn("buffer for CPU %d has corrupt offset\n", cpu); 4007c478bd9Sstevel@tonic-gate errno = EIO; 4017c478bd9Sstevel@tonic-gate return (-1); 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) { 4057c478bd9Sstevel@tonic-gate if (buf.dtb_xamot_offset > buf.dtb_size) { 4067c478bd9Sstevel@tonic-gate mdb_warn("ringbuffer for CPU %d has corrupt " 4077c478bd9Sstevel@tonic-gate "wrapped offset\n", cpu); 4087c478bd9Sstevel@tonic-gate errno = EIO; 4097c478bd9Sstevel@tonic-gate return (-1); 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate /* 4137c478bd9Sstevel@tonic-gate * If the ring buffer has wrapped, it needs to be polished. 4147c478bd9Sstevel@tonic-gate * See the comment in dtrace_buffer_polish() for details. 4157c478bd9Sstevel@tonic-gate */ 4167c478bd9Sstevel@tonic-gate if (buf.dtb_offset < buf.dtb_xamot_offset) { 4177c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset, 4187c478bd9Sstevel@tonic-gate buf.dtb_xamot_offset - buf.dtb_offset); 4197c478bd9Sstevel@tonic-gate } 4207c478bd9Sstevel@tonic-gate 4217c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_xamot_offset) { 4227c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset, 4237c478bd9Sstevel@tonic-gate buf.dtb_size - buf.dtb_offset); 4247c478bd9Sstevel@tonic-gate bzero(data, buf.dtb_xamot_offset); 4257c478bd9Sstevel@tonic-gate } 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate desc->dtbd_oldest = buf.dtb_xamot_offset; 4287c478bd9Sstevel@tonic-gate } else { 4297c478bd9Sstevel@tonic-gate desc->dtbd_oldest = 0; 4307c478bd9Sstevel@tonic-gate } 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate desc->dtbd_size = bufsize; 4337c478bd9Sstevel@tonic-gate desc->dtbd_drops = buf.dtb_drops; 4347c478bd9Sstevel@tonic-gate desc->dtbd_errors = buf.dtb_errors; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate return (0); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate /* 440c9a6ea2eSBryan Cantrill * This is essentially identical to its cousin in the kernel -- with the 441c9a6ea2eSBryan Cantrill * notable exception that we automatically set DTRACEOPT_GRABANON if this 442c9a6ea2eSBryan Cantrill * state is an anonymous enabling. 4437c478bd9Sstevel@tonic-gate */ 4447c478bd9Sstevel@tonic-gate static dof_hdr_t * 445c9a6ea2eSBryan Cantrill dtracemdb_dof_create(dtrace_state_t *state, int isanon) 4467c478bd9Sstevel@tonic-gate { 4477c478bd9Sstevel@tonic-gate dof_hdr_t *dof; 4487c478bd9Sstevel@tonic-gate dof_sec_t *sec; 4497c478bd9Sstevel@tonic-gate dof_optdesc_t *opt; 4507c478bd9Sstevel@tonic-gate int i, len = sizeof (dof_hdr_t) + 4517c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t)) + 4527c478bd9Sstevel@tonic-gate sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate dof = mdb_zalloc(len, UM_SLEEP); 4557c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0; 4567c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1; 4577c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2; 4587c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3; 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MODEL] = DOF_MODEL_NATIVE; 4617c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE; 462ac448965Sahl dof->dofh_ident[DOF_ID_VERSION] = DOF_VERSION; 4637c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFVERS] = DIF_VERSION; 4647c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFIREG] = DIF_DIR_NREGS; 4657c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFTREG] = DIF_DTR_NREGS; 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate dof->dofh_flags = 0; 4687c478bd9Sstevel@tonic-gate dof->dofh_hdrsize = sizeof (dof_hdr_t); 4697c478bd9Sstevel@tonic-gate dof->dofh_secsize = sizeof (dof_sec_t); 4707c478bd9Sstevel@tonic-gate dof->dofh_secnum = 1; /* only DOF_SECT_OPTDESC */ 4717c478bd9Sstevel@tonic-gate dof->dofh_secoff = sizeof (dof_hdr_t); 4727c478bd9Sstevel@tonic-gate dof->dofh_loadsz = len; 4737c478bd9Sstevel@tonic-gate dof->dofh_filesz = len; 4747c478bd9Sstevel@tonic-gate dof->dofh_pad = 0; 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate /* 4777c478bd9Sstevel@tonic-gate * Fill in the option section header... 4787c478bd9Sstevel@tonic-gate */ 4797c478bd9Sstevel@tonic-gate sec = (dof_sec_t *)((uintptr_t)dof + sizeof (dof_hdr_t)); 4807c478bd9Sstevel@tonic-gate sec->dofs_type = DOF_SECT_OPTDESC; 4817c478bd9Sstevel@tonic-gate sec->dofs_align = sizeof (uint64_t); 4827c478bd9Sstevel@tonic-gate sec->dofs_flags = DOF_SECF_LOAD; 4837c478bd9Sstevel@tonic-gate sec->dofs_entsize = sizeof (dof_optdesc_t); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate opt = (dof_optdesc_t *)((uintptr_t)sec + 4867c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t))); 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate sec->dofs_offset = (uintptr_t)opt - (uintptr_t)dof; 4897c478bd9Sstevel@tonic-gate sec->dofs_size = sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACEOPT_MAX; i++) { 4927c478bd9Sstevel@tonic-gate opt[i].dofo_option = i; 4937c478bd9Sstevel@tonic-gate opt[i].dofo_strtab = DOF_SECIDX_NONE; 4947c478bd9Sstevel@tonic-gate opt[i].dofo_value = state->dts_options[i]; 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 497c9a6ea2eSBryan Cantrill if (isanon) 498c9a6ea2eSBryan Cantrill opt[DTRACEOPT_GRABANON].dofo_value = 1; 499c9a6ea2eSBryan Cantrill 5007c478bd9Sstevel@tonic-gate return (dof); 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate static int 5047c478bd9Sstevel@tonic-gate dtracemdb_format(dtrace_state_t *state, dtrace_fmtdesc_t *desc) 5057c478bd9Sstevel@tonic-gate { 5067c478bd9Sstevel@tonic-gate uintptr_t addr, faddr; 5077c478bd9Sstevel@tonic-gate char c; 5087c478bd9Sstevel@tonic-gate int len = 0; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate if (desc->dtfd_format == 0 || desc->dtfd_format > state->dts_nformats) { 5117c478bd9Sstevel@tonic-gate errno = EINVAL; 5127c478bd9Sstevel@tonic-gate return (-1); 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate faddr = (uintptr_t)state->dts_formats + 5167c478bd9Sstevel@tonic-gate (desc->dtfd_format - 1) * sizeof (char *); 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), faddr) == -1) { 5197c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string pointer at %p", faddr); 5207c478bd9Sstevel@tonic-gate return (-1); 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate do { 5247c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), addr + len++) == -1) { 5257c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string at %p", addr); 5267c478bd9Sstevel@tonic-gate return (-1); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate } while (c != '\0'); 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate if (len > desc->dtfd_length) { 5317c478bd9Sstevel@tonic-gate desc->dtfd_length = len; 5327c478bd9Sstevel@tonic-gate return (0); 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate if (mdb_vread(desc->dtfd_string, len, addr) == -1) { 5367c478bd9Sstevel@tonic-gate mdb_warn("failed to reread format string at %p", addr); 5377c478bd9Sstevel@tonic-gate return (-1); 5387c478bd9Sstevel@tonic-gate } 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate return (0); 5417c478bd9Sstevel@tonic-gate } 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate static int 5447c478bd9Sstevel@tonic-gate dtracemdb_status(dtrace_state_t *state, dtrace_status_t *status) 5457c478bd9Sstevel@tonic-gate { 5467c478bd9Sstevel@tonic-gate dtrace_dstate_t *dstate; 5477c478bd9Sstevel@tonic-gate int i, j; 5487c478bd9Sstevel@tonic-gate uint64_t nerrs; 5497c478bd9Sstevel@tonic-gate uintptr_t addr; 5507c478bd9Sstevel@tonic-gate int ncpu; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 5537c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 5547c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5557c478bd9Sstevel@tonic-gate } 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate bzero(status, sizeof (dtrace_status_t)); 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 5607c478bd9Sstevel@tonic-gate errno = ENOENT; 5617c478bd9Sstevel@tonic-gate return (-1); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * For the MDB backend, we never set dtst_exiting or dtst_filled. This 5667c478bd9Sstevel@tonic-gate * is by design: we don't want the library to try to stop tracing, 5677c478bd9Sstevel@tonic-gate * because it doesn't particularly mean anything. 5687c478bd9Sstevel@tonic-gate */ 5697c478bd9Sstevel@tonic-gate nerrs = state->dts_errors; 5707c478bd9Sstevel@tonic-gate dstate = &state->dts_vstate.dtvs_dynvars; 5717c478bd9Sstevel@tonic-gate 5727c478bd9Sstevel@tonic-gate for (i = 0; i < ncpu; i++) { 5737c478bd9Sstevel@tonic-gate dtrace_dstate_percpu_t dcpu; 5747c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate addr = (uintptr_t)&dstate->dtds_percpu[i]; 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate if (mdb_vread(&dcpu, sizeof (dcpu), addr) == -1) { 5797c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU dstate at %p", addr); 5807c478bd9Sstevel@tonic-gate return (-1); 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate status->dtst_dyndrops += dcpu.dtdsc_drops; 5847c478bd9Sstevel@tonic-gate status->dtst_dyndrops_dirty += dcpu.dtdsc_dirty_drops; 5857c478bd9Sstevel@tonic-gate status->dtst_dyndrops_rinsing += dcpu.dtdsc_rinsing_drops; 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_buffer[i]; 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 5907c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU buffer at %p", addr); 5917c478bd9Sstevel@tonic-gate return (-1); 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate nerrs += buf.dtb_errors; 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate for (j = 0; j < state->dts_nspeculations; j++) { 5977c478bd9Sstevel@tonic-gate dtrace_speculation_t spec; 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_speculations[j]; 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate if (mdb_vread(&spec, sizeof (spec), addr) == -1) { 6027c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 6037c478bd9Sstevel@tonic-gate "speculation at %p", addr); 6047c478bd9Sstevel@tonic-gate return (-1); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate addr = (uintptr_t)&spec.dtsp_buffer[i]; 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 6107c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 6117c478bd9Sstevel@tonic-gate "speculative buffer at %p", addr); 6127c478bd9Sstevel@tonic-gate return (-1); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate status->dtst_specdrops += buf.dtb_xamot_drops; 6167c478bd9Sstevel@tonic-gate } 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate status->dtst_specdrops_busy = state->dts_speculations_busy; 6207c478bd9Sstevel@tonic-gate status->dtst_specdrops_unavail = state->dts_speculations_unavail; 6217c478bd9Sstevel@tonic-gate status->dtst_errors = nerrs; 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate return (0); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate typedef struct dtracemdb_data { 6277c478bd9Sstevel@tonic-gate dtrace_state_t *dtmd_state; 6287c478bd9Sstevel@tonic-gate char *dtmd_symstr; 6297c478bd9Sstevel@tonic-gate char *dtmd_modstr; 6307c478bd9Sstevel@tonic-gate uintptr_t dtmd_addr; 631c9a6ea2eSBryan Cantrill int dtmd_isanon; 6327c478bd9Sstevel@tonic-gate } dtracemdb_data_t; 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate static int 6357c478bd9Sstevel@tonic-gate dtracemdb_ioctl(void *varg, int cmd, void *arg) 6367c478bd9Sstevel@tonic-gate { 6377c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 6387c478bd9Sstevel@tonic-gate dtrace_state_t *state = data->dtmd_state; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate switch (cmd) { 6417c478bd9Sstevel@tonic-gate case DTRACEIOC_CONF: { 6427c478bd9Sstevel@tonic-gate dtrace_conf_t *conf = arg; 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate bzero(conf, sizeof (conf)); 6457c478bd9Sstevel@tonic-gate conf->dtc_difversion = DIF_VERSION; 6467c478bd9Sstevel@tonic-gate conf->dtc_difintregs = DIF_DIR_NREGS; 6477c478bd9Sstevel@tonic-gate conf->dtc_diftupregs = DIF_DTR_NREGS; 6487c478bd9Sstevel@tonic-gate conf->dtc_ctfmodel = CTF_MODEL_NATIVE; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate return (0); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate case DTRACEIOC_DOFGET: { 6547c478bd9Sstevel@tonic-gate dof_hdr_t *hdr = arg, *dof; 6557c478bd9Sstevel@tonic-gate 656c9a6ea2eSBryan Cantrill dof = dtracemdb_dof_create(state, data->dtmd_isanon); 6577c478bd9Sstevel@tonic-gate bcopy(dof, hdr, MIN(hdr->dofh_loadsz, dof->dofh_loadsz)); 6587c478bd9Sstevel@tonic-gate mdb_free(dof, dof->dofh_loadsz); 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate return (0); 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate case DTRACEIOC_BUFSNAP: 6647c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_buffer, arg)); 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGSNAP: 6677c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_aggbuffer, arg)); 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGDESC: 6707c478bd9Sstevel@tonic-gate return (dtracemdb_aggdesc(state, arg)); 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate case DTRACEIOC_EPROBE: 6737c478bd9Sstevel@tonic-gate return (dtracemdb_eprobe(state, arg)); 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBES: 6767c478bd9Sstevel@tonic-gate return (dtracemdb_probe(state, arg)); 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate case DTRACEIOC_FORMAT: 6797c478bd9Sstevel@tonic-gate return (dtracemdb_format(state, arg)); 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate case DTRACEIOC_STATUS: 6827c478bd9Sstevel@tonic-gate return (dtracemdb_status(state, arg)); 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate case DTRACEIOC_GO: 6857c478bd9Sstevel@tonic-gate *(processorid_t *)arg = -1; 6867c478bd9Sstevel@tonic-gate return (0); 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate case DTRACEIOC_ENABLE: 6897c478bd9Sstevel@tonic-gate errno = ENOTTY; /* see dt_open.c:dtrace_go() */ 6907c478bd9Sstevel@tonic-gate return (-1); 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate case DTRACEIOC_PROVIDER: 6937c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBEMATCH: 6947c478bd9Sstevel@tonic-gate errno = ESRCH; 6957c478bd9Sstevel@tonic-gate return (-1); 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate default: 6987c478bd9Sstevel@tonic-gate mdb_warn("unexpected ioctl 0x%x (%s)\n", cmd, 6997c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROVIDER ? "DTRACEIOC_PROVIDER" : 7007c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBES ? "DTRACEIOC_PROBES" : 7017c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_BUFSNAP ? "DTRACEIOC_BUFSNAP" : 7027c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEMATCH ? "DTRACEIOC_PROBEMATCH" : 7037c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_ENABLE ? "DTRACEIOC_ENABLE" : 7047c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGSNAP ? "DTRACEIOC_AGGSNAP" : 7057c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_EPROBE ? "DTRACEIOC_EPROBE" : 7067c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEARG ? "DTRACEIOC_PROBEARG" : 7077c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_CONF ? "DTRACEIOC_CONF" : 7087c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STATUS ? "DTRACEIOC_STATUS" : 7097c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_GO ? "DTRACEIOC_GO" : 7107c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STOP ? "DTRACEIOC_STOP" : 7117c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGDESC ? "DTRACEIOC_AGGDESC" : 7127c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_FORMAT ? "DTRACEIOC_FORMAT" : 7137c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_DOFGET ? "DTRACEIOC_DOFGET" : 7147c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_REPLICATE ? "DTRACEIOC_REPLICATE" : 7157c478bd9Sstevel@tonic-gate "???"); 7167c478bd9Sstevel@tonic-gate errno = ENXIO; 7177c478bd9Sstevel@tonic-gate return (-1); 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate static int 7227c478bd9Sstevel@tonic-gate dtracemdb_modctl(uintptr_t addr, const struct modctl *m, dtracemdb_data_t *data) 7237c478bd9Sstevel@tonic-gate { 7247c478bd9Sstevel@tonic-gate struct module mod; 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate if (m->mod_mp == NULL) 7277c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) { 7307c478bd9Sstevel@tonic-gate mdb_warn("couldn't read modctl %p's module", addr); 7317c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text > data->dtmd_addr) 7357c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text + mod.text_size <= data->dtmd_addr) 7387c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate if (mdb_readstr(data->dtmd_modstr, MDB_SYM_NAMLEN, 7417c478bd9Sstevel@tonic-gate (uintptr_t)m->mod_modname) == -1) 7427c478bd9Sstevel@tonic-gate return (WALK_ERR); 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate return (WALK_DONE); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate static int 7487c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr(void *varg, GElf_Addr addr, GElf_Sym *symp, 7497c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip) 7507c478bd9Sstevel@tonic-gate { 7517c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate if (data->dtmd_symstr == NULL) { 7547c478bd9Sstevel@tonic-gate data->dtmd_symstr = mdb_zalloc(MDB_SYM_NAMLEN, 7557c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 7567c478bd9Sstevel@tonic-gate } 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate if (data->dtmd_modstr == NULL) { 7597c478bd9Sstevel@tonic-gate data->dtmd_modstr = mdb_zalloc(MDB_SYM_NAMLEN, 7607c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate if (symp != NULL) { 7647c478bd9Sstevel@tonic-gate if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, data->dtmd_symstr, 7657c478bd9Sstevel@tonic-gate MDB_SYM_NAMLEN, symp) == -1) 7667c478bd9Sstevel@tonic-gate return (-1); 7677c478bd9Sstevel@tonic-gate } 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate if (sip != NULL) { 7707c478bd9Sstevel@tonic-gate data->dtmd_addr = addr; 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate (void) strcpy(data->dtmd_modstr, "???"); 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate if (mdb_walk("modctl", 7757c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtracemdb_modctl, varg) == -1) { 7767c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'modctl'"); 7777c478bd9Sstevel@tonic-gate return (-1); 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate sip->dts_object = data->dtmd_modstr; 7817c478bd9Sstevel@tonic-gate sip->dts_id = 0; 7827c478bd9Sstevel@tonic-gate sip->dts_name = symp != NULL ? data->dtmd_symstr : NULL; 7837c478bd9Sstevel@tonic-gate } 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate return (0); 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7897c478bd9Sstevel@tonic-gate static int 7907c478bd9Sstevel@tonic-gate dtracemdb_stat(void *varg, processorid_t cpu) 7917c478bd9Sstevel@tonic-gate { 7927c478bd9Sstevel@tonic-gate GElf_Sym sym; 7937c478bd9Sstevel@tonic-gate cpu_t c; 7947c478bd9Sstevel@tonic-gate uintptr_t caddr, addr; 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("cpu", &sym) == -1) { 7977c478bd9Sstevel@tonic-gate mdb_warn("failed to find symbol for 'cpu'"); 7987c478bd9Sstevel@tonic-gate return (-1); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate if (cpu * sizeof (uintptr_t) > sym.st_size) 8027c478bd9Sstevel@tonic-gate return (-1); 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value + cpu * sizeof (uintptr_t); 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate if (mdb_vread(&caddr, sizeof (caddr), addr) == -1) { 8077c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu[%d]", cpu); 8087c478bd9Sstevel@tonic-gate return (-1); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate if (caddr == NULL) 8127c478bd9Sstevel@tonic-gate return (-1); 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), caddr) == -1) { 8157c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu at %p", caddr); 8167c478bd9Sstevel@tonic-gate return (-1); 8177c478bd9Sstevel@tonic-gate } 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate if (c.cpu_flags & CPU_POWEROFF) { 8207c478bd9Sstevel@tonic-gate return (P_POWEROFF); 8217c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_SPARE) { 8227c478bd9Sstevel@tonic-gate return (P_SPARE); 8237c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_FAULTED) { 8247c478bd9Sstevel@tonic-gate return (P_FAULTED); 8257c478bd9Sstevel@tonic-gate } else if ((c.cpu_flags & (CPU_READY | CPU_OFFLINE)) != CPU_READY) { 8267c478bd9Sstevel@tonic-gate return (P_OFFLINE); 8277c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_ENABLE) { 8287c478bd9Sstevel@tonic-gate return (P_ONLINE); 8297c478bd9Sstevel@tonic-gate } else { 8307c478bd9Sstevel@tonic-gate return (P_NOINTR); 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate } 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8357c478bd9Sstevel@tonic-gate static long 8367c478bd9Sstevel@tonic-gate dtracemdb_sysconf(void *varg, int name) 8377c478bd9Sstevel@tonic-gate { 8387c478bd9Sstevel@tonic-gate int max_ncpus; 8397c478bd9Sstevel@tonic-gate processorid_t max_cpuid; 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate switch (name) { 8427c478bd9Sstevel@tonic-gate case _SC_CPUID_MAX: 8437c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) { 8447c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'"); 8457c478bd9Sstevel@tonic-gate return (-1); 8467c478bd9Sstevel@tonic-gate } 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate return (max_cpuid); 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate case _SC_NPROCESSORS_MAX: 8517c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) { 8527c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_ncpus'"); 8537c478bd9Sstevel@tonic-gate return (-1); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate return (max_ncpus); 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate default: 8597c478bd9Sstevel@tonic-gate mdb_warn("unexpected sysconf code %d\n", name); 8607c478bd9Sstevel@tonic-gate return (-1); 8617c478bd9Sstevel@tonic-gate } 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate const dtrace_vector_t dtrace_mdbops = { 8657c478bd9Sstevel@tonic-gate dtracemdb_ioctl, 8667c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr, 8677c478bd9Sstevel@tonic-gate dtracemdb_stat, 8687c478bd9Sstevel@tonic-gate dtracemdb_sysconf 8697c478bd9Sstevel@tonic-gate }; 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate typedef struct dtrace_dcmddata { 8727c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtdd_dtp; 8737c478bd9Sstevel@tonic-gate int dtdd_cpu; 8747c478bd9Sstevel@tonic-gate int dtdd_quiet; 8757c478bd9Sstevel@tonic-gate int dtdd_flowindent; 8767c478bd9Sstevel@tonic-gate int dtdd_heading; 877*7994dfddSDan Kimmel FILE *dtdd_output; 8787c478bd9Sstevel@tonic-gate } dtrace_dcmddata_t; 8797c478bd9Sstevel@tonic-gate 880*7994dfddSDan Kimmel /* 881*7994dfddSDan Kimmel * Helper to grab all the content from a file, spit it into a string, and erase 882*7994dfddSDan Kimmel * and reset the file. 883*7994dfddSDan Kimmel */ 884*7994dfddSDan Kimmel static void 885*7994dfddSDan Kimmel print_and_truncate_file(FILE *fp) 886*7994dfddSDan Kimmel { 887*7994dfddSDan Kimmel long len; 888*7994dfddSDan Kimmel char *out; 889*7994dfddSDan Kimmel 890*7994dfddSDan Kimmel /* flush, find length of file, seek to beginning, initialize buffer */ 891*7994dfddSDan Kimmel if (fflush(fp) || (len = ftell(fp)) < 0 || 892*7994dfddSDan Kimmel fseek(fp, 0, SEEK_SET) < 0) { 893*7994dfddSDan Kimmel mdb_warn("couldn't prepare DTrace output file: %d\n", errno); 894*7994dfddSDan Kimmel return; 895*7994dfddSDan Kimmel } 896*7994dfddSDan Kimmel 897*7994dfddSDan Kimmel out = mdb_alloc(len + 1, UM_SLEEP); 898*7994dfddSDan Kimmel out[len] = '\0'; 899*7994dfddSDan Kimmel 900*7994dfddSDan Kimmel /* read file into buffer, truncate file, and seek to beginning */ 901*7994dfddSDan Kimmel if ((fread(out, len + 1, sizeof (char), fp) == 0 && ferror(fp)) || 902*7994dfddSDan Kimmel ftruncate(fileno(fp), 0) < 0 || fseek(fp, 0, SEEK_SET) < 0) { 903*7994dfddSDan Kimmel mdb_warn("couldn't read DTrace output file: %d\n", errno); 904*7994dfddSDan Kimmel mdb_free(out, len + 1); 905*7994dfddSDan Kimmel return; 906*7994dfddSDan Kimmel } 907*7994dfddSDan Kimmel 908*7994dfddSDan Kimmel mdb_printf("%s", out); 909*7994dfddSDan Kimmel mdb_free(out, len + 1); 910*7994dfddSDan Kimmel } 911*7994dfddSDan Kimmel 9127c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9137c478bd9Sstevel@tonic-gate static int 9147c478bd9Sstevel@tonic-gate dtrace_dcmdrec(const dtrace_probedata_t *data, 9157c478bd9Sstevel@tonic-gate const dtrace_recdesc_t *rec, void *arg) 9167c478bd9Sstevel@tonic-gate { 9177c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 9187c478bd9Sstevel@tonic-gate 919*7994dfddSDan Kimmel print_and_truncate_file(dd->dtdd_output); 920*7994dfddSDan Kimmel 9217c478bd9Sstevel@tonic-gate if (rec == NULL) { 9227c478bd9Sstevel@tonic-gate /* 9237c478bd9Sstevel@tonic-gate * We have processed the final record; output the newline if 9247c478bd9Sstevel@tonic-gate * we're not in quiet mode. 9257c478bd9Sstevel@tonic-gate */ 9267c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) 9277c478bd9Sstevel@tonic-gate mdb_printf("\n"); 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 9307c478bd9Sstevel@tonic-gate } 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 9337c478bd9Sstevel@tonic-gate } 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9367c478bd9Sstevel@tonic-gate static int 9377c478bd9Sstevel@tonic-gate dtrace_dcmdprobe(const dtrace_probedata_t *data, void *arg) 9387c478bd9Sstevel@tonic-gate { 9397c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pd = data->dtpda_pdesc; 9407c478bd9Sstevel@tonic-gate processorid_t cpu = data->dtpda_cpu; 9417c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 9427c478bd9Sstevel@tonic-gate char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2]; 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate if (dd->dtdd_cpu != -1UL && dd->dtdd_cpu != cpu) 9457c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate if (dd->dtdd_heading == 0) { 9487c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 9497c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 9507c478bd9Sstevel@tonic-gate mdb_printf("%3s %6s %32s\n", 9517c478bd9Sstevel@tonic-gate "CPU", "ID", "FUNCTION:NAME"); 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate } else { 9547c478bd9Sstevel@tonic-gate mdb_printf("%3s %-41s\n", "CPU", "FUNCTION"); 9557c478bd9Sstevel@tonic-gate } 9567c478bd9Sstevel@tonic-gate dd->dtdd_heading = 1; 9577c478bd9Sstevel@tonic-gate } 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 9607c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 9617c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%s:%s", 9627c478bd9Sstevel@tonic-gate pd->dtpd_func, pd->dtpd_name); 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate mdb_printf("%3d %6d %32s ", cpu, pd->dtpd_id, name); 9657c478bd9Sstevel@tonic-gate } 9667c478bd9Sstevel@tonic-gate } else { 9677c478bd9Sstevel@tonic-gate int indent = data->dtpda_indent; 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate if (data->dtpda_flow == DTRACEFLOW_NONE) { 9707c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s:%s", 9717c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func, 9727c478bd9Sstevel@tonic-gate pd->dtpd_name); 9737c478bd9Sstevel@tonic-gate } else { 9747c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s", 9757c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func); 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate mdb_printf("%3d %-41s ", cpu, name); 9797c478bd9Sstevel@tonic-gate } 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 9827c478bd9Sstevel@tonic-gate } 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9857c478bd9Sstevel@tonic-gate static int 986a1b5e537Sbmc dtrace_dcmderr(const dtrace_errdata_t *data, void *arg) 9877c478bd9Sstevel@tonic-gate { 9887c478bd9Sstevel@tonic-gate mdb_warn(data->dteda_msg); 9897c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate 9927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9937c478bd9Sstevel@tonic-gate static int 994a1b5e537Sbmc dtrace_dcmddrop(const dtrace_dropdata_t *data, void *arg) 9957c478bd9Sstevel@tonic-gate { 9967c478bd9Sstevel@tonic-gate mdb_warn(data->dtdda_msg); 9977c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10017c478bd9Sstevel@tonic-gate static int 1002a1b5e537Sbmc dtrace_dcmdbuffered(const dtrace_bufdata_t *bufdata, void *arg) 10037c478bd9Sstevel@tonic-gate { 10047c478bd9Sstevel@tonic-gate mdb_printf("%s", bufdata->dtbda_buffered); 10057c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10097c478bd9Sstevel@tonic-gate int 10107c478bd9Sstevel@tonic-gate dtrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 10117c478bd9Sstevel@tonic-gate { 10127c478bd9Sstevel@tonic-gate dtrace_state_t state; 10137c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp; 10147c478bd9Sstevel@tonic-gate int ncpu, err; 10157c478bd9Sstevel@tonic-gate uintptr_t c = -1UL; 10167c478bd9Sstevel@tonic-gate dtrace_dcmddata_t dd; 10177c478bd9Sstevel@tonic-gate dtrace_optval_t val; 10187c478bd9Sstevel@tonic-gate dtracemdb_data_t md; 10197c478bd9Sstevel@tonic-gate int rval = DCMD_ERR; 1020c9a6ea2eSBryan Cantrill dtrace_anon_t anon; 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 10237c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'c', MDB_OPT_UINTPTR, &c, NULL) != argc) 10267c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 10297c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 10307c478bd9Sstevel@tonic-gate return (DCMD_ERR); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 10347c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", addr); 10357c478bd9Sstevel@tonic-gate return (DCMD_ERR); 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate 1038c9a6ea2eSBryan Cantrill if (state.dts_anon != NULL) { 1039c9a6ea2eSBryan Cantrill addr = (uintptr_t)state.dts_anon; 1040c9a6ea2eSBryan Cantrill 1041c9a6ea2eSBryan Cantrill if (mdb_vread(&state, sizeof (state), addr) == -1) { 1042c9a6ea2eSBryan Cantrill mdb_warn("couldn't read anonymous state at %p", addr); 1043c9a6ea2eSBryan Cantrill return (DCMD_ERR); 1044c9a6ea2eSBryan Cantrill } 1045c9a6ea2eSBryan Cantrill } 1046c9a6ea2eSBryan Cantrill 10477c478bd9Sstevel@tonic-gate bzero(&md, sizeof (md)); 10487c478bd9Sstevel@tonic-gate md.dtmd_state = &state; 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate if ((dtp = dtrace_vopen(DTRACE_VERSION, DTRACE_O_NOSYS, &err, 10517c478bd9Sstevel@tonic-gate &dtrace_mdbops, &md)) == NULL) { 10527c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 10537c478bd9Sstevel@tonic-gate dtrace_errmsg(NULL, err)); 10547c478bd9Sstevel@tonic-gate return (DCMD_ERR); 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 1057c9a6ea2eSBryan Cantrill /* 1058c9a6ea2eSBryan Cantrill * If this is the anonymous enabling, we need to set a bit indicating 1059c9a6ea2eSBryan Cantrill * that DTRACEOPT_GRABANON should be set. 1060c9a6ea2eSBryan Cantrill */ 1061c9a6ea2eSBryan Cantrill if (mdb_readvar(&anon, "dtrace_anon") == -1) { 1062c9a6ea2eSBryan Cantrill mdb_warn("failed to read 'dtrace_anon'"); 1063c9a6ea2eSBryan Cantrill return (DCMD_ERR); 1064c9a6ea2eSBryan Cantrill } 1065c9a6ea2eSBryan Cantrill 1066c9a6ea2eSBryan Cantrill md.dtmd_isanon = ((uintptr_t)anon.dta_state == addr); 1067c9a6ea2eSBryan Cantrill 10687c478bd9Sstevel@tonic-gate if (dtrace_go(dtp) != 0) { 10697c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 10707c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10717c478bd9Sstevel@tonic-gate goto err; 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate bzero(&dd, sizeof (dd)); 10757c478bd9Sstevel@tonic-gate dd.dtdd_dtp = dtp; 10767c478bd9Sstevel@tonic-gate dd.dtdd_cpu = c; 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "flowindent", &val) == -1) { 10797c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'flowindent' option: %s\n", 10807c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10817c478bd9Sstevel@tonic-gate goto err; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate dd.dtdd_flowindent = (val != DTRACEOPT_UNSET); 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "quiet", &val) == -1) { 10877c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'quiet' option: %s\n", 10887c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10897c478bd9Sstevel@tonic-gate goto err; 10907c478bd9Sstevel@tonic-gate } 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate dd.dtdd_quiet = (val != DTRACEOPT_UNSET); 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate if (dtrace_handle_err(dtp, dtrace_dcmderr, NULL) == -1) { 10957c478bd9Sstevel@tonic-gate mdb_warn("couldn't add err handler: %s\n", 10967c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10977c478bd9Sstevel@tonic-gate goto err; 10987c478bd9Sstevel@tonic-gate } 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate if (dtrace_handle_drop(dtp, dtrace_dcmddrop, NULL) == -1) { 11017c478bd9Sstevel@tonic-gate mdb_warn("couldn't add drop handler: %s\n", 11027c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11037c478bd9Sstevel@tonic-gate goto err; 11047c478bd9Sstevel@tonic-gate } 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate if (dtrace_handle_buffered(dtp, dtrace_dcmdbuffered, NULL) == -1) { 11077c478bd9Sstevel@tonic-gate mdb_warn("couldn't add buffered handler: %s\n", 11087c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11097c478bd9Sstevel@tonic-gate goto err; 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate if (dtrace_status(dtp) == -1) { 11137c478bd9Sstevel@tonic-gate mdb_warn("couldn't get status: %s\n", 11147c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11157c478bd9Sstevel@tonic-gate goto err; 11167c478bd9Sstevel@tonic-gate } 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if (dtrace_aggregate_snap(dtp) == -1) { 11197c478bd9Sstevel@tonic-gate mdb_warn("couldn't snapshot aggregation: %s\n", 11207c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11217c478bd9Sstevel@tonic-gate goto err; 11227c478bd9Sstevel@tonic-gate } 11237c478bd9Sstevel@tonic-gate 1124*7994dfddSDan Kimmel if ((dd.dtdd_output = tmpfile()) == NULL) { 1125*7994dfddSDan Kimmel mdb_warn("couldn't open DTrace output file: %d\n", errno); 1126*7994dfddSDan Kimmel goto err; 1127*7994dfddSDan Kimmel } 1128*7994dfddSDan Kimmel 1129*7994dfddSDan Kimmel if (dtrace_consume(dtp, dd.dtdd_output, 11307c478bd9Sstevel@tonic-gate dtrace_dcmdprobe, dtrace_dcmdrec, &dd) == -1) { 11317c478bd9Sstevel@tonic-gate mdb_warn("couldn't consume DTrace buffers: %s\n", 11327c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate if (dtrace_aggregate_print(dtp, NULL, NULL) == -1) { 11367c478bd9Sstevel@tonic-gate mdb_warn("couldn't print aggregation: %s\n", 11377c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 11387c478bd9Sstevel@tonic-gate goto err; 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate rval = DCMD_OK; 11427c478bd9Sstevel@tonic-gate err: 11437c478bd9Sstevel@tonic-gate dtrace_close(dtp); 1144*7994dfddSDan Kimmel fclose(dd.dtdd_output); 11457c478bd9Sstevel@tonic-gate return (rval); 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate static int 11497c478bd9Sstevel@tonic-gate dtrace_errhash_cmp(const void *l, const void *r) 11507c478bd9Sstevel@tonic-gate { 11517c478bd9Sstevel@tonic-gate uintptr_t lhs = *((uintptr_t *)l); 11527c478bd9Sstevel@tonic-gate uintptr_t rhs = *((uintptr_t *)r); 11537c478bd9Sstevel@tonic-gate dtrace_errhash_t lerr, rerr; 11547c478bd9Sstevel@tonic-gate char lmsg[256], rmsg[256]; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate (void) mdb_vread(&lerr, sizeof (lerr), lhs); 11577c478bd9Sstevel@tonic-gate (void) mdb_vread(&rerr, sizeof (rerr), rhs); 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate if (lerr.dter_msg == NULL) 11607c478bd9Sstevel@tonic-gate return (-1); 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate if (rerr.dter_msg == NULL) 11637c478bd9Sstevel@tonic-gate return (1); 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate (void) mdb_readstr(lmsg, sizeof (lmsg), (uintptr_t)lerr.dter_msg); 11667c478bd9Sstevel@tonic-gate (void) mdb_readstr(rmsg, sizeof (rmsg), (uintptr_t)rerr.dter_msg); 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate return (strcmp(lmsg, rmsg)); 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate int 11727c478bd9Sstevel@tonic-gate dtrace_errhash_init(mdb_walk_state_t *wsp) 11737c478bd9Sstevel@tonic-gate { 11747c478bd9Sstevel@tonic-gate GElf_Sym sym; 11757c478bd9Sstevel@tonic-gate uintptr_t *hash, addr; 11767c478bd9Sstevel@tonic-gate int i; 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 11797c478bd9Sstevel@tonic-gate mdb_warn("dtrace_errhash walk only supports global walks\n"); 11807c478bd9Sstevel@tonic-gate return (WALK_ERR); 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("dtrace_errhash", &sym) == -1) { 11847c478bd9Sstevel@tonic-gate mdb_warn("couldn't find 'dtrace_errhash' (non-DEBUG kernel?)"); 11857c478bd9Sstevel@tonic-gate return (WALK_ERR); 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value; 11897c478bd9Sstevel@tonic-gate hash = mdb_alloc(DTRACE_ERRHASHSZ * sizeof (uintptr_t), 11907c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACE_ERRHASHSZ; i++) 11937c478bd9Sstevel@tonic-gate hash[i] = addr + i * sizeof (dtrace_errhash_t); 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate qsort(hash, DTRACE_ERRHASHSZ, sizeof (uintptr_t), dtrace_errhash_cmp); 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 11987c478bd9Sstevel@tonic-gate wsp->walk_data = hash; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate return (WALK_NEXT); 12017c478bd9Sstevel@tonic-gate } 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate int 12047c478bd9Sstevel@tonic-gate dtrace_errhash_step(mdb_walk_state_t *wsp) 12057c478bd9Sstevel@tonic-gate { 12067c478bd9Sstevel@tonic-gate int ndx = (int)wsp->walk_addr; 12077c478bd9Sstevel@tonic-gate uintptr_t *hash = wsp->walk_data; 12087c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 12097c478bd9Sstevel@tonic-gate uintptr_t addr; 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate if (ndx >= DTRACE_ERRHASHSZ) 12127c478bd9Sstevel@tonic-gate return (WALK_DONE); 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate wsp->walk_addr = ndx + 1; 12157c478bd9Sstevel@tonic-gate addr = hash[ndx]; 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 12187c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 12197c478bd9Sstevel@tonic-gate return (WALK_DONE); 12207c478bd9Sstevel@tonic-gate } 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate if (err.dter_msg == NULL) 12237c478bd9Sstevel@tonic-gate return (WALK_NEXT); 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &err, wsp->walk_cbdata)); 12267c478bd9Sstevel@tonic-gate } 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12297c478bd9Sstevel@tonic-gate int 12307c478bd9Sstevel@tonic-gate dtrace_errhash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 12317c478bd9Sstevel@tonic-gate { 12327c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 12337c478bd9Sstevel@tonic-gate char msg[256]; 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 12367c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_errhash", "dtrace_errhash", 12377c478bd9Sstevel@tonic-gate argc, argv) == -1) { 12387c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_errhash'"); 12397c478bd9Sstevel@tonic-gate return (DCMD_ERR); 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate return (DCMD_OK); 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate 12457c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) 12467c478bd9Sstevel@tonic-gate mdb_printf("%8s %s\n", "COUNT", "ERROR"); 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 12497c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 12507c478bd9Sstevel@tonic-gate return (DCMD_ERR); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate addr = (uintptr_t)err.dter_msg; 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate if (mdb_readstr(msg, sizeof (msg), addr) == -1) { 12567c478bd9Sstevel@tonic-gate mdb_warn("failed to read error msg at %p", addr); 12577c478bd9Sstevel@tonic-gate return (DCMD_ERR); 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate mdb_printf("%8d %s", err.dter_count, msg); 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate /* 12637c478bd9Sstevel@tonic-gate * Some error messages include a newline -- only print the newline 12647c478bd9Sstevel@tonic-gate * if the message doesn't have one. 12657c478bd9Sstevel@tonic-gate */ 12667c478bd9Sstevel@tonic-gate if (msg[strlen(msg) - 1] != '\n') 12677c478bd9Sstevel@tonic-gate mdb_printf("\n"); 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate return (DCMD_OK); 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate int 12737c478bd9Sstevel@tonic-gate dtrace_helptrace_init(mdb_walk_state_t *wsp) 12747c478bd9Sstevel@tonic-gate { 12757c478bd9Sstevel@tonic-gate uint32_t next; 12767c478bd9Sstevel@tonic-gate int enabled; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 12797c478bd9Sstevel@tonic-gate mdb_warn("dtrace_helptrace only supports global walks\n"); 12807c478bd9Sstevel@tonic-gate return (WALK_ERR); 12817c478bd9Sstevel@tonic-gate } 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate if (mdb_readvar(&enabled, "dtrace_helptrace_enabled") == -1) { 12847c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_enabled'"); 12857c478bd9Sstevel@tonic-gate return (WALK_ERR); 12867c478bd9Sstevel@tonic-gate } 12877c478bd9Sstevel@tonic-gate 12887c478bd9Sstevel@tonic-gate if (!enabled) { 12897c478bd9Sstevel@tonic-gate mdb_warn("helper tracing is not enabled\n"); 12907c478bd9Sstevel@tonic-gate return (WALK_ERR); 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 12947c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 12957c478bd9Sstevel@tonic-gate return (WALK_ERR); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate wsp->walk_addr = next; 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate return (WALK_NEXT); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate int 13047c478bd9Sstevel@tonic-gate dtrace_helptrace_step(mdb_walk_state_t *wsp) 13057c478bd9Sstevel@tonic-gate { 13067c478bd9Sstevel@tonic-gate uint32_t next, size, nlocals, bufsize; 13077c478bd9Sstevel@tonic-gate uintptr_t buffer, addr; 13087c478bd9Sstevel@tonic-gate dtrace_helptrace_t *ht; 13097c478bd9Sstevel@tonic-gate int rval; 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 13127c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 13137c478bd9Sstevel@tonic-gate return (WALK_ERR); 13147c478bd9Sstevel@tonic-gate } 13157c478bd9Sstevel@tonic-gate 13167c478bd9Sstevel@tonic-gate if (mdb_readvar(&bufsize, "dtrace_helptrace_bufsize") == -1) { 13177c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_bufsize'"); 13187c478bd9Sstevel@tonic-gate return (WALK_ERR); 13197c478bd9Sstevel@tonic-gate } 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) { 13227c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_buffer'"); 13237c478bd9Sstevel@tonic-gate return (WALK_ERR); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate if (mdb_readvar(&nlocals, "dtrace_helptrace_nlocals") == -1) { 13277c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_nlocals'"); 13287c478bd9Sstevel@tonic-gate return (WALK_ERR); 13297c478bd9Sstevel@tonic-gate } 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate size = sizeof (dtrace_helptrace_t) + 13327c478bd9Sstevel@tonic-gate nlocals * sizeof (uint64_t) - sizeof (uint64_t); 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate if (wsp->walk_addr + size > bufsize) { 13357c478bd9Sstevel@tonic-gate if (next == 0) 13367c478bd9Sstevel@tonic-gate return (WALK_DONE); 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate addr = buffer + wsp->walk_addr; 13427c478bd9Sstevel@tonic-gate ht = alloca(size); 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate if (mdb_vread(ht, size, addr) == -1) { 13457c478bd9Sstevel@tonic-gate mdb_warn("couldn't read entry at %p", addr); 13467c478bd9Sstevel@tonic-gate return (WALK_ERR); 13477c478bd9Sstevel@tonic-gate } 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate if (ht->dtht_helper != NULL) { 13507c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(addr, ht, wsp->walk_cbdata); 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate if (rval != WALK_NEXT) 13537c478bd9Sstevel@tonic-gate return (rval); 13547c478bd9Sstevel@tonic-gate } 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate if (wsp->walk_addr < next && wsp->walk_addr + size >= next) 13577c478bd9Sstevel@tonic-gate return (WALK_DONE); 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate wsp->walk_addr += size; 13607c478bd9Sstevel@tonic-gate return (WALK_NEXT); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate int 13647c478bd9Sstevel@tonic-gate dtrace_helptrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 13657c478bd9Sstevel@tonic-gate { 13667c478bd9Sstevel@tonic-gate dtrace_helptrace_t help; 13677c478bd9Sstevel@tonic-gate dtrace_helper_action_t helper; 13687c478bd9Sstevel@tonic-gate char where[30]; 13697c478bd9Sstevel@tonic-gate uint_t opt_v = FALSE; 13707c478bd9Sstevel@tonic-gate uintptr_t haddr; 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 13737c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_helptrace", "dtrace_helptrace", 13747c478bd9Sstevel@tonic-gate argc, argv) == -1) { 13757c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_helptrace'"); 13767c478bd9Sstevel@tonic-gate return (DCMD_ERR); 13777c478bd9Sstevel@tonic-gate } 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate return (DCMD_OK); 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate 13827c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'v', 13837c478bd9Sstevel@tonic-gate MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc) 13847c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 13877c478bd9Sstevel@tonic-gate mdb_printf(" %?s %?s %12s %s\n", 13887c478bd9Sstevel@tonic-gate "ADDR", "HELPER", "WHERE", "DIFO"); 13897c478bd9Sstevel@tonic-gate } 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate if (mdb_vread(&help, sizeof (help), addr) == -1) { 13927c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_helptrace_t at %p", addr); 13937c478bd9Sstevel@tonic-gate return (DCMD_ERR); 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 13977c478bd9Sstevel@tonic-gate case 0: 13987c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "predicate"); 13997c478bd9Sstevel@tonic-gate break; 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 14027c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "next"); 14037c478bd9Sstevel@tonic-gate break; 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 14067c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "done"); 14077c478bd9Sstevel@tonic-gate break; 14087c478bd9Sstevel@tonic-gate 14097c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 14107c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "err"); 14117c478bd9Sstevel@tonic-gate break; 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate default: 14147c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), 14157c478bd9Sstevel@tonic-gate "action #%d", help.dtht_where); 14167c478bd9Sstevel@tonic-gate break; 14177c478bd9Sstevel@tonic-gate } 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate mdb_printf(" %?p %?p %12s ", addr, help.dtht_helper, where); 14207c478bd9Sstevel@tonic-gate 14217c478bd9Sstevel@tonic-gate haddr = (uintptr_t)help.dtht_helper; 14227c478bd9Sstevel@tonic-gate 14237c478bd9Sstevel@tonic-gate if (mdb_vread(&helper, sizeof (helper), haddr) == -1) { 14247c478bd9Sstevel@tonic-gate /* 14257c478bd9Sstevel@tonic-gate * We're not going to warn in this case -- we're just not going 14267c478bd9Sstevel@tonic-gate * to print anything exciting. 14277c478bd9Sstevel@tonic-gate */ 14287c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 14297c478bd9Sstevel@tonic-gate } else { 14307c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 14317c478bd9Sstevel@tonic-gate case 0: 143299fd1a49Sahl mdb_printf("%p\n", helper.dtha_predicate); 14337c478bd9Sstevel@tonic-gate break; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 14367c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 14377c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 14387c478bd9Sstevel@tonic-gate mdb_printf("-\n"); 14397c478bd9Sstevel@tonic-gate break; 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate default: 144299fd1a49Sahl haddr = (uintptr_t)helper.dtha_actions + 14437c478bd9Sstevel@tonic-gate (help.dtht_where - 1) * sizeof (uintptr_t); 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate if (mdb_vread(&haddr, sizeof (haddr), haddr) == -1) { 14467c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 14477c478bd9Sstevel@tonic-gate } else { 14487c478bd9Sstevel@tonic-gate mdb_printf("%p\n", haddr); 14497c478bd9Sstevel@tonic-gate } 14507c478bd9Sstevel@tonic-gate } 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate if (opt_v) { 14547c478bd9Sstevel@tonic-gate int i; 14557c478bd9Sstevel@tonic-gate 1456187eccf8Sbmc if (help.dtht_where == DTRACE_HELPTRACE_ERR) { 1457187eccf8Sbmc int f = help.dtht_fault; 1458187eccf8Sbmc 1459187eccf8Sbmc mdb_printf("%?s| %?s %10s |\n", "", "", ""); 1460187eccf8Sbmc mdb_printf("%?s| %?s %10s +-> fault: %s\n", "", "", "", 1461187eccf8Sbmc f == DTRACEFLT_BADADDR ? "BADADDR" : 1462187eccf8Sbmc f == DTRACEFLT_BADALIGN ? "BADALIGN" : 1463187eccf8Sbmc f == DTRACEFLT_ILLOP ? "ILLOP" : 1464187eccf8Sbmc f == DTRACEFLT_DIVZERO ? "DIVZERO" : 1465187eccf8Sbmc f == DTRACEFLT_NOSCRATCH ? "NOSCRATCH" : 1466187eccf8Sbmc f == DTRACEFLT_KPRIV ? "KPRIV" : 1467187eccf8Sbmc f == DTRACEFLT_UPRIV ? "UPRIV" : 1468187eccf8Sbmc f == DTRACEFLT_TUPOFLOW ? "TUPOFLOW" : 1469b8fac8e1Sjhaslam f == DTRACEFLT_BADSTACK ? "BADSTACK" : 1470187eccf8Sbmc "DTRACEFLT_UNKNOWN"); 1471187eccf8Sbmc mdb_printf("%?s| %?s %12s addr: 0x%x\n", "", "", "", 1472187eccf8Sbmc help.dtht_illval); 1473187eccf8Sbmc mdb_printf("%?s| %?s %12s offset: %d\n", "", "", "", 1474187eccf8Sbmc help.dtht_fltoffs); 1475187eccf8Sbmc } 1476187eccf8Sbmc 14777c478bd9Sstevel@tonic-gate mdb_printf("%?s|\n%?s+--> %?s %4s %s\n", "", "", 14787c478bd9Sstevel@tonic-gate "ADDR", "NDX", "VALUE"); 14797c478bd9Sstevel@tonic-gate addr += sizeof (help) - sizeof (uint64_t); 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate for (i = 0; i < help.dtht_nlocals; i++) { 14827c478bd9Sstevel@tonic-gate uint64_t val; 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate if (mdb_vread(&val, sizeof (val), addr) == -1) { 14857c478bd9Sstevel@tonic-gate mdb_warn("couldn't read local at %p", addr); 14867c478bd9Sstevel@tonic-gate continue; 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate mdb_printf("%?s %?p %4d %p\n", "", addr, i, val); 14907c478bd9Sstevel@tonic-gate addr += sizeof (uint64_t); 14917c478bd9Sstevel@tonic-gate } 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate mdb_printf("\n"); 14947c478bd9Sstevel@tonic-gate } 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate return (DCMD_OK); 14977c478bd9Sstevel@tonic-gate } 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 15007c478bd9Sstevel@tonic-gate static int 15017c478bd9Sstevel@tonic-gate dtrace_state_walk(uintptr_t addr, const vmem_seg_t *seg, minor_t *highest) 15027c478bd9Sstevel@tonic-gate { 15037c478bd9Sstevel@tonic-gate if (seg->vs_end > *highest) 15047c478bd9Sstevel@tonic-gate *highest = seg->vs_end; 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate typedef struct dtrace_state_walk { 15107c478bd9Sstevel@tonic-gate uintptr_t dtsw_softstate; 15117c478bd9Sstevel@tonic-gate minor_t dtsw_max; 15127c478bd9Sstevel@tonic-gate minor_t dtsw_current; 15137c478bd9Sstevel@tonic-gate } dtrace_state_walk_t; 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate int 15167c478bd9Sstevel@tonic-gate dtrace_state_init(mdb_walk_state_t *wsp) 15177c478bd9Sstevel@tonic-gate { 15187c478bd9Sstevel@tonic-gate uintptr_t dtrace_minor; 15197c478bd9Sstevel@tonic-gate minor_t max = 0; 15207c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw; 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 15237c478bd9Sstevel@tonic-gate mdb_warn("dtrace_state only supports global walks\n"); 15247c478bd9Sstevel@tonic-gate return (WALK_ERR); 15257c478bd9Sstevel@tonic-gate } 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate /* 15287c478bd9Sstevel@tonic-gate * Find the dtrace_minor vmem arena and walk it to get the maximum 15297c478bd9Sstevel@tonic-gate * minor number. 15307c478bd9Sstevel@tonic-gate */ 15317c478bd9Sstevel@tonic-gate if (mdb_readvar(&dtrace_minor, "dtrace_minor") == -1) { 15327c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_minor'"); 15337c478bd9Sstevel@tonic-gate return (WALK_ERR); 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate 15367c478bd9Sstevel@tonic-gate if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)dtrace_state_walk, 15377c478bd9Sstevel@tonic-gate &max, dtrace_minor) == -1) { 15387c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'vmem_alloc'"); 15397c478bd9Sstevel@tonic-gate return (WALK_ERR); 15407c478bd9Sstevel@tonic-gate } 15417c478bd9Sstevel@tonic-gate 15427c478bd9Sstevel@tonic-gate dw = mdb_zalloc(sizeof (dtrace_state_walk_t), UM_SLEEP | UM_GC); 15437c478bd9Sstevel@tonic-gate dw->dtsw_current = 0; 15447c478bd9Sstevel@tonic-gate dw->dtsw_max = max; 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate if (mdb_readvar(&dw->dtsw_softstate, "dtrace_softstate") == -1) { 15477c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 15487c478bd9Sstevel@tonic-gate return (DCMD_ERR); 15497c478bd9Sstevel@tonic-gate } 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate wsp->walk_data = dw; 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate int 15577c478bd9Sstevel@tonic-gate dtrace_state_step(mdb_walk_state_t *wsp) 15587c478bd9Sstevel@tonic-gate { 15597c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw = wsp->walk_data; 15607c478bd9Sstevel@tonic-gate uintptr_t statep; 15617c478bd9Sstevel@tonic-gate dtrace_state_t state; 15627c478bd9Sstevel@tonic-gate int rval; 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate while (mdb_get_soft_state_byaddr(dw->dtsw_softstate, dw->dtsw_current, 15657c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 15667c478bd9Sstevel@tonic-gate if (dw->dtsw_current >= dw->dtsw_max) 15677c478bd9Sstevel@tonic-gate return (WALK_DONE); 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate dw->dtsw_current++; 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), statep) == -1) { 15737c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", statep); 15747c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15757c478bd9Sstevel@tonic-gate } 15767c478bd9Sstevel@tonic-gate 15777c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(statep, &state, wsp->walk_cbdata); 15787c478bd9Sstevel@tonic-gate dw->dtsw_current++; 15797c478bd9Sstevel@tonic-gate 15807c478bd9Sstevel@tonic-gate return (rval); 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate typedef struct dtrace_state_data { 15847c478bd9Sstevel@tonic-gate int dtsd_major; 15857c478bd9Sstevel@tonic-gate uintptr_t dtsd_proc; 15867c478bd9Sstevel@tonic-gate uintptr_t dtsd_softstate; 15877c478bd9Sstevel@tonic-gate uintptr_t dtsd_state; 15887c478bd9Sstevel@tonic-gate } dtrace_state_data_t; 15897c478bd9Sstevel@tonic-gate 15907c478bd9Sstevel@tonic-gate static int 15917c478bd9Sstevel@tonic-gate dtrace_state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data) 15927c478bd9Sstevel@tonic-gate { 15937c478bd9Sstevel@tonic-gate vnode_t vnode; 15947c478bd9Sstevel@tonic-gate proc_t proc; 15957c478bd9Sstevel@tonic-gate minor_t minor; 15967c478bd9Sstevel@tonic-gate uintptr_t statep; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) { 15997c478bd9Sstevel@tonic-gate mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode); 16007c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16017c478bd9Sstevel@tonic-gate } 16027c478bd9Sstevel@tonic-gate 16037c478bd9Sstevel@tonic-gate if (getmajor(vnode.v_rdev) != data->dtsd_major) 16047c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate minor = getminor(vnode.v_rdev); 16077c478bd9Sstevel@tonic-gate 16087c478bd9Sstevel@tonic-gate if (mdb_vread(&proc, sizeof (proc), data->dtsd_proc) == -1) { 16097c478bd9Sstevel@tonic-gate mdb_warn("failed to read proc at %p", data->dtsd_proc); 16107c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor, 16147c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 16157c478bd9Sstevel@tonic-gate mdb_warn("failed to read softstate for minor %d", minor); 16167c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16177c478bd9Sstevel@tonic-gate } 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate if (statep != data->dtsd_state) 16207c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16217c478bd9Sstevel@tonic-gate 16227c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?p %-*s %?p\n", statep, minor, 16237c478bd9Sstevel@tonic-gate data->dtsd_proc, MAXCOMLEN, proc.p_user.u_comm, addr); 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 16297c478bd9Sstevel@tonic-gate static int 16307c478bd9Sstevel@tonic-gate dtrace_state_proc(uintptr_t addr, void *ignored, dtrace_state_data_t *data) 16317c478bd9Sstevel@tonic-gate { 16327c478bd9Sstevel@tonic-gate data->dtsd_proc = addr; 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate if (mdb_pwalk("file", 16357c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_state_file, data, addr) == -1) { 16367c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'file' for proc %p", addr); 16377c478bd9Sstevel@tonic-gate return (WALK_ERR); 16387c478bd9Sstevel@tonic-gate } 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16417c478bd9Sstevel@tonic-gate } 16427c478bd9Sstevel@tonic-gate 16437c478bd9Sstevel@tonic-gate void 16447c478bd9Sstevel@tonic-gate dtrace_state_help(void) 16457c478bd9Sstevel@tonic-gate { 16467c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure, displays all " 16477c478bd9Sstevel@tonic-gate /*CSTYLED*/ 16487c478bd9Sstevel@tonic-gate "consumers, or \"<anonymous>\"\nif the consumer is anonymous. If " 16497c478bd9Sstevel@tonic-gate "no state structure is provided, iterates\nover all state " 16507c478bd9Sstevel@tonic-gate "structures.\n\n" 16517c478bd9Sstevel@tonic-gate "Addresses in ADDR column may be provided to ::dtrace to obtain\n" 16527c478bd9Sstevel@tonic-gate "dtrace(1M)-like output for in-kernel DTrace data.\n"); 16537c478bd9Sstevel@tonic-gate } 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate int 16567c478bd9Sstevel@tonic-gate dtrace_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 16577c478bd9Sstevel@tonic-gate { 16587c478bd9Sstevel@tonic-gate uintptr_t devi; 16597c478bd9Sstevel@tonic-gate struct dev_info info; 16607c478bd9Sstevel@tonic-gate dtrace_state_data_t data; 16617c478bd9Sstevel@tonic-gate dtrace_anon_t anon; 16627c478bd9Sstevel@tonic-gate dtrace_state_t state; 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 16657c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_state", 16667c478bd9Sstevel@tonic-gate "dtrace_state", argc, argv) == -1) { 16677c478bd9Sstevel@tonic-gate mdb_warn("can't walk dtrace_state"); 16687c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate return (DCMD_OK); 16717c478bd9Sstevel@tonic-gate } 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 16747c478bd9Sstevel@tonic-gate mdb_printf("%?s %5s %?s %-*s %?s\n", "ADDR", "MINOR", "PROC", 16757c478bd9Sstevel@tonic-gate MAXCOMLEN, "NAME", "FILE"); 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate /* 16797c478bd9Sstevel@tonic-gate * First determine if this is anonymous state. 16807c478bd9Sstevel@tonic-gate */ 16817c478bd9Sstevel@tonic-gate if (mdb_readvar(&anon, "dtrace_anon") == -1) { 16827c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_anon'"); 16837c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate if ((uintptr_t)anon.dta_state == addr) { 16877c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 16887c478bd9Sstevel@tonic-gate mdb_warn("failed to read anon at %p", addr); 16897c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?s %-*s %?s\n", addr, 16937c478bd9Sstevel@tonic-gate getminor(state.dts_dev), "-", MAXCOMLEN, 16947c478bd9Sstevel@tonic-gate "<anonymous>", "-"); 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate return (DCMD_OK); 16977c478bd9Sstevel@tonic-gate } 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate if (mdb_readvar(&devi, "dtrace_devi") == -1) { 17007c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_devi'"); 17017c478bd9Sstevel@tonic-gate return (DCMD_ERR); 17027c478bd9Sstevel@tonic-gate } 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) { 17057c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dev_info'"); 17067c478bd9Sstevel@tonic-gate return (DCMD_ERR); 17077c478bd9Sstevel@tonic-gate } 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate data.dtsd_major = info.devi_major; 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate if (mdb_readvar(&data.dtsd_softstate, "dtrace_softstate") == -1) { 17127c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 17137c478bd9Sstevel@tonic-gate return (DCMD_ERR); 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate data.dtsd_state = addr; 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate /* 17197c478bd9Sstevel@tonic-gate * Walk through all processes and all open files looking for this 17207c478bd9Sstevel@tonic-gate * state. It must be open somewhere... 17217c478bd9Sstevel@tonic-gate */ 17227c478bd9Sstevel@tonic-gate if (mdb_walk("proc", (mdb_walk_cb_t)dtrace_state_proc, &data) == -1) { 17237c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'proc'"); 17247c478bd9Sstevel@tonic-gate return (DCMD_ERR); 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate return (DCMD_OK); 17287c478bd9Sstevel@tonic-gate } 17297c478bd9Sstevel@tonic-gate 17307c478bd9Sstevel@tonic-gate typedef struct dtrace_aggkey_data { 17317c478bd9Sstevel@tonic-gate uintptr_t *dtakd_hash; 17327c478bd9Sstevel@tonic-gate uintptr_t dtakd_hashsize; 17337c478bd9Sstevel@tonic-gate uintptr_t dtakd_next; 17347c478bd9Sstevel@tonic-gate uintptr_t dtakd_ndx; 17357c478bd9Sstevel@tonic-gate } dtrace_aggkey_data_t; 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate int 17387c478bd9Sstevel@tonic-gate dtrace_aggkey_init(mdb_walk_state_t *wsp) 17397c478bd9Sstevel@tonic-gate { 17407c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 17417c478bd9Sstevel@tonic-gate uintptr_t addr; 17427c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 17437c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data; 17447c478bd9Sstevel@tonic-gate size_t hsize; 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 17477c478bd9Sstevel@tonic-gate mdb_warn("dtrace_aggkey walk needs aggregation buffer\n"); 17487c478bd9Sstevel@tonic-gate return (WALK_ERR); 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 17527c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 17537c478bd9Sstevel@tonic-gate return (WALK_ERR); 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate addr = (uintptr_t)buf.dtb_tomax + 17577c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), addr) == -1) { 17607c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", addr); 17617c478bd9Sstevel@tonic-gate return (WALK_ERR); 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_aggkey_data_t), UM_SLEEP); 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate data->dtakd_hashsize = agb.dtagb_hashsize; 17677c478bd9Sstevel@tonic-gate hsize = agb.dtagb_hashsize * sizeof (dtrace_aggkey_t *); 17687c478bd9Sstevel@tonic-gate data->dtakd_hash = mdb_alloc(hsize, UM_SLEEP); 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtakd_hash, hsize, 17717c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash) == -1) { 17727c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 17737c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash); 17747c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 17757c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 17767c478bd9Sstevel@tonic-gate return (WALK_ERR); 17777c478bd9Sstevel@tonic-gate } 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate wsp->walk_data = data; 17807c478bd9Sstevel@tonic-gate return (WALK_NEXT); 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate 17837c478bd9Sstevel@tonic-gate int 17847c478bd9Sstevel@tonic-gate dtrace_aggkey_step(mdb_walk_state_t *wsp) 17857c478bd9Sstevel@tonic-gate { 17867c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 17877c478bd9Sstevel@tonic-gate dtrace_aggkey_t key; 17887c478bd9Sstevel@tonic-gate uintptr_t addr; 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate while ((addr = data->dtakd_next) == NULL) { 17917c478bd9Sstevel@tonic-gate if (data->dtakd_ndx == data->dtakd_hashsize) 17927c478bd9Sstevel@tonic-gate return (WALK_DONE); 17937c478bd9Sstevel@tonic-gate 17947c478bd9Sstevel@tonic-gate data->dtakd_next = data->dtakd_hash[data->dtakd_ndx++]; 17957c478bd9Sstevel@tonic-gate } 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate if (mdb_vread(&key, sizeof (key), addr) == -1) { 17987c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggkey_t at %p", addr); 17997c478bd9Sstevel@tonic-gate return (WALK_ERR); 18007c478bd9Sstevel@tonic-gate } 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate data->dtakd_next = (uintptr_t)key.dtak_next; 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &key, wsp->walk_cbdata)); 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate void 18087c478bd9Sstevel@tonic-gate dtrace_aggkey_fini(mdb_walk_state_t *wsp) 18097c478bd9Sstevel@tonic-gate { 18107c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 18117c478bd9Sstevel@tonic-gate size_t hsize; 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate hsize = data->dtakd_hashsize * sizeof (dtrace_aggkey_t *); 18147c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 18157c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate typedef struct dtrace_dynvar_data { 18197c478bd9Sstevel@tonic-gate dtrace_dynhash_t *dtdvd_hash; 18207c478bd9Sstevel@tonic-gate uintptr_t dtdvd_hashsize; 18217c478bd9Sstevel@tonic-gate uintptr_t dtdvd_next; 18227c478bd9Sstevel@tonic-gate uintptr_t dtdvd_ndx; 1823c9a6ea2eSBryan Cantrill uintptr_t dtdvd_sink; 18247c478bd9Sstevel@tonic-gate } dtrace_dynvar_data_t; 18257c478bd9Sstevel@tonic-gate 18267c478bd9Sstevel@tonic-gate int 18277c478bd9Sstevel@tonic-gate dtrace_dynvar_init(mdb_walk_state_t *wsp) 18287c478bd9Sstevel@tonic-gate { 18297c478bd9Sstevel@tonic-gate uintptr_t addr; 18307c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 18317c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data; 18327c478bd9Sstevel@tonic-gate size_t hsize; 1833c9a6ea2eSBryan Cantrill GElf_Sym sym; 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 18367c478bd9Sstevel@tonic-gate mdb_warn("dtrace_dynvar walk needs dtrace_dstate_t\n"); 18377c478bd9Sstevel@tonic-gate return (WALK_ERR); 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 18417c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic state at %p", addr); 18427c478bd9Sstevel@tonic-gate return (WALK_ERR); 18437c478bd9Sstevel@tonic-gate } 18447c478bd9Sstevel@tonic-gate 1845c9a6ea2eSBryan Cantrill if (mdb_lookup_by_name("dtrace_dynhash_sink", &sym) == -1) { 1846c9a6ea2eSBryan Cantrill mdb_warn("couldn't find 'dtrace_dynhash_sink'"); 1847c9a6ea2eSBryan Cantrill return (WALK_ERR); 1848c9a6ea2eSBryan Cantrill } 1849c9a6ea2eSBryan Cantrill 18507c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_dynvar_data_t), UM_SLEEP); 18517c478bd9Sstevel@tonic-gate 18527c478bd9Sstevel@tonic-gate data->dtdvd_hashsize = dstate.dtds_hashsize; 18537c478bd9Sstevel@tonic-gate hsize = dstate.dtds_hashsize * sizeof (dtrace_dynhash_t); 18547c478bd9Sstevel@tonic-gate data->dtdvd_hash = mdb_alloc(hsize, UM_SLEEP); 1855c9a6ea2eSBryan Cantrill data->dtdvd_sink = (uintptr_t)sym.st_value; 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtdvd_hash, hsize, 18587c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash) == -1) { 18597c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 18607c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash); 18617c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 18627c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 18637c478bd9Sstevel@tonic-gate return (WALK_ERR); 18647c478bd9Sstevel@tonic-gate } 18657c478bd9Sstevel@tonic-gate 1866c9a6ea2eSBryan Cantrill data->dtdvd_next = (uintptr_t)data->dtdvd_hash[0].dtdh_chain; 1867c9a6ea2eSBryan Cantrill 18687c478bd9Sstevel@tonic-gate wsp->walk_data = data; 18697c478bd9Sstevel@tonic-gate return (WALK_NEXT); 18707c478bd9Sstevel@tonic-gate } 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate int 18737c478bd9Sstevel@tonic-gate dtrace_dynvar_step(mdb_walk_state_t *wsp) 18747c478bd9Sstevel@tonic-gate { 18757c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 18767c478bd9Sstevel@tonic-gate dtrace_dynvar_t dynvar, *dvar; 18777c478bd9Sstevel@tonic-gate size_t dvarsize; 18787c478bd9Sstevel@tonic-gate uintptr_t addr; 18797c478bd9Sstevel@tonic-gate int nkeys; 18807c478bd9Sstevel@tonic-gate 1881c9a6ea2eSBryan Cantrill while ((addr = data->dtdvd_next) == data->dtdvd_sink) { 18827c478bd9Sstevel@tonic-gate if (data->dtdvd_ndx == data->dtdvd_hashsize) 18837c478bd9Sstevel@tonic-gate return (WALK_DONE); 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate data->dtdvd_next = 18867c478bd9Sstevel@tonic-gate (uintptr_t)data->dtdvd_hash[data->dtdvd_ndx++].dtdh_chain; 18877c478bd9Sstevel@tonic-gate } 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate if (mdb_vread(&dynvar, sizeof (dynvar), addr) == -1) { 18907c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 18917c478bd9Sstevel@tonic-gate return (WALK_ERR); 18927c478bd9Sstevel@tonic-gate } 18937c478bd9Sstevel@tonic-gate 18947c478bd9Sstevel@tonic-gate /* 18957c478bd9Sstevel@tonic-gate * Now we need to allocate the correct size. 18967c478bd9Sstevel@tonic-gate */ 18977c478bd9Sstevel@tonic-gate nkeys = dynvar.dtdv_tuple.dtt_nkeys; 18987c478bd9Sstevel@tonic-gate dvarsize = (uintptr_t)&dynvar.dtdv_tuple.dtt_key[nkeys] - 18997c478bd9Sstevel@tonic-gate (uintptr_t)&dynvar; 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate dvar = alloca(dvarsize); 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate if (mdb_vread(dvar, dvarsize, addr) == -1) { 19047c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 19057c478bd9Sstevel@tonic-gate return (WALK_ERR); 19067c478bd9Sstevel@tonic-gate } 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate data->dtdvd_next = (uintptr_t)dynvar.dtdv_next; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, dvar, wsp->walk_cbdata)); 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate 19137c478bd9Sstevel@tonic-gate void 19147c478bd9Sstevel@tonic-gate dtrace_dynvar_fini(mdb_walk_state_t *wsp) 19157c478bd9Sstevel@tonic-gate { 19167c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 19177c478bd9Sstevel@tonic-gate size_t hsize; 19187c478bd9Sstevel@tonic-gate 19197c478bd9Sstevel@tonic-gate hsize = data->dtdvd_hashsize * sizeof (dtrace_dynvar_t *); 19207c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 19217c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 19227c478bd9Sstevel@tonic-gate } 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate typedef struct dtrace_hashstat_data { 19257c478bd9Sstevel@tonic-gate size_t *dthsd_counts; 19267c478bd9Sstevel@tonic-gate size_t dthsd_hashsize; 19277c478bd9Sstevel@tonic-gate char *dthsd_data; 19287c478bd9Sstevel@tonic-gate size_t dthsd_size; 19297c478bd9Sstevel@tonic-gate int dthsd_header; 19307c478bd9Sstevel@tonic-gate } dtrace_hashstat_data_t; 19317c478bd9Sstevel@tonic-gate 19327c478bd9Sstevel@tonic-gate typedef void (*dtrace_hashstat_func_t)(dtrace_hashstat_data_t *); 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate static void 19357c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(dtrace_hashstat_data_t *data) 19367c478bd9Sstevel@tonic-gate { 19377c478bd9Sstevel@tonic-gate int i; 19387c478bd9Sstevel@tonic-gate int hval = 0; 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 19417c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 19447c478bd9Sstevel@tonic-gate } 19457c478bd9Sstevel@tonic-gate 19467c478bd9Sstevel@tonic-gate static void 19477c478bd9Sstevel@tonic-gate dtrace_hashstat_shifty(dtrace_hashstat_data_t *data) 19487c478bd9Sstevel@tonic-gate { 19497c478bd9Sstevel@tonic-gate uint64_t hval = 0; 19507c478bd9Sstevel@tonic-gate int i; 19517c478bd9Sstevel@tonic-gate 19527c478bd9Sstevel@tonic-gate if (data->dthsd_size < sizeof (uint64_t)) { 19537c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(data); 19547c478bd9Sstevel@tonic-gate return; 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i += sizeof (uint64_t)) { 19587c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 19597c478bd9Sstevel@tonic-gate uint64_t val = *((uint64_t *)&data->dthsd_data[i]); 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate hval += (val & ((1 << NBBY) - 1)) + 19627c478bd9Sstevel@tonic-gate ((val >> NBBY) & ((1 << NBBY) - 1)) + 19637c478bd9Sstevel@tonic-gate ((val >> (NBBY << 1)) & ((1 << NBBY) - 1)) + 19647c478bd9Sstevel@tonic-gate ((val >> (NBBY << 2)) & ((1 << NBBY) - 1)) + 19657c478bd9Sstevel@tonic-gate (val & USHRT_MAX) + (val >> (NBBY << 1) & USHRT_MAX); 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 19697c478bd9Sstevel@tonic-gate } 19707c478bd9Sstevel@tonic-gate 19717c478bd9Sstevel@tonic-gate static void 19727c478bd9Sstevel@tonic-gate dtrace_hashstat_knuth(dtrace_hashstat_data_t *data) 19737c478bd9Sstevel@tonic-gate { 19747c478bd9Sstevel@tonic-gate int i; 19757c478bd9Sstevel@tonic-gate int hval = data->dthsd_size; 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 19787c478bd9Sstevel@tonic-gate hval = (hval << 4) ^ (hval >> 28) ^ data->dthsd_data[i]; 19797c478bd9Sstevel@tonic-gate 19807c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 19817c478bd9Sstevel@tonic-gate } 19827c478bd9Sstevel@tonic-gate 19837c478bd9Sstevel@tonic-gate static void 19847c478bd9Sstevel@tonic-gate dtrace_hashstat_oneatatime(dtrace_hashstat_data_t *data) 19857c478bd9Sstevel@tonic-gate { 19867c478bd9Sstevel@tonic-gate int i; 19877c478bd9Sstevel@tonic-gate uint32_t hval = 0; 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 19907c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 19917c478bd9Sstevel@tonic-gate hval += (hval << 10); 19927c478bd9Sstevel@tonic-gate hval ^= (hval >> 6); 19937c478bd9Sstevel@tonic-gate } 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate hval += (hval << 3); 19967c478bd9Sstevel@tonic-gate hval ^= (hval >> 11); 19977c478bd9Sstevel@tonic-gate hval += (hval << 15); 19987c478bd9Sstevel@tonic-gate 19997c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 20007c478bd9Sstevel@tonic-gate } 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate static void 20037c478bd9Sstevel@tonic-gate dtrace_hashstat_fnv(dtrace_hashstat_data_t *data) 20047c478bd9Sstevel@tonic-gate { 20057c478bd9Sstevel@tonic-gate static const uint32_t prime = 0x01000193; 20067c478bd9Sstevel@tonic-gate uint32_t hval = 0; 20077c478bd9Sstevel@tonic-gate int i; 20087c478bd9Sstevel@tonic-gate 20097c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 20107c478bd9Sstevel@tonic-gate hval *= prime; 20117c478bd9Sstevel@tonic-gate hval ^= data->dthsd_data[i]; 20127c478bd9Sstevel@tonic-gate } 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 20157c478bd9Sstevel@tonic-gate } 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate static void 20187c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(char *name, dtrace_hashstat_data_t *data) 20197c478bd9Sstevel@tonic-gate { 20207c478bd9Sstevel@tonic-gate size_t nz = 0, i; 20217c478bd9Sstevel@tonic-gate int longest = 0; 20227c478bd9Sstevel@tonic-gate size_t ttl = 0; 20237c478bd9Sstevel@tonic-gate double sum = 0.0; 20247c478bd9Sstevel@tonic-gate double avg; 20257c478bd9Sstevel@tonic-gate uint_t util, stddev; 20267c478bd9Sstevel@tonic-gate 20277c478bd9Sstevel@tonic-gate if (!data->dthsd_header) { 20287c478bd9Sstevel@tonic-gate mdb_printf("%15s %11s %11s %11s %11s %11s\n", "NAME", 20297c478bd9Sstevel@tonic-gate "HASHSIZE", "%UTIL", "LONGEST", "AVERAGE", "STDDEV"); 20307c478bd9Sstevel@tonic-gate data->dthsd_header = 1; 20317c478bd9Sstevel@tonic-gate } 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 20347c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] != 0) { 20357c478bd9Sstevel@tonic-gate nz++; 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] > longest) 20387c478bd9Sstevel@tonic-gate longest = data->dthsd_counts[i]; 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate ttl += data->dthsd_counts[i]; 20417c478bd9Sstevel@tonic-gate } 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate 20447c478bd9Sstevel@tonic-gate if (nz == 0) { 20457c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %11s %11s %11s %11s\n", name, 20467c478bd9Sstevel@tonic-gate data->dthsd_hashsize, "-", "-", "-", "-"); 20477c478bd9Sstevel@tonic-gate return; 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate avg = (double)ttl / (double)nz; 20517c478bd9Sstevel@tonic-gate 20527c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 20537c478bd9Sstevel@tonic-gate double delta = (double)data->dthsd_counts[i] - avg; 20547c478bd9Sstevel@tonic-gate 20557c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] == 0) 20567c478bd9Sstevel@tonic-gate continue; 20577c478bd9Sstevel@tonic-gate 20587c478bd9Sstevel@tonic-gate sum += delta * delta; 20597c478bd9Sstevel@tonic-gate } 20607c478bd9Sstevel@tonic-gate 20617c478bd9Sstevel@tonic-gate util = (nz * 1000) / data->dthsd_hashsize; 20627c478bd9Sstevel@tonic-gate stddev = (uint_t)sqrt(sum / (double)nz) * 10; 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %9u.%1u %11d %11d %9u.%1u\n", name, 20657c478bd9Sstevel@tonic-gate data->dthsd_hashsize, util / 10, util % 10, longest, ttl / nz, 20667c478bd9Sstevel@tonic-gate stddev / 10, stddev % 10); 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate static struct dtrace_hashstat { 20707c478bd9Sstevel@tonic-gate char *dths_name; 20717c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dths_func; 20727c478bd9Sstevel@tonic-gate } _dtrace_hashstat[] = { 20737c478bd9Sstevel@tonic-gate { "<actual>", NULL }, 20747c478bd9Sstevel@tonic-gate { "additive", dtrace_hashstat_additive }, 20757c478bd9Sstevel@tonic-gate { "shifty", dtrace_hashstat_shifty }, 20767c478bd9Sstevel@tonic-gate { "knuth", dtrace_hashstat_knuth }, 20777c478bd9Sstevel@tonic-gate { "one-at-a-time", dtrace_hashstat_oneatatime }, 20787c478bd9Sstevel@tonic-gate { "fnv", dtrace_hashstat_fnv }, 20797c478bd9Sstevel@tonic-gate { NULL, 0 } 20807c478bd9Sstevel@tonic-gate }; 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate typedef struct dtrace_aggstat_data { 20837c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t dtagsd_hash; 20847c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dtagsd_func; 20857c478bd9Sstevel@tonic-gate } dtrace_aggstat_data_t; 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate static int 20887c478bd9Sstevel@tonic-gate dtrace_aggstat_walk(uintptr_t addr, dtrace_aggkey_t *key, 20897c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 20907c478bd9Sstevel@tonic-gate { 20917c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 20927c478bd9Sstevel@tonic-gate size_t size; 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 20957c478bd9Sstevel@tonic-gate size_t bucket = key->dtak_hashval % hdata->dthsd_hashsize; 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 20987c478bd9Sstevel@tonic-gate return (WALK_NEXT); 20997c478bd9Sstevel@tonic-gate } 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate /* 21027c478bd9Sstevel@tonic-gate * We need to read the data. 21037c478bd9Sstevel@tonic-gate */ 21047c478bd9Sstevel@tonic-gate size = key->dtak_size - sizeof (dtrace_aggid_t); 21057c478bd9Sstevel@tonic-gate addr = (uintptr_t)key->dtak_data + sizeof (dtrace_aggid_t); 21067c478bd9Sstevel@tonic-gate hdata->dthsd_data = alloca(size); 21077c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate if (mdb_vread(hdata->dthsd_data, size, addr) == -1) { 21107c478bd9Sstevel@tonic-gate mdb_warn("couldn't read data at %p", addr); 21117c478bd9Sstevel@tonic-gate return (WALK_ERR); 21127c478bd9Sstevel@tonic-gate } 21137c478bd9Sstevel@tonic-gate 21147c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate return (WALK_NEXT); 21177c478bd9Sstevel@tonic-gate } 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21207c478bd9Sstevel@tonic-gate int 21217c478bd9Sstevel@tonic-gate dtrace_aggstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 21227c478bd9Sstevel@tonic-gate { 21237c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 21247c478bd9Sstevel@tonic-gate uintptr_t aaddr; 21257c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 21267c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime, evenpow; 21277c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 21287c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 21297c478bd9Sstevel@tonic-gate 21307c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 21337c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 21347c478bd9Sstevel@tonic-gate 21357c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 21367c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 21377c478bd9Sstevel@tonic-gate return (DCMD_ERR); 21387c478bd9Sstevel@tonic-gate } 21397c478bd9Sstevel@tonic-gate 21407c478bd9Sstevel@tonic-gate aaddr = (uintptr_t)buf.dtb_tomax + 21417c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), aaddr) == -1) { 21447c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", aaddr); 21457c478bd9Sstevel@tonic-gate return (DCMD_ERR); 21467c478bd9Sstevel@tonic-gate } 21477c478bd9Sstevel@tonic-gate 21487c478bd9Sstevel@tonic-gate hsize = (actual = agb.dtagb_hashsize) * sizeof (size_t); 21497c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 21507c478bd9Sstevel@tonic-gate 21517c478bd9Sstevel@tonic-gate /* 21527c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 21537c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 21547c478bd9Sstevel@tonic-gate * hell of it.) 21557c478bd9Sstevel@tonic-gate */ 21567c478bd9Sstevel@tonic-gate for (prime = agb.dtagb_hashsize - 1; prime > 7; prime--) { 21577c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 21607c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 21617c478bd9Sstevel@tonic-gate break; 21627c478bd9Sstevel@tonic-gate } 21637c478bd9Sstevel@tonic-gate 21647c478bd9Sstevel@tonic-gate if (i == limit) 21657c478bd9Sstevel@tonic-gate break; 21667c478bd9Sstevel@tonic-gate } 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate /* 21697c478bd9Sstevel@tonic-gate * And now we want to pick the largest power of two smaller than the 21707c478bd9Sstevel@tonic-gate * hashsize. 21717c478bd9Sstevel@tonic-gate */ 21727c478bd9Sstevel@tonic-gate for (i = 0; (1 << i) < agb.dtagb_hashsize; i++) 21737c478bd9Sstevel@tonic-gate continue; 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate evenpow = (1 << (i - 1)); 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 21787c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 21817c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 21827c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 21857c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 21867c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 21877c478bd9Sstevel@tonic-gate return (DCMD_ERR); 21887c478bd9Sstevel@tonic-gate } 21897c478bd9Sstevel@tonic-gate 21907c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate /* 21937c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 21947c478bd9Sstevel@tonic-gate * any of the sizing experiments. 21957c478bd9Sstevel@tonic-gate */ 21967c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 21977c478bd9Sstevel@tonic-gate continue; 21987c478bd9Sstevel@tonic-gate 21997c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 22007c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 22017c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 22047c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 22057c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 22067c478bd9Sstevel@tonic-gate return (DCMD_ERR); 22077c478bd9Sstevel@tonic-gate } 22087c478bd9Sstevel@tonic-gate 22097c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 22107c478bd9Sstevel@tonic-gate 22117c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = evenpow; 22127c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 22137c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 22147c478bd9Sstevel@tonic-gate 22157c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 22167c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 22177c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 22187c478bd9Sstevel@tonic-gate return (DCMD_ERR); 22197c478bd9Sstevel@tonic-gate } 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 22227c478bd9Sstevel@tonic-gate } 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate return (DCMD_OK); 22257c478bd9Sstevel@tonic-gate } 22267c478bd9Sstevel@tonic-gate 22277c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 22287c478bd9Sstevel@tonic-gate static int 22297c478bd9Sstevel@tonic-gate dtrace_dynstat_walk(uintptr_t addr, dtrace_dynvar_t *dynvar, 22307c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 22317c478bd9Sstevel@tonic-gate { 22327c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 22337c478bd9Sstevel@tonic-gate dtrace_tuple_t *tuple = &dynvar->dtdv_tuple; 22347c478bd9Sstevel@tonic-gate dtrace_key_t *key = tuple->dtt_key; 22357c478bd9Sstevel@tonic-gate size_t size = 0, offs = 0; 22367c478bd9Sstevel@tonic-gate int i, nkeys = tuple->dtt_nkeys; 22377c478bd9Sstevel@tonic-gate char *buf; 22387c478bd9Sstevel@tonic-gate 22397c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 22407c478bd9Sstevel@tonic-gate size_t bucket = dynvar->dtdv_hashval % hdata->dthsd_hashsize; 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 22437c478bd9Sstevel@tonic-gate return (WALK_NEXT); 22447c478bd9Sstevel@tonic-gate } 22457c478bd9Sstevel@tonic-gate 22467c478bd9Sstevel@tonic-gate /* 22477c478bd9Sstevel@tonic-gate * We want to hand the hashing algorithm a contiguous buffer. First 22487c478bd9Sstevel@tonic-gate * run through the tuple and determine the size. 22497c478bd9Sstevel@tonic-gate */ 22507c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 22517c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 22527c478bd9Sstevel@tonic-gate size += sizeof (uint64_t); 22537c478bd9Sstevel@tonic-gate } else { 22547c478bd9Sstevel@tonic-gate size += key[i].dttk_size; 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate } 22577c478bd9Sstevel@tonic-gate 22587c478bd9Sstevel@tonic-gate buf = alloca(size); 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate /* 22617c478bd9Sstevel@tonic-gate * Now go back through the tuple and copy the data into the buffer. 22627c478bd9Sstevel@tonic-gate */ 22637c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 22647c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 22657c478bd9Sstevel@tonic-gate bcopy(&key[i].dttk_value, &buf[offs], 22667c478bd9Sstevel@tonic-gate sizeof (uint64_t)); 22677c478bd9Sstevel@tonic-gate offs += sizeof (uint64_t); 22687c478bd9Sstevel@tonic-gate } else { 22697c478bd9Sstevel@tonic-gate if (mdb_vread(&buf[offs], key[i].dttk_size, 22707c478bd9Sstevel@tonic-gate key[i].dttk_value) == -1) { 22717c478bd9Sstevel@tonic-gate mdb_warn("couldn't read tuple data at %p", 22727c478bd9Sstevel@tonic-gate key[i].dttk_value); 22737c478bd9Sstevel@tonic-gate return (WALK_ERR); 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate offs += key[i].dttk_size; 22777c478bd9Sstevel@tonic-gate } 22787c478bd9Sstevel@tonic-gate } 22797c478bd9Sstevel@tonic-gate 22807c478bd9Sstevel@tonic-gate hdata->dthsd_data = buf; 22817c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate return (WALK_NEXT); 22867c478bd9Sstevel@tonic-gate } 22877c478bd9Sstevel@tonic-gate 22887c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 22897c478bd9Sstevel@tonic-gate int 22907c478bd9Sstevel@tonic-gate dtrace_dynstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 22917c478bd9Sstevel@tonic-gate { 22927c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 22937c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime; 22947c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 22957c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 22987c478bd9Sstevel@tonic-gate 22997c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 23007c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 23037c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic variable state at %p", addr); 23047c478bd9Sstevel@tonic-gate return (DCMD_ERR); 23057c478bd9Sstevel@tonic-gate } 23067c478bd9Sstevel@tonic-gate 23077c478bd9Sstevel@tonic-gate hsize = (actual = dstate.dtds_hashsize) * sizeof (size_t); 23087c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate /* 23117c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 23127c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 23137c478bd9Sstevel@tonic-gate * hell of it.) 23147c478bd9Sstevel@tonic-gate */ 23157c478bd9Sstevel@tonic-gate for (prime = dstate.dtds_hashsize - 1; prime > 7; prime--) { 23167c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 23177c478bd9Sstevel@tonic-gate 23187c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 23197c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 23207c478bd9Sstevel@tonic-gate break; 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate 23237c478bd9Sstevel@tonic-gate if (i == limit) 23247c478bd9Sstevel@tonic-gate break; 23257c478bd9Sstevel@tonic-gate } 23267c478bd9Sstevel@tonic-gate 23277c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 23287c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 23297c478bd9Sstevel@tonic-gate 23307c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 23317c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 23327c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 23357c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 23367c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_dynvar at %p", addr); 23377c478bd9Sstevel@tonic-gate return (DCMD_ERR); 23387c478bd9Sstevel@tonic-gate } 23397c478bd9Sstevel@tonic-gate 23407c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate /* 23437c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 23447c478bd9Sstevel@tonic-gate * any of the sizing experiments. 23457c478bd9Sstevel@tonic-gate */ 23467c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 23477c478bd9Sstevel@tonic-gate continue; 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 23507c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 23517c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 23527c478bd9Sstevel@tonic-gate 23537c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 23547c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 23557c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 23567c478bd9Sstevel@tonic-gate return (DCMD_ERR); 23577c478bd9Sstevel@tonic-gate } 23587c478bd9Sstevel@tonic-gate 23597c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 23607c478bd9Sstevel@tonic-gate } 23617c478bd9Sstevel@tonic-gate 23627c478bd9Sstevel@tonic-gate return (DCMD_OK); 23637c478bd9Sstevel@tonic-gate } 23647c478bd9Sstevel@tonic-gate 2365c2580b93Sjhaslam typedef struct dtrace_ecb_walk { 2366c2580b93Sjhaslam dtrace_ecb_t **dtew_ecbs; 2367c2580b93Sjhaslam int dtew_necbs; 2368c2580b93Sjhaslam int dtew_curecb; 2369c2580b93Sjhaslam } dtrace_ecb_walk_t; 2370c2580b93Sjhaslam 2371c2580b93Sjhaslam static int 2372c2580b93Sjhaslam dtrace_ecb_init(mdb_walk_state_t *wsp) 2373c2580b93Sjhaslam { 2374c2580b93Sjhaslam uintptr_t addr; 2375c2580b93Sjhaslam dtrace_state_t state; 2376c2580b93Sjhaslam dtrace_ecb_walk_t *ecbwp; 2377c2580b93Sjhaslam 2378c2580b93Sjhaslam if ((addr = wsp->walk_addr) == NULL) { 2379c2580b93Sjhaslam mdb_warn("dtrace_ecb walk needs dtrace_state_t\n"); 2380c2580b93Sjhaslam return (WALK_ERR); 2381c2580b93Sjhaslam } 2382c2580b93Sjhaslam 2383c2580b93Sjhaslam if (mdb_vread(&state, sizeof (state), addr) == -1) { 2384c2580b93Sjhaslam mdb_warn("failed to read dtrace state pointer at %p", addr); 2385c2580b93Sjhaslam return (WALK_ERR); 2386c2580b93Sjhaslam } 2387c2580b93Sjhaslam 2388c2580b93Sjhaslam ecbwp = mdb_zalloc(sizeof (dtrace_ecb_walk_t), UM_SLEEP | UM_GC); 2389c2580b93Sjhaslam 2390c2580b93Sjhaslam ecbwp->dtew_ecbs = state.dts_ecbs; 2391c2580b93Sjhaslam ecbwp->dtew_necbs = state.dts_necbs; 2392c2580b93Sjhaslam ecbwp->dtew_curecb = 0; 2393c2580b93Sjhaslam 2394c2580b93Sjhaslam wsp->walk_data = ecbwp; 2395c2580b93Sjhaslam 2396c2580b93Sjhaslam return (WALK_NEXT); 2397c2580b93Sjhaslam } 2398c2580b93Sjhaslam 2399c2580b93Sjhaslam static int 2400c2580b93Sjhaslam dtrace_ecb_step(mdb_walk_state_t *wsp) 2401c2580b93Sjhaslam { 2402c2580b93Sjhaslam uintptr_t ecbp, addr; 2403c2580b93Sjhaslam dtrace_ecb_walk_t *ecbwp = wsp->walk_data; 2404c2580b93Sjhaslam 2405c2580b93Sjhaslam addr = (uintptr_t)ecbwp->dtew_ecbs + 2406c2580b93Sjhaslam ecbwp->dtew_curecb * sizeof (dtrace_ecb_t *); 2407c2580b93Sjhaslam 2408c2580b93Sjhaslam if (ecbwp->dtew_curecb++ == ecbwp->dtew_necbs) 2409c2580b93Sjhaslam return (WALK_DONE); 2410c2580b93Sjhaslam 2411c2580b93Sjhaslam if (mdb_vread(&ecbp, sizeof (addr), addr) == -1) { 2412c2580b93Sjhaslam mdb_warn("failed to read ecb at entry %d\n", 2413c2580b93Sjhaslam ecbwp->dtew_curecb); 2414c2580b93Sjhaslam return (WALK_ERR); 2415c2580b93Sjhaslam } 2416c2580b93Sjhaslam 2417c2580b93Sjhaslam if (ecbp == NULL) 2418c2580b93Sjhaslam return (WALK_NEXT); 2419c2580b93Sjhaslam 2420c2580b93Sjhaslam return (wsp->walk_callback(ecbp, NULL, wsp->walk_cbdata)); 2421c2580b93Sjhaslam } 2422c2580b93Sjhaslam 24230f1d7ad6SJonathan Haslam static void 24240f1d7ad6SJonathan Haslam dtrace_options_numtostr(uint64_t num, char *buf, size_t len) 24250f1d7ad6SJonathan Haslam { 24260f1d7ad6SJonathan Haslam uint64_t n = num; 24270f1d7ad6SJonathan Haslam int index = 0; 24280f1d7ad6SJonathan Haslam char u; 24290f1d7ad6SJonathan Haslam 24300f1d7ad6SJonathan Haslam while (n >= 1024) { 24310f1d7ad6SJonathan Haslam n = (n + (1024 / 2)) / 1024; /* Round up or down */ 24320f1d7ad6SJonathan Haslam index++; 24330f1d7ad6SJonathan Haslam } 24340f1d7ad6SJonathan Haslam 24350f1d7ad6SJonathan Haslam u = " KMGTPE"[index]; 24360f1d7ad6SJonathan Haslam 24370f1d7ad6SJonathan Haslam if (index == 0) { 24380f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%llu", (u_longlong_t)n); 24390f1d7ad6SJonathan Haslam } else if (n < 10 && (num & (num - 1)) != 0) { 24400f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%.2f%c", 24410f1d7ad6SJonathan Haslam (double)num / (1ULL << 10 * index), u); 24420f1d7ad6SJonathan Haslam } else if (n < 100 && (num & (num - 1)) != 0) { 24430f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%.1f%c", 24440f1d7ad6SJonathan Haslam (double)num / (1ULL << 10 * index), u); 24450f1d7ad6SJonathan Haslam } else { 24460f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%llu%c", (u_longlong_t)n, u); 24470f1d7ad6SJonathan Haslam } 24480f1d7ad6SJonathan Haslam } 24490f1d7ad6SJonathan Haslam 24500f1d7ad6SJonathan Haslam static void 24510f1d7ad6SJonathan Haslam dtrace_options_numtohz(uint64_t num, char *buf, size_t len) 24520f1d7ad6SJonathan Haslam { 24530f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%dhz", NANOSEC/num); 24540f1d7ad6SJonathan Haslam } 24550f1d7ad6SJonathan Haslam 24560f1d7ad6SJonathan Haslam static void 24570f1d7ad6SJonathan Haslam dtrace_options_numtobufpolicy(uint64_t num, char *buf, size_t len) 24580f1d7ad6SJonathan Haslam { 24590f1d7ad6SJonathan Haslam char *policy = "unknown"; 24600f1d7ad6SJonathan Haslam 24610f1d7ad6SJonathan Haslam switch (num) { 24620f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_RING: 24630f1d7ad6SJonathan Haslam policy = "ring"; 24640f1d7ad6SJonathan Haslam break; 24650f1d7ad6SJonathan Haslam 24660f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_FILL: 24670f1d7ad6SJonathan Haslam policy = "fill"; 24680f1d7ad6SJonathan Haslam break; 24690f1d7ad6SJonathan Haslam 24700f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_SWITCH: 24710f1d7ad6SJonathan Haslam policy = "switch"; 24720f1d7ad6SJonathan Haslam break; 24730f1d7ad6SJonathan Haslam } 24740f1d7ad6SJonathan Haslam 24750f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%s", policy); 24760f1d7ad6SJonathan Haslam } 24770f1d7ad6SJonathan Haslam 24780f1d7ad6SJonathan Haslam static void 24790f1d7ad6SJonathan Haslam dtrace_options_numtocpu(uint64_t cpu, char *buf, size_t len) 24800f1d7ad6SJonathan Haslam { 24810f1d7ad6SJonathan Haslam if (cpu == DTRACE_CPUALL) 24820f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%7s", "unbound"); 24830f1d7ad6SJonathan Haslam else 24840f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%d", cpu); 24850f1d7ad6SJonathan Haslam } 24860f1d7ad6SJonathan Haslam 24870f1d7ad6SJonathan Haslam typedef void (*dtrace_options_func_t)(uint64_t, char *, size_t); 24880f1d7ad6SJonathan Haslam 24890f1d7ad6SJonathan Haslam static struct dtrace_options { 24900f1d7ad6SJonathan Haslam char *dtop_optstr; 24910f1d7ad6SJonathan Haslam dtrace_options_func_t dtop_func; 24920f1d7ad6SJonathan Haslam } _dtrace_options[] = { 24930f1d7ad6SJonathan Haslam { "bufsize", dtrace_options_numtostr }, 24940f1d7ad6SJonathan Haslam { "bufpolicy", dtrace_options_numtobufpolicy }, 24950f1d7ad6SJonathan Haslam { "dynvarsize", dtrace_options_numtostr }, 24960f1d7ad6SJonathan Haslam { "aggsize", dtrace_options_numtostr }, 24970f1d7ad6SJonathan Haslam { "specsize", dtrace_options_numtostr }, 24980f1d7ad6SJonathan Haslam { "nspec", dtrace_options_numtostr }, 24990f1d7ad6SJonathan Haslam { "strsize", dtrace_options_numtostr }, 25000f1d7ad6SJonathan Haslam { "cleanrate", dtrace_options_numtohz }, 25010f1d7ad6SJonathan Haslam { "cpu", dtrace_options_numtocpu }, 25020f1d7ad6SJonathan Haslam { "bufresize", dtrace_options_numtostr }, 25030f1d7ad6SJonathan Haslam { "grabanon", dtrace_options_numtostr }, 25040f1d7ad6SJonathan Haslam { "flowindent", dtrace_options_numtostr }, 25050f1d7ad6SJonathan Haslam { "quiet", dtrace_options_numtostr }, 25060f1d7ad6SJonathan Haslam { "stackframes", dtrace_options_numtostr }, 25070f1d7ad6SJonathan Haslam { "ustackframes", dtrace_options_numtostr }, 25080f1d7ad6SJonathan Haslam { "aggrate", dtrace_options_numtohz }, 25090f1d7ad6SJonathan Haslam { "switchrate", dtrace_options_numtohz }, 25100f1d7ad6SJonathan Haslam { "statusrate", dtrace_options_numtohz }, 25110f1d7ad6SJonathan Haslam { "destructive", dtrace_options_numtostr }, 25120f1d7ad6SJonathan Haslam { "stackindent", dtrace_options_numtostr }, 25130f1d7ad6SJonathan Haslam { "rawbytes", dtrace_options_numtostr }, 25140f1d7ad6SJonathan Haslam { "jstackframes", dtrace_options_numtostr }, 25150f1d7ad6SJonathan Haslam { "jstackstrsize", dtrace_options_numtostr }, 25160f1d7ad6SJonathan Haslam { "aggsortkey", dtrace_options_numtostr }, 25170f1d7ad6SJonathan Haslam { "aggsortrev", dtrace_options_numtostr }, 25180f1d7ad6SJonathan Haslam { "aggsortpos", dtrace_options_numtostr }, 25190f1d7ad6SJonathan Haslam { "aggsortkeypos", dtrace_options_numtostr } 25200f1d7ad6SJonathan Haslam }; 25210f1d7ad6SJonathan Haslam 25220f1d7ad6SJonathan Haslam static void 25230f1d7ad6SJonathan Haslam dtrace_options_help(void) 25240f1d7ad6SJonathan Haslam { 25250f1d7ad6SJonathan Haslam mdb_printf("Given a dtrace_state_t structure, displays the " 25260f1d7ad6SJonathan Haslam "current tunable option\nsettings.\n"); 25270f1d7ad6SJonathan Haslam } 25280f1d7ad6SJonathan Haslam 25290f1d7ad6SJonathan Haslam /*ARGSUSED*/ 25300f1d7ad6SJonathan Haslam static int 25310f1d7ad6SJonathan Haslam dtrace_options(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 25320f1d7ad6SJonathan Haslam { 25330f1d7ad6SJonathan Haslam dtrace_state_t state; 25340f1d7ad6SJonathan Haslam int i = 0; 25350f1d7ad6SJonathan Haslam dtrace_optval_t *options; 25360f1d7ad6SJonathan Haslam char val[32]; 25370f1d7ad6SJonathan Haslam 25380f1d7ad6SJonathan Haslam if (!(flags & DCMD_ADDRSPEC)) 25390f1d7ad6SJonathan Haslam return (DCMD_USAGE); 25400f1d7ad6SJonathan Haslam 25410f1d7ad6SJonathan Haslam if (mdb_vread(&state, sizeof (dtrace_state_t), (uintptr_t)addr) == -1) { 25420f1d7ad6SJonathan Haslam mdb_warn("failed to read state pointer at %p\n", addr); 25430f1d7ad6SJonathan Haslam return (DCMD_ERR); 25440f1d7ad6SJonathan Haslam } 25450f1d7ad6SJonathan Haslam 25460f1d7ad6SJonathan Haslam options = &state.dts_options[0]; 25470f1d7ad6SJonathan Haslam 25480f1d7ad6SJonathan Haslam mdb_printf("%<u>%-25s %s%</u>\n", "OPTION", "VALUE"); 25490f1d7ad6SJonathan Haslam for (i = 0; i < DTRACEOPT_MAX; i++) { 25500f1d7ad6SJonathan Haslam if (options[i] == DTRACEOPT_UNSET) { 25510f1d7ad6SJonathan Haslam mdb_printf("%-25s %s\n", 25520f1d7ad6SJonathan Haslam _dtrace_options[i].dtop_optstr, "UNSET"); 25530f1d7ad6SJonathan Haslam } else { 25540f1d7ad6SJonathan Haslam (void) _dtrace_options[i].dtop_func(options[i], 25550f1d7ad6SJonathan Haslam val, 32); 25560f1d7ad6SJonathan Haslam mdb_printf("%-25s %s\n", 25570f1d7ad6SJonathan Haslam _dtrace_options[i].dtop_optstr, val); 25580f1d7ad6SJonathan Haslam } 25590f1d7ad6SJonathan Haslam } 25600f1d7ad6SJonathan Haslam 25610f1d7ad6SJonathan Haslam return (DCMD_OK); 25620f1d7ad6SJonathan Haslam } 25630f1d7ad6SJonathan Haslam 25640f1d7ad6SJonathan Haslam static int 25650f1d7ad6SJonathan Haslam pid2state_init(mdb_walk_state_t *wsp) 25660f1d7ad6SJonathan Haslam { 25670f1d7ad6SJonathan Haslam dtrace_state_data_t *data; 25680f1d7ad6SJonathan Haslam uintptr_t devi; 25690f1d7ad6SJonathan Haslam uintptr_t proc; 25700f1d7ad6SJonathan Haslam struct dev_info info; 25710f1d7ad6SJonathan Haslam pid_t pid = (pid_t)wsp->walk_addr; 25720f1d7ad6SJonathan Haslam 25730f1d7ad6SJonathan Haslam if (wsp->walk_addr == NULL) { 25740f1d7ad6SJonathan Haslam mdb_warn("pid2state walk requires PID\n"); 25750f1d7ad6SJonathan Haslam return (WALK_ERR); 25760f1d7ad6SJonathan Haslam } 25770f1d7ad6SJonathan Haslam 25780f1d7ad6SJonathan Haslam data = mdb_zalloc(sizeof (dtrace_state_data_t), UM_SLEEP | UM_GC); 25790f1d7ad6SJonathan Haslam 25800f1d7ad6SJonathan Haslam if (mdb_readvar(&data->dtsd_softstate, "dtrace_softstate") == -1) { 25810f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_softstate'"); 25820f1d7ad6SJonathan Haslam return (DCMD_ERR); 25830f1d7ad6SJonathan Haslam } 25840f1d7ad6SJonathan Haslam 25850f1d7ad6SJonathan Haslam if ((proc = mdb_pid2proc(pid, NULL)) == NULL) { 25860f1d7ad6SJonathan Haslam mdb_warn("PID 0t%d not found\n", pid); 25870f1d7ad6SJonathan Haslam return (DCMD_ERR); 25880f1d7ad6SJonathan Haslam } 25890f1d7ad6SJonathan Haslam 25900f1d7ad6SJonathan Haslam if (mdb_readvar(&devi, "dtrace_devi") == -1) { 25910f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_devi'"); 25920f1d7ad6SJonathan Haslam return (DCMD_ERR); 25930f1d7ad6SJonathan Haslam } 25940f1d7ad6SJonathan Haslam 25950f1d7ad6SJonathan Haslam if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) { 25960f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dev_info'"); 25970f1d7ad6SJonathan Haslam return (DCMD_ERR); 25980f1d7ad6SJonathan Haslam } 25990f1d7ad6SJonathan Haslam 26000f1d7ad6SJonathan Haslam data->dtsd_major = info.devi_major; 26010f1d7ad6SJonathan Haslam data->dtsd_proc = proc; 26020f1d7ad6SJonathan Haslam 26030f1d7ad6SJonathan Haslam wsp->walk_data = data; 26040f1d7ad6SJonathan Haslam 26050f1d7ad6SJonathan Haslam return (WALK_NEXT); 26060f1d7ad6SJonathan Haslam } 26070f1d7ad6SJonathan Haslam 26080f1d7ad6SJonathan Haslam /*ARGSUSED*/ 26090f1d7ad6SJonathan Haslam static int 26100f1d7ad6SJonathan Haslam pid2state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data) 26110f1d7ad6SJonathan Haslam { 26120f1d7ad6SJonathan Haslam vnode_t vnode; 26130f1d7ad6SJonathan Haslam minor_t minor; 26140f1d7ad6SJonathan Haslam uintptr_t statep; 26150f1d7ad6SJonathan Haslam 26160f1d7ad6SJonathan Haslam /* Get the vnode for this file */ 26170f1d7ad6SJonathan Haslam if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) { 26180f1d7ad6SJonathan Haslam mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode); 26190f1d7ad6SJonathan Haslam return (WALK_NEXT); 26200f1d7ad6SJonathan Haslam } 26210f1d7ad6SJonathan Haslam 26220f1d7ad6SJonathan Haslam 26230f1d7ad6SJonathan Haslam /* Is this the dtrace device? */ 26240f1d7ad6SJonathan Haslam if (getmajor(vnode.v_rdev) != data->dtsd_major) 26250f1d7ad6SJonathan Haslam return (WALK_NEXT); 26260f1d7ad6SJonathan Haslam 26270f1d7ad6SJonathan Haslam /* Get the minor number for this device entry */ 26280f1d7ad6SJonathan Haslam minor = getminor(vnode.v_rdev); 26290f1d7ad6SJonathan Haslam 26300f1d7ad6SJonathan Haslam if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor, 26310f1d7ad6SJonathan Haslam &statep, NULL, 0) == -1) { 26320f1d7ad6SJonathan Haslam mdb_warn("failed to read softstate for minor %d", minor); 26330f1d7ad6SJonathan Haslam return (WALK_NEXT); 26340f1d7ad6SJonathan Haslam } 26350f1d7ad6SJonathan Haslam 26360f1d7ad6SJonathan Haslam mdb_printf("%p\n", statep); 26370f1d7ad6SJonathan Haslam 26380f1d7ad6SJonathan Haslam return (WALK_NEXT); 26390f1d7ad6SJonathan Haslam } 26400f1d7ad6SJonathan Haslam 26410f1d7ad6SJonathan Haslam static int 26420f1d7ad6SJonathan Haslam pid2state_step(mdb_walk_state_t *wsp) 26430f1d7ad6SJonathan Haslam { 26440f1d7ad6SJonathan Haslam dtrace_state_data_t *ds = wsp->walk_data; 26450f1d7ad6SJonathan Haslam 26460f1d7ad6SJonathan Haslam if (mdb_pwalk("file", 26470f1d7ad6SJonathan Haslam (mdb_walk_cb_t)pid2state_file, ds, ds->dtsd_proc) == -1) { 26480f1d7ad6SJonathan Haslam mdb_warn("couldn't walk 'file' for proc %p", ds->dtsd_proc); 26490f1d7ad6SJonathan Haslam return (WALK_ERR); 26500f1d7ad6SJonathan Haslam } 26510f1d7ad6SJonathan Haslam 26520f1d7ad6SJonathan Haslam return (WALK_DONE); 26530f1d7ad6SJonathan Haslam } 26540f1d7ad6SJonathan Haslam 26550f1d7ad6SJonathan Haslam /*ARGSUSED*/ 26560f1d7ad6SJonathan Haslam static int 26570f1d7ad6SJonathan Haslam dtrace_probes_walk(uintptr_t addr, void *ignored, uintptr_t *target) 26580f1d7ad6SJonathan Haslam { 26590f1d7ad6SJonathan Haslam dtrace_ecb_t ecb; 26600f1d7ad6SJonathan Haslam dtrace_probe_t probe; 26610f1d7ad6SJonathan Haslam dtrace_probedesc_t pd; 26620f1d7ad6SJonathan Haslam 26630f1d7ad6SJonathan Haslam if (addr == NULL) 26640f1d7ad6SJonathan Haslam return (WALK_ERR); 26650f1d7ad6SJonathan Haslam 26660f1d7ad6SJonathan Haslam if (mdb_vread(&ecb, sizeof (dtrace_ecb_t), addr) == -1) { 26670f1d7ad6SJonathan Haslam mdb_warn("failed to read ecb %p\n", addr); 26680f1d7ad6SJonathan Haslam return (WALK_ERR); 26690f1d7ad6SJonathan Haslam } 26700f1d7ad6SJonathan Haslam 26710f1d7ad6SJonathan Haslam if (ecb.dte_probe == NULL) 26720f1d7ad6SJonathan Haslam return (WALK_ERR); 26730f1d7ad6SJonathan Haslam 26740f1d7ad6SJonathan Haslam if (mdb_vread(&probe, sizeof (dtrace_probe_t), 26750f1d7ad6SJonathan Haslam (uintptr_t)ecb.dte_probe) == -1) { 26760f1d7ad6SJonathan Haslam mdb_warn("failed to read probe %p\n", ecb.dte_probe); 26770f1d7ad6SJonathan Haslam return (WALK_ERR); 26780f1d7ad6SJonathan Haslam } 26790f1d7ad6SJonathan Haslam 26800f1d7ad6SJonathan Haslam pd.dtpd_id = probe.dtpr_id; 26810f1d7ad6SJonathan Haslam dtracemdb_probe(NULL, &pd); 26820f1d7ad6SJonathan Haslam 26830f1d7ad6SJonathan Haslam mdb_printf("%5d %10s %17s %33s %s\n", pd.dtpd_id, pd.dtpd_provider, 26840f1d7ad6SJonathan Haslam pd.dtpd_mod, pd.dtpd_func, pd.dtpd_name); 26850f1d7ad6SJonathan Haslam 26860f1d7ad6SJonathan Haslam return (WALK_NEXT); 26870f1d7ad6SJonathan Haslam } 26880f1d7ad6SJonathan Haslam 26890f1d7ad6SJonathan Haslam static void 26900f1d7ad6SJonathan Haslam dtrace_probes_help(void) 26910f1d7ad6SJonathan Haslam { 26920f1d7ad6SJonathan Haslam mdb_printf("Given a dtrace_state_t structure, displays all " 26930f1d7ad6SJonathan Haslam "its active enablings. If no\nstate structure is provided, " 26940f1d7ad6SJonathan Haslam "all available probes are listed.\n"); 26950f1d7ad6SJonathan Haslam } 26960f1d7ad6SJonathan Haslam 26970f1d7ad6SJonathan Haslam /*ARGSUSED*/ 26980f1d7ad6SJonathan Haslam static int 26990f1d7ad6SJonathan Haslam dtrace_probes(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 27000f1d7ad6SJonathan Haslam { 27010f1d7ad6SJonathan Haslam dtrace_probedesc_t pd; 27020f1d7ad6SJonathan Haslam uintptr_t caddr, base, paddr; 27030f1d7ad6SJonathan Haslam int nprobes, i; 27040f1d7ad6SJonathan Haslam 27050f1d7ad6SJonathan Haslam mdb_printf("%5s %10s %17s %33s %s\n", 27060f1d7ad6SJonathan Haslam "ID", "PROVIDER", "MODULE", "FUNCTION", "NAME"); 27070f1d7ad6SJonathan Haslam 27080f1d7ad6SJonathan Haslam if (!(flags & DCMD_ADDRSPEC)) { 27090f1d7ad6SJonathan Haslam /* 27100f1d7ad6SJonathan Haslam * If no argument is provided just display all available 27110f1d7ad6SJonathan Haslam * probes. 27120f1d7ad6SJonathan Haslam */ 27130f1d7ad6SJonathan Haslam if (mdb_readvar(&base, "dtrace_probes") == -1) { 27140f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_probes'"); 27150f1d7ad6SJonathan Haslam return (-1); 27160f1d7ad6SJonathan Haslam } 27170f1d7ad6SJonathan Haslam 27180f1d7ad6SJonathan Haslam if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) { 27190f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_nprobes'"); 27200f1d7ad6SJonathan Haslam return (-1); 27210f1d7ad6SJonathan Haslam } 27220f1d7ad6SJonathan Haslam 27230f1d7ad6SJonathan Haslam for (i = 0; i < nprobes; i++) { 27240f1d7ad6SJonathan Haslam caddr = base + i * sizeof (dtrace_probe_t *); 27250f1d7ad6SJonathan Haslam 27260f1d7ad6SJonathan Haslam if (mdb_vread(&paddr, sizeof (paddr), caddr) == -1) { 27270f1d7ad6SJonathan Haslam mdb_warn("couldn't read probe pointer at %p", 27280f1d7ad6SJonathan Haslam caddr); 27290f1d7ad6SJonathan Haslam continue; 27300f1d7ad6SJonathan Haslam } 27310f1d7ad6SJonathan Haslam 27320f1d7ad6SJonathan Haslam if (paddr == NULL) 27330f1d7ad6SJonathan Haslam continue; 27340f1d7ad6SJonathan Haslam 27350f1d7ad6SJonathan Haslam pd.dtpd_id = i + 1; 27360f1d7ad6SJonathan Haslam if (dtracemdb_probe(NULL, &pd) == 0) { 27370f1d7ad6SJonathan Haslam mdb_printf("%5d %10s %17s %33s %s\n", 27380f1d7ad6SJonathan Haslam pd.dtpd_id, pd.dtpd_provider, 27390f1d7ad6SJonathan Haslam pd.dtpd_mod, pd.dtpd_func, pd.dtpd_name); 27400f1d7ad6SJonathan Haslam } 27410f1d7ad6SJonathan Haslam } 27420f1d7ad6SJonathan Haslam } else { 27430f1d7ad6SJonathan Haslam if (mdb_pwalk("dtrace_ecb", (mdb_walk_cb_t)dtrace_probes_walk, 27440f1d7ad6SJonathan Haslam NULL, addr) == -1) { 27450f1d7ad6SJonathan Haslam mdb_warn("couldn't walk 'dtrace_ecb'"); 27460f1d7ad6SJonathan Haslam return (DCMD_ERR); 27470f1d7ad6SJonathan Haslam } 27480f1d7ad6SJonathan Haslam } 27490f1d7ad6SJonathan Haslam 27500f1d7ad6SJonathan Haslam return (DCMD_OK); 27510f1d7ad6SJonathan Haslam } 27520f1d7ad6SJonathan Haslam 27531a7c1b72Smws const mdb_dcmd_t kernel_dcmds[] = { 27547c478bd9Sstevel@tonic-gate { "id2probe", ":", "translate a dtrace_id_t to a dtrace_probe_t", 27557c478bd9Sstevel@tonic-gate id2probe }, 27567c478bd9Sstevel@tonic-gate { "dtrace", ":[-c cpu]", "print dtrace(1M)-like output", 27577c478bd9Sstevel@tonic-gate dtrace, dtrace_help }, 27587c478bd9Sstevel@tonic-gate { "dtrace_errhash", ":", "print DTrace error hash", dtrace_errhash }, 27597c478bd9Sstevel@tonic-gate { "dtrace_helptrace", ":", "print DTrace helper trace", 27607c478bd9Sstevel@tonic-gate dtrace_helptrace }, 27617c478bd9Sstevel@tonic-gate { "dtrace_state", ":", "print active DTrace consumers", dtrace_state, 27627c478bd9Sstevel@tonic-gate dtrace_state_help }, 27637c478bd9Sstevel@tonic-gate { "dtrace_aggstat", ":", 27647c478bd9Sstevel@tonic-gate "print DTrace aggregation hash statistics", dtrace_aggstat }, 27657c478bd9Sstevel@tonic-gate { "dtrace_dynstat", ":", 27667c478bd9Sstevel@tonic-gate "print DTrace dynamic variable hash statistics", dtrace_dynstat }, 27670f1d7ad6SJonathan Haslam { "dtrace_options", ":", 27680f1d7ad6SJonathan Haslam "print a DTrace consumer's current tuneable options", 27690f1d7ad6SJonathan Haslam dtrace_options, dtrace_options_help }, 27700f1d7ad6SJonathan Haslam { "dtrace_probes", "?", "print a DTrace consumer's enabled probes", 27710f1d7ad6SJonathan Haslam dtrace_probes, dtrace_probes_help }, 27727c478bd9Sstevel@tonic-gate { NULL } 27737c478bd9Sstevel@tonic-gate }; 27747c478bd9Sstevel@tonic-gate 27751a7c1b72Smws const mdb_walker_t kernel_walkers[] = { 27767c478bd9Sstevel@tonic-gate { "dtrace_errhash", "walk hash of DTrace error messasges", 27777c478bd9Sstevel@tonic-gate dtrace_errhash_init, dtrace_errhash_step }, 27787c478bd9Sstevel@tonic-gate { "dtrace_helptrace", "walk DTrace helper trace entries", 27797c478bd9Sstevel@tonic-gate dtrace_helptrace_init, dtrace_helptrace_step }, 27807c478bd9Sstevel@tonic-gate { "dtrace_state", "walk DTrace per-consumer softstate", 27817c478bd9Sstevel@tonic-gate dtrace_state_init, dtrace_state_step }, 27827c478bd9Sstevel@tonic-gate { "dtrace_aggkey", "walk DTrace aggregation keys", 27837c478bd9Sstevel@tonic-gate dtrace_aggkey_init, dtrace_aggkey_step, dtrace_aggkey_fini }, 27847c478bd9Sstevel@tonic-gate { "dtrace_dynvar", "walk DTrace dynamic variables", 27857c478bd9Sstevel@tonic-gate dtrace_dynvar_init, dtrace_dynvar_step, dtrace_dynvar_fini }, 2786c2580b93Sjhaslam { "dtrace_ecb", "walk a DTrace consumer's enabling control blocks", 2787c2580b93Sjhaslam dtrace_ecb_init, dtrace_ecb_step }, 27880f1d7ad6SJonathan Haslam { "pid2state", "walk a processes dtrace_state structures", 27890f1d7ad6SJonathan Haslam pid2state_init, pid2state_step }, 27907c478bd9Sstevel@tonic-gate { NULL } 27917c478bd9Sstevel@tonic-gate }; 2792