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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * explicitly define DTRACE_ERRDEBUG to pull in definition of dtrace_errhash_t 317c478bd9Sstevel@tonic-gate * explicitly define _STDARG_H to avoid stdarg.h/varargs.h u/k defn conflict 327c478bd9Sstevel@tonic-gate */ 337c478bd9Sstevel@tonic-gate #define DTRACE_ERRDEBUG 347c478bd9Sstevel@tonic-gate #define _STDARG_H 357c478bd9Sstevel@tonic-gate 367c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h> 377c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h> 387c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h> 397c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h> 407c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h> 417c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 427c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 437c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 447c478bd9Sstevel@tonic-gate #include <dtrace.h> 457c478bd9Sstevel@tonic-gate #include <alloca.h> 467c478bd9Sstevel@tonic-gate #include <ctype.h> 477c478bd9Sstevel@tonic-gate #include <errno.h> 487c478bd9Sstevel@tonic-gate #include <math.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 /* 4407c478bd9Sstevel@tonic-gate * This is essentially identical to its cousin in the kernel. 4417c478bd9Sstevel@tonic-gate */ 4427c478bd9Sstevel@tonic-gate static dof_hdr_t * 4437c478bd9Sstevel@tonic-gate dtracemdb_dof_create(dtrace_state_t *state) 4447c478bd9Sstevel@tonic-gate { 4457c478bd9Sstevel@tonic-gate dof_hdr_t *dof; 4467c478bd9Sstevel@tonic-gate dof_sec_t *sec; 4477c478bd9Sstevel@tonic-gate dof_optdesc_t *opt; 4487c478bd9Sstevel@tonic-gate int i, len = sizeof (dof_hdr_t) + 4497c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t)) + 4507c478bd9Sstevel@tonic-gate sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 4517c478bd9Sstevel@tonic-gate 4527c478bd9Sstevel@tonic-gate dof = mdb_zalloc(len, UM_SLEEP); 4537c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0; 4547c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1; 4557c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2; 4567c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3; 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MODEL] = DOF_MODEL_NATIVE; 4597c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE; 4607c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_VERSION] = DOF_VERSION_1; 4617c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFVERS] = DIF_VERSION; 4627c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFIREG] = DIF_DIR_NREGS; 4637c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFTREG] = DIF_DTR_NREGS; 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate dof->dofh_flags = 0; 4667c478bd9Sstevel@tonic-gate dof->dofh_hdrsize = sizeof (dof_hdr_t); 4677c478bd9Sstevel@tonic-gate dof->dofh_secsize = sizeof (dof_sec_t); 4687c478bd9Sstevel@tonic-gate dof->dofh_secnum = 1; /* only DOF_SECT_OPTDESC */ 4697c478bd9Sstevel@tonic-gate dof->dofh_secoff = sizeof (dof_hdr_t); 4707c478bd9Sstevel@tonic-gate dof->dofh_loadsz = len; 4717c478bd9Sstevel@tonic-gate dof->dofh_filesz = len; 4727c478bd9Sstevel@tonic-gate dof->dofh_pad = 0; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate /* 4757c478bd9Sstevel@tonic-gate * Fill in the option section header... 4767c478bd9Sstevel@tonic-gate */ 4777c478bd9Sstevel@tonic-gate sec = (dof_sec_t *)((uintptr_t)dof + sizeof (dof_hdr_t)); 4787c478bd9Sstevel@tonic-gate sec->dofs_type = DOF_SECT_OPTDESC; 4797c478bd9Sstevel@tonic-gate sec->dofs_align = sizeof (uint64_t); 4807c478bd9Sstevel@tonic-gate sec->dofs_flags = DOF_SECF_LOAD; 4817c478bd9Sstevel@tonic-gate sec->dofs_entsize = sizeof (dof_optdesc_t); 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate opt = (dof_optdesc_t *)((uintptr_t)sec + 4847c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t))); 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate sec->dofs_offset = (uintptr_t)opt - (uintptr_t)dof; 4877c478bd9Sstevel@tonic-gate sec->dofs_size = sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACEOPT_MAX; i++) { 4907c478bd9Sstevel@tonic-gate opt[i].dofo_option = i; 4917c478bd9Sstevel@tonic-gate opt[i].dofo_strtab = DOF_SECIDX_NONE; 4927c478bd9Sstevel@tonic-gate opt[i].dofo_value = state->dts_options[i]; 4937c478bd9Sstevel@tonic-gate } 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate return (dof); 4967c478bd9Sstevel@tonic-gate } 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate static int 4997c478bd9Sstevel@tonic-gate dtracemdb_format(dtrace_state_t *state, dtrace_fmtdesc_t *desc) 5007c478bd9Sstevel@tonic-gate { 5017c478bd9Sstevel@tonic-gate uintptr_t addr, faddr; 5027c478bd9Sstevel@tonic-gate char c; 5037c478bd9Sstevel@tonic-gate int len = 0; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate if (desc->dtfd_format == 0 || desc->dtfd_format > state->dts_nformats) { 5067c478bd9Sstevel@tonic-gate errno = EINVAL; 5077c478bd9Sstevel@tonic-gate return (-1); 5087c478bd9Sstevel@tonic-gate } 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate faddr = (uintptr_t)state->dts_formats + 5117c478bd9Sstevel@tonic-gate (desc->dtfd_format - 1) * sizeof (char *); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), faddr) == -1) { 5147c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string pointer at %p", faddr); 5157c478bd9Sstevel@tonic-gate return (-1); 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate do { 5197c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), addr + len++) == -1) { 5207c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string at %p", addr); 5217c478bd9Sstevel@tonic-gate return (-1); 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate } while (c != '\0'); 5247c478bd9Sstevel@tonic-gate 5257c478bd9Sstevel@tonic-gate if (len > desc->dtfd_length) { 5267c478bd9Sstevel@tonic-gate desc->dtfd_length = len; 5277c478bd9Sstevel@tonic-gate return (0); 5287c478bd9Sstevel@tonic-gate } 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate if (mdb_vread(desc->dtfd_string, len, addr) == -1) { 5317c478bd9Sstevel@tonic-gate mdb_warn("failed to reread format string at %p", addr); 5327c478bd9Sstevel@tonic-gate return (-1); 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate return (0); 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate static int 5397c478bd9Sstevel@tonic-gate dtracemdb_status(dtrace_state_t *state, dtrace_status_t *status) 5407c478bd9Sstevel@tonic-gate { 5417c478bd9Sstevel@tonic-gate dtrace_dstate_t *dstate; 5427c478bd9Sstevel@tonic-gate int i, j; 5437c478bd9Sstevel@tonic-gate uint64_t nerrs; 5447c478bd9Sstevel@tonic-gate uintptr_t addr; 5457c478bd9Sstevel@tonic-gate int ncpu; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 5487c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 5497c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate bzero(status, sizeof (dtrace_status_t)); 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 5557c478bd9Sstevel@tonic-gate errno = ENOENT; 5567c478bd9Sstevel@tonic-gate return (-1); 5577c478bd9Sstevel@tonic-gate } 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate /* 5607c478bd9Sstevel@tonic-gate * For the MDB backend, we never set dtst_exiting or dtst_filled. This 5617c478bd9Sstevel@tonic-gate * is by design: we don't want the library to try to stop tracing, 5627c478bd9Sstevel@tonic-gate * because it doesn't particularly mean anything. 5637c478bd9Sstevel@tonic-gate */ 5647c478bd9Sstevel@tonic-gate nerrs = state->dts_errors; 5657c478bd9Sstevel@tonic-gate dstate = &state->dts_vstate.dtvs_dynvars; 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate for (i = 0; i < ncpu; i++) { 5687c478bd9Sstevel@tonic-gate dtrace_dstate_percpu_t dcpu; 5697c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate addr = (uintptr_t)&dstate->dtds_percpu[i]; 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate if (mdb_vread(&dcpu, sizeof (dcpu), addr) == -1) { 5747c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU dstate at %p", addr); 5757c478bd9Sstevel@tonic-gate return (-1); 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate status->dtst_dyndrops += dcpu.dtdsc_drops; 5797c478bd9Sstevel@tonic-gate status->dtst_dyndrops_dirty += dcpu.dtdsc_dirty_drops; 5807c478bd9Sstevel@tonic-gate status->dtst_dyndrops_rinsing += dcpu.dtdsc_rinsing_drops; 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_buffer[i]; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 5857c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU buffer at %p", addr); 5867c478bd9Sstevel@tonic-gate return (-1); 5877c478bd9Sstevel@tonic-gate } 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate nerrs += buf.dtb_errors; 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate for (j = 0; j < state->dts_nspeculations; j++) { 5927c478bd9Sstevel@tonic-gate dtrace_speculation_t spec; 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_speculations[j]; 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate if (mdb_vread(&spec, sizeof (spec), addr) == -1) { 5977c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 5987c478bd9Sstevel@tonic-gate "speculation at %p", addr); 5997c478bd9Sstevel@tonic-gate return (-1); 6007c478bd9Sstevel@tonic-gate } 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate addr = (uintptr_t)&spec.dtsp_buffer[i]; 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 6057c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 6067c478bd9Sstevel@tonic-gate "speculative buffer at %p", addr); 6077c478bd9Sstevel@tonic-gate return (-1); 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate status->dtst_specdrops += buf.dtb_xamot_drops; 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate } 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate status->dtst_specdrops_busy = state->dts_speculations_busy; 6157c478bd9Sstevel@tonic-gate status->dtst_specdrops_unavail = state->dts_speculations_unavail; 6167c478bd9Sstevel@tonic-gate status->dtst_errors = nerrs; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate return (0); 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate typedef struct dtracemdb_data { 6227c478bd9Sstevel@tonic-gate dtrace_state_t *dtmd_state; 6237c478bd9Sstevel@tonic-gate char *dtmd_symstr; 6247c478bd9Sstevel@tonic-gate char *dtmd_modstr; 6257c478bd9Sstevel@tonic-gate uintptr_t dtmd_addr; 6267c478bd9Sstevel@tonic-gate } dtracemdb_data_t; 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate static int 6297c478bd9Sstevel@tonic-gate dtracemdb_ioctl(void *varg, int cmd, void *arg) 6307c478bd9Sstevel@tonic-gate { 6317c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 6327c478bd9Sstevel@tonic-gate dtrace_state_t *state = data->dtmd_state; 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate switch (cmd) { 6357c478bd9Sstevel@tonic-gate case DTRACEIOC_CONF: { 6367c478bd9Sstevel@tonic-gate dtrace_conf_t *conf = arg; 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate bzero(conf, sizeof (conf)); 6397c478bd9Sstevel@tonic-gate conf->dtc_difversion = DIF_VERSION; 6407c478bd9Sstevel@tonic-gate conf->dtc_difintregs = DIF_DIR_NREGS; 6417c478bd9Sstevel@tonic-gate conf->dtc_diftupregs = DIF_DTR_NREGS; 6427c478bd9Sstevel@tonic-gate conf->dtc_ctfmodel = CTF_MODEL_NATIVE; 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate return (0); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate case DTRACEIOC_DOFGET: { 6487c478bd9Sstevel@tonic-gate dof_hdr_t *hdr = arg, *dof; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate dof = dtracemdb_dof_create(state); 6517c478bd9Sstevel@tonic-gate bcopy(dof, hdr, MIN(hdr->dofh_loadsz, dof->dofh_loadsz)); 6527c478bd9Sstevel@tonic-gate mdb_free(dof, dof->dofh_loadsz); 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate return (0); 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate case DTRACEIOC_BUFSNAP: 6587c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_buffer, arg)); 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGSNAP: 6617c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_aggbuffer, arg)); 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGDESC: 6647c478bd9Sstevel@tonic-gate return (dtracemdb_aggdesc(state, arg)); 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate case DTRACEIOC_EPROBE: 6677c478bd9Sstevel@tonic-gate return (dtracemdb_eprobe(state, arg)); 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBES: 6707c478bd9Sstevel@tonic-gate return (dtracemdb_probe(state, arg)); 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate case DTRACEIOC_FORMAT: 6737c478bd9Sstevel@tonic-gate return (dtracemdb_format(state, arg)); 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate case DTRACEIOC_STATUS: 6767c478bd9Sstevel@tonic-gate return (dtracemdb_status(state, arg)); 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate case DTRACEIOC_GO: 6797c478bd9Sstevel@tonic-gate *(processorid_t *)arg = -1; 6807c478bd9Sstevel@tonic-gate return (0); 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate case DTRACEIOC_ENABLE: 6837c478bd9Sstevel@tonic-gate errno = ENOTTY; /* see dt_open.c:dtrace_go() */ 6847c478bd9Sstevel@tonic-gate return (-1); 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate case DTRACEIOC_PROVIDER: 6877c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBEMATCH: 6887c478bd9Sstevel@tonic-gate errno = ESRCH; 6897c478bd9Sstevel@tonic-gate return (-1); 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate default: 6927c478bd9Sstevel@tonic-gate mdb_warn("unexpected ioctl 0x%x (%s)\n", cmd, 6937c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROVIDER ? "DTRACEIOC_PROVIDER" : 6947c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBES ? "DTRACEIOC_PROBES" : 6957c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_BUFSNAP ? "DTRACEIOC_BUFSNAP" : 6967c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEMATCH ? "DTRACEIOC_PROBEMATCH" : 6977c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_ENABLE ? "DTRACEIOC_ENABLE" : 6987c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGSNAP ? "DTRACEIOC_AGGSNAP" : 6997c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_EPROBE ? "DTRACEIOC_EPROBE" : 7007c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEARG ? "DTRACEIOC_PROBEARG" : 7017c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_CONF ? "DTRACEIOC_CONF" : 7027c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STATUS ? "DTRACEIOC_STATUS" : 7037c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_GO ? "DTRACEIOC_GO" : 7047c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STOP ? "DTRACEIOC_STOP" : 7057c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGDESC ? "DTRACEIOC_AGGDESC" : 7067c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_FORMAT ? "DTRACEIOC_FORMAT" : 7077c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_DOFGET ? "DTRACEIOC_DOFGET" : 7087c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_REPLICATE ? "DTRACEIOC_REPLICATE" : 7097c478bd9Sstevel@tonic-gate "???"); 7107c478bd9Sstevel@tonic-gate errno = ENXIO; 7117c478bd9Sstevel@tonic-gate return (-1); 7127c478bd9Sstevel@tonic-gate } 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate static int 7167c478bd9Sstevel@tonic-gate dtracemdb_modctl(uintptr_t addr, const struct modctl *m, dtracemdb_data_t *data) 7177c478bd9Sstevel@tonic-gate { 7187c478bd9Sstevel@tonic-gate struct module mod; 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate if (m->mod_mp == NULL) 7217c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) { 7247c478bd9Sstevel@tonic-gate mdb_warn("couldn't read modctl %p's module", addr); 7257c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text > data->dtmd_addr) 7297c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text + mod.text_size <= data->dtmd_addr) 7327c478bd9Sstevel@tonic-gate return (WALK_NEXT); 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate if (mdb_readstr(data->dtmd_modstr, MDB_SYM_NAMLEN, 7357c478bd9Sstevel@tonic-gate (uintptr_t)m->mod_modname) == -1) 7367c478bd9Sstevel@tonic-gate return (WALK_ERR); 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate return (WALK_DONE); 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate static int 7427c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr(void *varg, GElf_Addr addr, GElf_Sym *symp, 7437c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip) 7447c478bd9Sstevel@tonic-gate { 7457c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate if (data->dtmd_symstr == NULL) { 7487c478bd9Sstevel@tonic-gate data->dtmd_symstr = mdb_zalloc(MDB_SYM_NAMLEN, 7497c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 7507c478bd9Sstevel@tonic-gate } 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate if (data->dtmd_modstr == NULL) { 7537c478bd9Sstevel@tonic-gate data->dtmd_modstr = mdb_zalloc(MDB_SYM_NAMLEN, 7547c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 7557c478bd9Sstevel@tonic-gate } 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate if (symp != NULL) { 7587c478bd9Sstevel@tonic-gate if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, data->dtmd_symstr, 7597c478bd9Sstevel@tonic-gate MDB_SYM_NAMLEN, symp) == -1) 7607c478bd9Sstevel@tonic-gate return (-1); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate if (sip != NULL) { 7647c478bd9Sstevel@tonic-gate data->dtmd_addr = addr; 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate (void) strcpy(data->dtmd_modstr, "???"); 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate if (mdb_walk("modctl", 7697c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtracemdb_modctl, varg) == -1) { 7707c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'modctl'"); 7717c478bd9Sstevel@tonic-gate return (-1); 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate sip->dts_object = data->dtmd_modstr; 7757c478bd9Sstevel@tonic-gate sip->dts_id = 0; 7767c478bd9Sstevel@tonic-gate sip->dts_name = symp != NULL ? data->dtmd_symstr : NULL; 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate return (0); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7837c478bd9Sstevel@tonic-gate static int 7847c478bd9Sstevel@tonic-gate dtracemdb_stat(void *varg, processorid_t cpu) 7857c478bd9Sstevel@tonic-gate { 7867c478bd9Sstevel@tonic-gate GElf_Sym sym; 7877c478bd9Sstevel@tonic-gate cpu_t c; 7887c478bd9Sstevel@tonic-gate uintptr_t caddr, addr; 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("cpu", &sym) == -1) { 7917c478bd9Sstevel@tonic-gate mdb_warn("failed to find symbol for 'cpu'"); 7927c478bd9Sstevel@tonic-gate return (-1); 7937c478bd9Sstevel@tonic-gate } 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate if (cpu * sizeof (uintptr_t) > sym.st_size) 7967c478bd9Sstevel@tonic-gate return (-1); 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value + cpu * sizeof (uintptr_t); 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate if (mdb_vread(&caddr, sizeof (caddr), addr) == -1) { 8017c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu[%d]", cpu); 8027c478bd9Sstevel@tonic-gate return (-1); 8037c478bd9Sstevel@tonic-gate } 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate if (caddr == NULL) 8067c478bd9Sstevel@tonic-gate return (-1); 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), caddr) == -1) { 8097c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu at %p", caddr); 8107c478bd9Sstevel@tonic-gate return (-1); 8117c478bd9Sstevel@tonic-gate } 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate if (c.cpu_flags & CPU_POWEROFF) { 8147c478bd9Sstevel@tonic-gate return (P_POWEROFF); 8157c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_SPARE) { 8167c478bd9Sstevel@tonic-gate return (P_SPARE); 8177c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_FAULTED) { 8187c478bd9Sstevel@tonic-gate return (P_FAULTED); 8197c478bd9Sstevel@tonic-gate } else if ((c.cpu_flags & (CPU_READY | CPU_OFFLINE)) != CPU_READY) { 8207c478bd9Sstevel@tonic-gate return (P_OFFLINE); 8217c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_ENABLE) { 8227c478bd9Sstevel@tonic-gate return (P_ONLINE); 8237c478bd9Sstevel@tonic-gate } else { 8247c478bd9Sstevel@tonic-gate return (P_NOINTR); 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8297c478bd9Sstevel@tonic-gate static long 8307c478bd9Sstevel@tonic-gate dtracemdb_sysconf(void *varg, int name) 8317c478bd9Sstevel@tonic-gate { 8327c478bd9Sstevel@tonic-gate int max_ncpus; 8337c478bd9Sstevel@tonic-gate processorid_t max_cpuid; 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate switch (name) { 8367c478bd9Sstevel@tonic-gate case _SC_CPUID_MAX: 8377c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) { 8387c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'"); 8397c478bd9Sstevel@tonic-gate return (-1); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate return (max_cpuid); 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate case _SC_NPROCESSORS_MAX: 8457c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) { 8467c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_ncpus'"); 8477c478bd9Sstevel@tonic-gate return (-1); 8487c478bd9Sstevel@tonic-gate } 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate return (max_ncpus); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate default: 8537c478bd9Sstevel@tonic-gate mdb_warn("unexpected sysconf code %d\n", name); 8547c478bd9Sstevel@tonic-gate return (-1); 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate const dtrace_vector_t dtrace_mdbops = { 8597c478bd9Sstevel@tonic-gate dtracemdb_ioctl, 8607c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr, 8617c478bd9Sstevel@tonic-gate dtracemdb_stat, 8627c478bd9Sstevel@tonic-gate dtracemdb_sysconf 8637c478bd9Sstevel@tonic-gate }; 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate typedef struct dtrace_dcmddata { 8667c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtdd_dtp; 8677c478bd9Sstevel@tonic-gate int dtdd_cpu; 8687c478bd9Sstevel@tonic-gate int dtdd_quiet; 8697c478bd9Sstevel@tonic-gate int dtdd_flowindent; 8707c478bd9Sstevel@tonic-gate int dtdd_heading; 8717c478bd9Sstevel@tonic-gate } dtrace_dcmddata_t; 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8747c478bd9Sstevel@tonic-gate static int 8757c478bd9Sstevel@tonic-gate dtrace_dcmdrec(const dtrace_probedata_t *data, 8767c478bd9Sstevel@tonic-gate const dtrace_recdesc_t *rec, void *arg) 8777c478bd9Sstevel@tonic-gate { 8787c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate if (rec == NULL) { 8817c478bd9Sstevel@tonic-gate /* 8827c478bd9Sstevel@tonic-gate * We have processed the final record; output the newline if 8837c478bd9Sstevel@tonic-gate * we're not in quiet mode. 8847c478bd9Sstevel@tonic-gate */ 8857c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) 8867c478bd9Sstevel@tonic-gate mdb_printf("\n"); 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 8897c478bd9Sstevel@tonic-gate } 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8957c478bd9Sstevel@tonic-gate static int 8967c478bd9Sstevel@tonic-gate dtrace_dcmdprobe(const dtrace_probedata_t *data, void *arg) 8977c478bd9Sstevel@tonic-gate { 8987c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pd = data->dtpda_pdesc; 8997c478bd9Sstevel@tonic-gate processorid_t cpu = data->dtpda_cpu; 9007c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 9017c478bd9Sstevel@tonic-gate char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2]; 9027c478bd9Sstevel@tonic-gate 9037c478bd9Sstevel@tonic-gate if (dd->dtdd_cpu != -1UL && dd->dtdd_cpu != cpu) 9047c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate if (dd->dtdd_heading == 0) { 9077c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 9087c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 9097c478bd9Sstevel@tonic-gate mdb_printf("%3s %6s %32s\n", 9107c478bd9Sstevel@tonic-gate "CPU", "ID", "FUNCTION:NAME"); 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate } else { 9137c478bd9Sstevel@tonic-gate mdb_printf("%3s %-41s\n", "CPU", "FUNCTION"); 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate dd->dtdd_heading = 1; 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 9197c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 9207c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%s:%s", 9217c478bd9Sstevel@tonic-gate pd->dtpd_func, pd->dtpd_name); 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate mdb_printf("%3d %6d %32s ", cpu, pd->dtpd_id, name); 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate } else { 9267c478bd9Sstevel@tonic-gate int indent = data->dtpda_indent; 9277c478bd9Sstevel@tonic-gate 9287c478bd9Sstevel@tonic-gate if (data->dtpda_flow == DTRACEFLOW_NONE) { 9297c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s:%s", 9307c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func, 9317c478bd9Sstevel@tonic-gate pd->dtpd_name); 9327c478bd9Sstevel@tonic-gate } else { 9337c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s", 9347c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func); 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate mdb_printf("%3d %-41s ", cpu, name); 9387c478bd9Sstevel@tonic-gate } 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 9417c478bd9Sstevel@tonic-gate } 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9447c478bd9Sstevel@tonic-gate static int 945*a1b5e537Sbmc dtrace_dcmderr(const dtrace_errdata_t *data, void *arg) 9467c478bd9Sstevel@tonic-gate { 9477c478bd9Sstevel@tonic-gate mdb_warn(data->dteda_msg); 9487c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 9497c478bd9Sstevel@tonic-gate } 9507c478bd9Sstevel@tonic-gate 9517c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9527c478bd9Sstevel@tonic-gate static int 953*a1b5e537Sbmc dtrace_dcmddrop(const dtrace_dropdata_t *data, void *arg) 9547c478bd9Sstevel@tonic-gate { 9557c478bd9Sstevel@tonic-gate mdb_warn(data->dtdda_msg); 9567c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 9577c478bd9Sstevel@tonic-gate } 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9607c478bd9Sstevel@tonic-gate static int 961*a1b5e537Sbmc dtrace_dcmdbuffered(const dtrace_bufdata_t *bufdata, void *arg) 9627c478bd9Sstevel@tonic-gate { 9637c478bd9Sstevel@tonic-gate mdb_printf("%s", bufdata->dtbda_buffered); 9647c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 9657c478bd9Sstevel@tonic-gate } 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9687c478bd9Sstevel@tonic-gate int 9697c478bd9Sstevel@tonic-gate dtrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 9707c478bd9Sstevel@tonic-gate { 9717c478bd9Sstevel@tonic-gate dtrace_state_t state; 9727c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp; 9737c478bd9Sstevel@tonic-gate int ncpu, err; 9747c478bd9Sstevel@tonic-gate uintptr_t c = -1UL; 9757c478bd9Sstevel@tonic-gate dtrace_dcmddata_t dd; 9767c478bd9Sstevel@tonic-gate dtrace_optval_t val; 9777c478bd9Sstevel@tonic-gate dtracemdb_data_t md; 9787c478bd9Sstevel@tonic-gate int rval = DCMD_ERR; 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 9817c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'c', MDB_OPT_UINTPTR, &c, NULL) != argc) 9847c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 9877c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 9887c478bd9Sstevel@tonic-gate return (DCMD_ERR); 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 9927c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", addr); 9937c478bd9Sstevel@tonic-gate return (DCMD_ERR); 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate bzero(&md, sizeof (md)); 9977c478bd9Sstevel@tonic-gate md.dtmd_state = &state; 9987c478bd9Sstevel@tonic-gate 9997c478bd9Sstevel@tonic-gate if ((dtp = dtrace_vopen(DTRACE_VERSION, DTRACE_O_NOSYS, &err, 10007c478bd9Sstevel@tonic-gate &dtrace_mdbops, &md)) == NULL) { 10017c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 10027c478bd9Sstevel@tonic-gate dtrace_errmsg(NULL, err)); 10037c478bd9Sstevel@tonic-gate return (DCMD_ERR); 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate if (dtrace_go(dtp) != 0) { 10077c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 10087c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10097c478bd9Sstevel@tonic-gate goto err; 10107c478bd9Sstevel@tonic-gate } 10117c478bd9Sstevel@tonic-gate 10127c478bd9Sstevel@tonic-gate bzero(&dd, sizeof (dd)); 10137c478bd9Sstevel@tonic-gate dd.dtdd_dtp = dtp; 10147c478bd9Sstevel@tonic-gate dd.dtdd_cpu = c; 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "flowindent", &val) == -1) { 10177c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'flowindent' option: %s\n", 10187c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10197c478bd9Sstevel@tonic-gate goto err; 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate dd.dtdd_flowindent = (val != DTRACEOPT_UNSET); 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "quiet", &val) == -1) { 10257c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'quiet' option: %s\n", 10267c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10277c478bd9Sstevel@tonic-gate goto err; 10287c478bd9Sstevel@tonic-gate } 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate dd.dtdd_quiet = (val != DTRACEOPT_UNSET); 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate if (dtrace_handle_err(dtp, dtrace_dcmderr, NULL) == -1) { 10337c478bd9Sstevel@tonic-gate mdb_warn("couldn't add err handler: %s\n", 10347c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10357c478bd9Sstevel@tonic-gate goto err; 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate if (dtrace_handle_drop(dtp, dtrace_dcmddrop, NULL) == -1) { 10397c478bd9Sstevel@tonic-gate mdb_warn("couldn't add drop handler: %s\n", 10407c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10417c478bd9Sstevel@tonic-gate goto err; 10427c478bd9Sstevel@tonic-gate } 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate if (dtrace_handle_buffered(dtp, dtrace_dcmdbuffered, NULL) == -1) { 10457c478bd9Sstevel@tonic-gate mdb_warn("couldn't add buffered handler: %s\n", 10467c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10477c478bd9Sstevel@tonic-gate goto err; 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate if (dtrace_status(dtp) == -1) { 10517c478bd9Sstevel@tonic-gate mdb_warn("couldn't get status: %s\n", 10527c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10537c478bd9Sstevel@tonic-gate goto err; 10547c478bd9Sstevel@tonic-gate } 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate if (dtrace_aggregate_snap(dtp) == -1) { 10577c478bd9Sstevel@tonic-gate mdb_warn("couldn't snapshot aggregation: %s\n", 10587c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10597c478bd9Sstevel@tonic-gate goto err; 10607c478bd9Sstevel@tonic-gate } 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate if (dtrace_consume(dtp, NULL, 10637c478bd9Sstevel@tonic-gate dtrace_dcmdprobe, dtrace_dcmdrec, &dd) == -1) { 10647c478bd9Sstevel@tonic-gate mdb_warn("couldn't consume DTrace buffers: %s\n", 10657c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 10667c478bd9Sstevel@tonic-gate } 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate if (dtrace_aggregate_print(dtp, NULL, NULL) == -1) { 10697c478bd9Sstevel@tonic-gate mdb_warn("couldn't print aggregation: %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 rval = DCMD_OK; 10757c478bd9Sstevel@tonic-gate err: 10767c478bd9Sstevel@tonic-gate dtrace_close(dtp); 10777c478bd9Sstevel@tonic-gate return (rval); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate static int 10817c478bd9Sstevel@tonic-gate dtrace_errhash_cmp(const void *l, const void *r) 10827c478bd9Sstevel@tonic-gate { 10837c478bd9Sstevel@tonic-gate uintptr_t lhs = *((uintptr_t *)l); 10847c478bd9Sstevel@tonic-gate uintptr_t rhs = *((uintptr_t *)r); 10857c478bd9Sstevel@tonic-gate dtrace_errhash_t lerr, rerr; 10867c478bd9Sstevel@tonic-gate char lmsg[256], rmsg[256]; 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate (void) mdb_vread(&lerr, sizeof (lerr), lhs); 10897c478bd9Sstevel@tonic-gate (void) mdb_vread(&rerr, sizeof (rerr), rhs); 10907c478bd9Sstevel@tonic-gate 10917c478bd9Sstevel@tonic-gate if (lerr.dter_msg == NULL) 10927c478bd9Sstevel@tonic-gate return (-1); 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate if (rerr.dter_msg == NULL) 10957c478bd9Sstevel@tonic-gate return (1); 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate (void) mdb_readstr(lmsg, sizeof (lmsg), (uintptr_t)lerr.dter_msg); 10987c478bd9Sstevel@tonic-gate (void) mdb_readstr(rmsg, sizeof (rmsg), (uintptr_t)rerr.dter_msg); 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate return (strcmp(lmsg, rmsg)); 11017c478bd9Sstevel@tonic-gate } 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate int 11047c478bd9Sstevel@tonic-gate dtrace_errhash_init(mdb_walk_state_t *wsp) 11057c478bd9Sstevel@tonic-gate { 11067c478bd9Sstevel@tonic-gate GElf_Sym sym; 11077c478bd9Sstevel@tonic-gate uintptr_t *hash, addr; 11087c478bd9Sstevel@tonic-gate int i; 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 11117c478bd9Sstevel@tonic-gate mdb_warn("dtrace_errhash walk only supports global walks\n"); 11127c478bd9Sstevel@tonic-gate return (WALK_ERR); 11137c478bd9Sstevel@tonic-gate } 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("dtrace_errhash", &sym) == -1) { 11167c478bd9Sstevel@tonic-gate mdb_warn("couldn't find 'dtrace_errhash' (non-DEBUG kernel?)"); 11177c478bd9Sstevel@tonic-gate return (WALK_ERR); 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value; 11217c478bd9Sstevel@tonic-gate hash = mdb_alloc(DTRACE_ERRHASHSZ * sizeof (uintptr_t), 11227c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACE_ERRHASHSZ; i++) 11257c478bd9Sstevel@tonic-gate hash[i] = addr + i * sizeof (dtrace_errhash_t); 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate qsort(hash, DTRACE_ERRHASHSZ, sizeof (uintptr_t), dtrace_errhash_cmp); 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 11307c478bd9Sstevel@tonic-gate wsp->walk_data = hash; 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate return (WALK_NEXT); 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate int 11367c478bd9Sstevel@tonic-gate dtrace_errhash_step(mdb_walk_state_t *wsp) 11377c478bd9Sstevel@tonic-gate { 11387c478bd9Sstevel@tonic-gate int ndx = (int)wsp->walk_addr; 11397c478bd9Sstevel@tonic-gate uintptr_t *hash = wsp->walk_data; 11407c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 11417c478bd9Sstevel@tonic-gate uintptr_t addr; 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate if (ndx >= DTRACE_ERRHASHSZ) 11447c478bd9Sstevel@tonic-gate return (WALK_DONE); 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate wsp->walk_addr = ndx + 1; 11477c478bd9Sstevel@tonic-gate addr = hash[ndx]; 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 11507c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 11517c478bd9Sstevel@tonic-gate return (WALK_DONE); 11527c478bd9Sstevel@tonic-gate } 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate if (err.dter_msg == NULL) 11557c478bd9Sstevel@tonic-gate return (WALK_NEXT); 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &err, wsp->walk_cbdata)); 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11617c478bd9Sstevel@tonic-gate int 11627c478bd9Sstevel@tonic-gate dtrace_errhash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 11637c478bd9Sstevel@tonic-gate { 11647c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 11657c478bd9Sstevel@tonic-gate char msg[256]; 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 11687c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_errhash", "dtrace_errhash", 11697c478bd9Sstevel@tonic-gate argc, argv) == -1) { 11707c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_errhash'"); 11717c478bd9Sstevel@tonic-gate return (DCMD_ERR); 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate return (DCMD_OK); 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) 11787c478bd9Sstevel@tonic-gate mdb_printf("%8s %s\n", "COUNT", "ERROR"); 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 11817c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 11827c478bd9Sstevel@tonic-gate return (DCMD_ERR); 11837c478bd9Sstevel@tonic-gate } 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate addr = (uintptr_t)err.dter_msg; 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate if (mdb_readstr(msg, sizeof (msg), addr) == -1) { 11887c478bd9Sstevel@tonic-gate mdb_warn("failed to read error msg at %p", addr); 11897c478bd9Sstevel@tonic-gate return (DCMD_ERR); 11907c478bd9Sstevel@tonic-gate } 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate mdb_printf("%8d %s", err.dter_count, msg); 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate /* 11957c478bd9Sstevel@tonic-gate * Some error messages include a newline -- only print the newline 11967c478bd9Sstevel@tonic-gate * if the message doesn't have one. 11977c478bd9Sstevel@tonic-gate */ 11987c478bd9Sstevel@tonic-gate if (msg[strlen(msg) - 1] != '\n') 11997c478bd9Sstevel@tonic-gate mdb_printf("\n"); 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate return (DCMD_OK); 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate int 12057c478bd9Sstevel@tonic-gate dtrace_helptrace_init(mdb_walk_state_t *wsp) 12067c478bd9Sstevel@tonic-gate { 12077c478bd9Sstevel@tonic-gate uint32_t next; 12087c478bd9Sstevel@tonic-gate int enabled; 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 12117c478bd9Sstevel@tonic-gate mdb_warn("dtrace_helptrace only supports global walks\n"); 12127c478bd9Sstevel@tonic-gate return (WALK_ERR); 12137c478bd9Sstevel@tonic-gate } 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate if (mdb_readvar(&enabled, "dtrace_helptrace_enabled") == -1) { 12167c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_enabled'"); 12177c478bd9Sstevel@tonic-gate return (WALK_ERR); 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate if (!enabled) { 12217c478bd9Sstevel@tonic-gate mdb_warn("helper tracing is not enabled\n"); 12227c478bd9Sstevel@tonic-gate return (WALK_ERR); 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 12267c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 12277c478bd9Sstevel@tonic-gate return (WALK_ERR); 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate wsp->walk_addr = next; 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate return (WALK_NEXT); 12337c478bd9Sstevel@tonic-gate } 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate int 12367c478bd9Sstevel@tonic-gate dtrace_helptrace_step(mdb_walk_state_t *wsp) 12377c478bd9Sstevel@tonic-gate { 12387c478bd9Sstevel@tonic-gate uint32_t next, size, nlocals, bufsize; 12397c478bd9Sstevel@tonic-gate uintptr_t buffer, addr; 12407c478bd9Sstevel@tonic-gate dtrace_helptrace_t *ht; 12417c478bd9Sstevel@tonic-gate int rval; 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 12447c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 12457c478bd9Sstevel@tonic-gate return (WALK_ERR); 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate if (mdb_readvar(&bufsize, "dtrace_helptrace_bufsize") == -1) { 12497c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_bufsize'"); 12507c478bd9Sstevel@tonic-gate return (WALK_ERR); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) { 12547c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_buffer'"); 12557c478bd9Sstevel@tonic-gate return (WALK_ERR); 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate if (mdb_readvar(&nlocals, "dtrace_helptrace_nlocals") == -1) { 12597c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_nlocals'"); 12607c478bd9Sstevel@tonic-gate return (WALK_ERR); 12617c478bd9Sstevel@tonic-gate } 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate size = sizeof (dtrace_helptrace_t) + 12647c478bd9Sstevel@tonic-gate nlocals * sizeof (uint64_t) - sizeof (uint64_t); 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate if (wsp->walk_addr + size > bufsize) { 12677c478bd9Sstevel@tonic-gate if (next == 0) 12687c478bd9Sstevel@tonic-gate return (WALK_DONE); 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate addr = buffer + wsp->walk_addr; 12747c478bd9Sstevel@tonic-gate ht = alloca(size); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate if (mdb_vread(ht, size, addr) == -1) { 12777c478bd9Sstevel@tonic-gate mdb_warn("couldn't read entry at %p", addr); 12787c478bd9Sstevel@tonic-gate return (WALK_ERR); 12797c478bd9Sstevel@tonic-gate } 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate if (ht->dtht_helper != NULL) { 12827c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(addr, ht, wsp->walk_cbdata); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate if (rval != WALK_NEXT) 12857c478bd9Sstevel@tonic-gate return (rval); 12867c478bd9Sstevel@tonic-gate } 12877c478bd9Sstevel@tonic-gate 12887c478bd9Sstevel@tonic-gate if (wsp->walk_addr < next && wsp->walk_addr + size >= next) 12897c478bd9Sstevel@tonic-gate return (WALK_DONE); 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate wsp->walk_addr += size; 12927c478bd9Sstevel@tonic-gate return (WALK_NEXT); 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate int 12967c478bd9Sstevel@tonic-gate dtrace_helptrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 12977c478bd9Sstevel@tonic-gate { 12987c478bd9Sstevel@tonic-gate dtrace_helptrace_t help; 12997c478bd9Sstevel@tonic-gate dtrace_helper_action_t helper; 13007c478bd9Sstevel@tonic-gate char where[30]; 13017c478bd9Sstevel@tonic-gate uint_t opt_v = FALSE; 13027c478bd9Sstevel@tonic-gate uintptr_t haddr; 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 13057c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_helptrace", "dtrace_helptrace", 13067c478bd9Sstevel@tonic-gate argc, argv) == -1) { 13077c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_helptrace'"); 13087c478bd9Sstevel@tonic-gate return (DCMD_ERR); 13097c478bd9Sstevel@tonic-gate } 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate return (DCMD_OK); 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate 13147c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'v', 13157c478bd9Sstevel@tonic-gate MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc) 13167c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 13197c478bd9Sstevel@tonic-gate mdb_printf(" %?s %?s %12s %s\n", 13207c478bd9Sstevel@tonic-gate "ADDR", "HELPER", "WHERE", "DIFO"); 13217c478bd9Sstevel@tonic-gate } 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate if (mdb_vread(&help, sizeof (help), addr) == -1) { 13247c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_helptrace_t at %p", addr); 13257c478bd9Sstevel@tonic-gate return (DCMD_ERR); 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 13297c478bd9Sstevel@tonic-gate case 0: 13307c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "predicate"); 13317c478bd9Sstevel@tonic-gate break; 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 13347c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "next"); 13357c478bd9Sstevel@tonic-gate break; 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 13387c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "done"); 13397c478bd9Sstevel@tonic-gate break; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 13427c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "err"); 13437c478bd9Sstevel@tonic-gate break; 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate default: 13467c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), 13477c478bd9Sstevel@tonic-gate "action #%d", help.dtht_where); 13487c478bd9Sstevel@tonic-gate break; 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate mdb_printf(" %?p %?p %12s ", addr, help.dtht_helper, where); 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate haddr = (uintptr_t)help.dtht_helper; 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate if (mdb_vread(&helper, sizeof (helper), haddr) == -1) { 13567c478bd9Sstevel@tonic-gate /* 13577c478bd9Sstevel@tonic-gate * We're not going to warn in this case -- we're just not going 13587c478bd9Sstevel@tonic-gate * to print anything exciting. 13597c478bd9Sstevel@tonic-gate */ 13607c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 13617c478bd9Sstevel@tonic-gate } else { 13627c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 13637c478bd9Sstevel@tonic-gate case 0: 13647c478bd9Sstevel@tonic-gate mdb_printf("%p\n", helper.dthp_predicate); 13657c478bd9Sstevel@tonic-gate break; 13667c478bd9Sstevel@tonic-gate 13677c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 13687c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 13697c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 13707c478bd9Sstevel@tonic-gate mdb_printf("-\n"); 13717c478bd9Sstevel@tonic-gate break; 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate default: 13747c478bd9Sstevel@tonic-gate haddr = (uintptr_t)helper.dthp_actions + 13757c478bd9Sstevel@tonic-gate (help.dtht_where - 1) * sizeof (uintptr_t); 13767c478bd9Sstevel@tonic-gate 13777c478bd9Sstevel@tonic-gate if (mdb_vread(&haddr, sizeof (haddr), haddr) == -1) { 13787c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 13797c478bd9Sstevel@tonic-gate } else { 13807c478bd9Sstevel@tonic-gate mdb_printf("%p\n", haddr); 13817c478bd9Sstevel@tonic-gate } 13827c478bd9Sstevel@tonic-gate } 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate 13857c478bd9Sstevel@tonic-gate if (opt_v) { 13867c478bd9Sstevel@tonic-gate int i; 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate mdb_printf("%?s|\n%?s+--> %?s %4s %s\n", "", "", 13897c478bd9Sstevel@tonic-gate "ADDR", "NDX", "VALUE"); 13907c478bd9Sstevel@tonic-gate addr += sizeof (help) - sizeof (uint64_t); 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate for (i = 0; i < help.dtht_nlocals; i++) { 13937c478bd9Sstevel@tonic-gate uint64_t val; 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate if (mdb_vread(&val, sizeof (val), addr) == -1) { 13967c478bd9Sstevel@tonic-gate mdb_warn("couldn't read local at %p", addr); 13977c478bd9Sstevel@tonic-gate continue; 13987c478bd9Sstevel@tonic-gate } 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate mdb_printf("%?s %?p %4d %p\n", "", addr, i, val); 14017c478bd9Sstevel@tonic-gate addr += sizeof (uint64_t); 14027c478bd9Sstevel@tonic-gate } 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate mdb_printf("\n"); 14057c478bd9Sstevel@tonic-gate } 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate return (DCMD_OK); 14087c478bd9Sstevel@tonic-gate } 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14117c478bd9Sstevel@tonic-gate static int 14127c478bd9Sstevel@tonic-gate dtrace_state_walk(uintptr_t addr, const vmem_seg_t *seg, minor_t *highest) 14137c478bd9Sstevel@tonic-gate { 14147c478bd9Sstevel@tonic-gate if (seg->vs_end > *highest) 14157c478bd9Sstevel@tonic-gate *highest = seg->vs_end; 14167c478bd9Sstevel@tonic-gate 14177c478bd9Sstevel@tonic-gate return (WALK_NEXT); 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate typedef struct dtrace_state_walk { 14217c478bd9Sstevel@tonic-gate uintptr_t dtsw_softstate; 14227c478bd9Sstevel@tonic-gate minor_t dtsw_max; 14237c478bd9Sstevel@tonic-gate minor_t dtsw_current; 14247c478bd9Sstevel@tonic-gate } dtrace_state_walk_t; 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate int 14277c478bd9Sstevel@tonic-gate dtrace_state_init(mdb_walk_state_t *wsp) 14287c478bd9Sstevel@tonic-gate { 14297c478bd9Sstevel@tonic-gate uintptr_t dtrace_minor; 14307c478bd9Sstevel@tonic-gate minor_t max = 0; 14317c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw; 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 14347c478bd9Sstevel@tonic-gate mdb_warn("dtrace_state only supports global walks\n"); 14357c478bd9Sstevel@tonic-gate return (WALK_ERR); 14367c478bd9Sstevel@tonic-gate } 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate /* 14397c478bd9Sstevel@tonic-gate * Find the dtrace_minor vmem arena and walk it to get the maximum 14407c478bd9Sstevel@tonic-gate * minor number. 14417c478bd9Sstevel@tonic-gate */ 14427c478bd9Sstevel@tonic-gate if (mdb_readvar(&dtrace_minor, "dtrace_minor") == -1) { 14437c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_minor'"); 14447c478bd9Sstevel@tonic-gate return (WALK_ERR); 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)dtrace_state_walk, 14487c478bd9Sstevel@tonic-gate &max, dtrace_minor) == -1) { 14497c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'vmem_alloc'"); 14507c478bd9Sstevel@tonic-gate return (WALK_ERR); 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate dw = mdb_zalloc(sizeof (dtrace_state_walk_t), UM_SLEEP | UM_GC); 14547c478bd9Sstevel@tonic-gate dw->dtsw_current = 0; 14557c478bd9Sstevel@tonic-gate dw->dtsw_max = max; 14567c478bd9Sstevel@tonic-gate 14577c478bd9Sstevel@tonic-gate if (mdb_readvar(&dw->dtsw_softstate, "dtrace_softstate") == -1) { 14587c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 14597c478bd9Sstevel@tonic-gate return (DCMD_ERR); 14607c478bd9Sstevel@tonic-gate } 14617c478bd9Sstevel@tonic-gate 14627c478bd9Sstevel@tonic-gate wsp->walk_data = dw; 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate return (WALK_NEXT); 14657c478bd9Sstevel@tonic-gate } 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate int 14687c478bd9Sstevel@tonic-gate dtrace_state_step(mdb_walk_state_t *wsp) 14697c478bd9Sstevel@tonic-gate { 14707c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw = wsp->walk_data; 14717c478bd9Sstevel@tonic-gate uintptr_t statep; 14727c478bd9Sstevel@tonic-gate dtrace_state_t state; 14737c478bd9Sstevel@tonic-gate int rval; 14747c478bd9Sstevel@tonic-gate 14757c478bd9Sstevel@tonic-gate while (mdb_get_soft_state_byaddr(dw->dtsw_softstate, dw->dtsw_current, 14767c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 14777c478bd9Sstevel@tonic-gate if (dw->dtsw_current >= dw->dtsw_max) 14787c478bd9Sstevel@tonic-gate return (WALK_DONE); 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate dw->dtsw_current++; 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), statep) == -1) { 14847c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", statep); 14857c478bd9Sstevel@tonic-gate return (WALK_NEXT); 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(statep, &state, wsp->walk_cbdata); 14897c478bd9Sstevel@tonic-gate dw->dtsw_current++; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate return (rval); 14927c478bd9Sstevel@tonic-gate } 14937c478bd9Sstevel@tonic-gate 14947c478bd9Sstevel@tonic-gate typedef struct dtrace_state_data { 14957c478bd9Sstevel@tonic-gate int dtsd_major; 14967c478bd9Sstevel@tonic-gate uintptr_t dtsd_proc; 14977c478bd9Sstevel@tonic-gate uintptr_t dtsd_softstate; 14987c478bd9Sstevel@tonic-gate uintptr_t dtsd_state; 14997c478bd9Sstevel@tonic-gate } dtrace_state_data_t; 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate static int 15027c478bd9Sstevel@tonic-gate dtrace_state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data) 15037c478bd9Sstevel@tonic-gate { 15047c478bd9Sstevel@tonic-gate vnode_t vnode; 15057c478bd9Sstevel@tonic-gate proc_t proc; 15067c478bd9Sstevel@tonic-gate minor_t minor; 15077c478bd9Sstevel@tonic-gate uintptr_t statep; 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) { 15107c478bd9Sstevel@tonic-gate mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode); 15117c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15127c478bd9Sstevel@tonic-gate } 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate if (getmajor(vnode.v_rdev) != data->dtsd_major) 15157c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate minor = getminor(vnode.v_rdev); 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate if (mdb_vread(&proc, sizeof (proc), data->dtsd_proc) == -1) { 15207c478bd9Sstevel@tonic-gate mdb_warn("failed to read proc at %p", data->dtsd_proc); 15217c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor, 15257c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 15267c478bd9Sstevel@tonic-gate mdb_warn("failed to read softstate for minor %d", minor); 15277c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate if (statep != data->dtsd_state) 15317c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?p %-*s %?p\n", statep, minor, 15347c478bd9Sstevel@tonic-gate data->dtsd_proc, MAXCOMLEN, proc.p_user.u_comm, addr); 15357c478bd9Sstevel@tonic-gate 15367c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15377c478bd9Sstevel@tonic-gate } 15387c478bd9Sstevel@tonic-gate 15397c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 15407c478bd9Sstevel@tonic-gate static int 15417c478bd9Sstevel@tonic-gate dtrace_state_proc(uintptr_t addr, void *ignored, dtrace_state_data_t *data) 15427c478bd9Sstevel@tonic-gate { 15437c478bd9Sstevel@tonic-gate data->dtsd_proc = addr; 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate if (mdb_pwalk("file", 15467c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_state_file, data, addr) == -1) { 15477c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'file' for proc %p", addr); 15487c478bd9Sstevel@tonic-gate return (WALK_ERR); 15497c478bd9Sstevel@tonic-gate } 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate return (WALK_NEXT); 15527c478bd9Sstevel@tonic-gate } 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate void 15557c478bd9Sstevel@tonic-gate dtrace_state_help(void) 15567c478bd9Sstevel@tonic-gate { 15577c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure, displays all " 15587c478bd9Sstevel@tonic-gate /*CSTYLED*/ 15597c478bd9Sstevel@tonic-gate "consumers, or \"<anonymous>\"\nif the consumer is anonymous. If " 15607c478bd9Sstevel@tonic-gate "no state structure is provided, iterates\nover all state " 15617c478bd9Sstevel@tonic-gate "structures.\n\n" 15627c478bd9Sstevel@tonic-gate "Addresses in ADDR column may be provided to ::dtrace to obtain\n" 15637c478bd9Sstevel@tonic-gate "dtrace(1M)-like output for in-kernel DTrace data.\n"); 15647c478bd9Sstevel@tonic-gate } 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate int 15677c478bd9Sstevel@tonic-gate dtrace_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 15687c478bd9Sstevel@tonic-gate { 15697c478bd9Sstevel@tonic-gate uintptr_t devi; 15707c478bd9Sstevel@tonic-gate struct dev_info info; 15717c478bd9Sstevel@tonic-gate dtrace_state_data_t data; 15727c478bd9Sstevel@tonic-gate dtrace_anon_t anon; 15737c478bd9Sstevel@tonic-gate dtrace_state_t state; 15747c478bd9Sstevel@tonic-gate 15757c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 15767c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_state", 15777c478bd9Sstevel@tonic-gate "dtrace_state", argc, argv) == -1) { 15787c478bd9Sstevel@tonic-gate mdb_warn("can't walk dtrace_state"); 15797c478bd9Sstevel@tonic-gate return (DCMD_ERR); 15807c478bd9Sstevel@tonic-gate } 15817c478bd9Sstevel@tonic-gate return (DCMD_OK); 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 15857c478bd9Sstevel@tonic-gate mdb_printf("%?s %5s %?s %-*s %?s\n", "ADDR", "MINOR", "PROC", 15867c478bd9Sstevel@tonic-gate MAXCOMLEN, "NAME", "FILE"); 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate /* 15907c478bd9Sstevel@tonic-gate * First determine if this is anonymous state. 15917c478bd9Sstevel@tonic-gate */ 15927c478bd9Sstevel@tonic-gate if (mdb_readvar(&anon, "dtrace_anon") == -1) { 15937c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_anon'"); 15947c478bd9Sstevel@tonic-gate return (DCMD_ERR); 15957c478bd9Sstevel@tonic-gate } 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate if ((uintptr_t)anon.dta_state == addr) { 15987c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 15997c478bd9Sstevel@tonic-gate mdb_warn("failed to read anon at %p", addr); 16007c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16017c478bd9Sstevel@tonic-gate } 16027c478bd9Sstevel@tonic-gate 16037c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?s %-*s %?s\n", addr, 16047c478bd9Sstevel@tonic-gate getminor(state.dts_dev), "-", MAXCOMLEN, 16057c478bd9Sstevel@tonic-gate "<anonymous>", "-"); 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate return (DCMD_OK); 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate if (mdb_readvar(&devi, "dtrace_devi") == -1) { 16117c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_devi'"); 16127c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16137c478bd9Sstevel@tonic-gate } 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) { 16167c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dev_info'"); 16177c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16187c478bd9Sstevel@tonic-gate } 16197c478bd9Sstevel@tonic-gate 16207c478bd9Sstevel@tonic-gate data.dtsd_major = info.devi_major; 16217c478bd9Sstevel@tonic-gate 16227c478bd9Sstevel@tonic-gate if (mdb_readvar(&data.dtsd_softstate, "dtrace_softstate") == -1) { 16237c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 16247c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate data.dtsd_state = addr; 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate /* 16307c478bd9Sstevel@tonic-gate * Walk through all processes and all open files looking for this 16317c478bd9Sstevel@tonic-gate * state. It must be open somewhere... 16327c478bd9Sstevel@tonic-gate */ 16337c478bd9Sstevel@tonic-gate if (mdb_walk("proc", (mdb_walk_cb_t)dtrace_state_proc, &data) == -1) { 16347c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'proc'"); 16357c478bd9Sstevel@tonic-gate return (DCMD_ERR); 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate 16387c478bd9Sstevel@tonic-gate return (DCMD_OK); 16397c478bd9Sstevel@tonic-gate } 16407c478bd9Sstevel@tonic-gate 16417c478bd9Sstevel@tonic-gate typedef struct dtrace_aggkey_data { 16427c478bd9Sstevel@tonic-gate uintptr_t *dtakd_hash; 16437c478bd9Sstevel@tonic-gate uintptr_t dtakd_hashsize; 16447c478bd9Sstevel@tonic-gate uintptr_t dtakd_next; 16457c478bd9Sstevel@tonic-gate uintptr_t dtakd_ndx; 16467c478bd9Sstevel@tonic-gate } dtrace_aggkey_data_t; 16477c478bd9Sstevel@tonic-gate 16487c478bd9Sstevel@tonic-gate int 16497c478bd9Sstevel@tonic-gate dtrace_aggkey_init(mdb_walk_state_t *wsp) 16507c478bd9Sstevel@tonic-gate { 16517c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 16527c478bd9Sstevel@tonic-gate uintptr_t addr; 16537c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 16547c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data; 16557c478bd9Sstevel@tonic-gate size_t hsize; 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 16587c478bd9Sstevel@tonic-gate mdb_warn("dtrace_aggkey walk needs aggregation buffer\n"); 16597c478bd9Sstevel@tonic-gate return (WALK_ERR); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate 16627c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 16637c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 16647c478bd9Sstevel@tonic-gate return (WALK_ERR); 16657c478bd9Sstevel@tonic-gate } 16667c478bd9Sstevel@tonic-gate 16677c478bd9Sstevel@tonic-gate addr = (uintptr_t)buf.dtb_tomax + 16687c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), addr) == -1) { 16717c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", addr); 16727c478bd9Sstevel@tonic-gate return (WALK_ERR); 16737c478bd9Sstevel@tonic-gate } 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_aggkey_data_t), UM_SLEEP); 16767c478bd9Sstevel@tonic-gate 16777c478bd9Sstevel@tonic-gate data->dtakd_hashsize = agb.dtagb_hashsize; 16787c478bd9Sstevel@tonic-gate hsize = agb.dtagb_hashsize * sizeof (dtrace_aggkey_t *); 16797c478bd9Sstevel@tonic-gate data->dtakd_hash = mdb_alloc(hsize, UM_SLEEP); 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtakd_hash, hsize, 16827c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash) == -1) { 16837c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 16847c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash); 16857c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 16867c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 16877c478bd9Sstevel@tonic-gate return (WALK_ERR); 16887c478bd9Sstevel@tonic-gate } 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate wsp->walk_data = data; 16917c478bd9Sstevel@tonic-gate return (WALK_NEXT); 16927c478bd9Sstevel@tonic-gate } 16937c478bd9Sstevel@tonic-gate 16947c478bd9Sstevel@tonic-gate int 16957c478bd9Sstevel@tonic-gate dtrace_aggkey_step(mdb_walk_state_t *wsp) 16967c478bd9Sstevel@tonic-gate { 16977c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 16987c478bd9Sstevel@tonic-gate dtrace_aggkey_t key; 16997c478bd9Sstevel@tonic-gate uintptr_t addr; 17007c478bd9Sstevel@tonic-gate 17017c478bd9Sstevel@tonic-gate while ((addr = data->dtakd_next) == NULL) { 17027c478bd9Sstevel@tonic-gate if (data->dtakd_ndx == data->dtakd_hashsize) 17037c478bd9Sstevel@tonic-gate return (WALK_DONE); 17047c478bd9Sstevel@tonic-gate 17057c478bd9Sstevel@tonic-gate data->dtakd_next = data->dtakd_hash[data->dtakd_ndx++]; 17067c478bd9Sstevel@tonic-gate } 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate if (mdb_vread(&key, sizeof (key), addr) == -1) { 17097c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggkey_t at %p", addr); 17107c478bd9Sstevel@tonic-gate return (WALK_ERR); 17117c478bd9Sstevel@tonic-gate } 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate data->dtakd_next = (uintptr_t)key.dtak_next; 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &key, wsp->walk_cbdata)); 17167c478bd9Sstevel@tonic-gate } 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate void 17197c478bd9Sstevel@tonic-gate dtrace_aggkey_fini(mdb_walk_state_t *wsp) 17207c478bd9Sstevel@tonic-gate { 17217c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 17227c478bd9Sstevel@tonic-gate size_t hsize; 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate hsize = data->dtakd_hashsize * sizeof (dtrace_aggkey_t *); 17257c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 17267c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 17277c478bd9Sstevel@tonic-gate } 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate typedef struct dtrace_dynvar_data { 17307c478bd9Sstevel@tonic-gate dtrace_dynhash_t *dtdvd_hash; 17317c478bd9Sstevel@tonic-gate uintptr_t dtdvd_hashsize; 17327c478bd9Sstevel@tonic-gate uintptr_t dtdvd_next; 17337c478bd9Sstevel@tonic-gate uintptr_t dtdvd_ndx; 17347c478bd9Sstevel@tonic-gate } dtrace_dynvar_data_t; 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate int 17377c478bd9Sstevel@tonic-gate dtrace_dynvar_init(mdb_walk_state_t *wsp) 17387c478bd9Sstevel@tonic-gate { 17397c478bd9Sstevel@tonic-gate uintptr_t addr; 17407c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 17417c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data; 17427c478bd9Sstevel@tonic-gate size_t hsize; 17437c478bd9Sstevel@tonic-gate 17447c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 17457c478bd9Sstevel@tonic-gate mdb_warn("dtrace_dynvar walk needs dtrace_dstate_t\n"); 17467c478bd9Sstevel@tonic-gate return (WALK_ERR); 17477c478bd9Sstevel@tonic-gate } 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 17507c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic state at %p", addr); 17517c478bd9Sstevel@tonic-gate return (WALK_ERR); 17527c478bd9Sstevel@tonic-gate } 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_dynvar_data_t), UM_SLEEP); 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate data->dtdvd_hashsize = dstate.dtds_hashsize; 17577c478bd9Sstevel@tonic-gate hsize = dstate.dtds_hashsize * sizeof (dtrace_dynhash_t); 17587c478bd9Sstevel@tonic-gate data->dtdvd_hash = mdb_alloc(hsize, UM_SLEEP); 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtdvd_hash, hsize, 17617c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash) == -1) { 17627c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 17637c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash); 17647c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 17657c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 17667c478bd9Sstevel@tonic-gate return (WALK_ERR); 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate 17697c478bd9Sstevel@tonic-gate wsp->walk_data = data; 17707c478bd9Sstevel@tonic-gate return (WALK_NEXT); 17717c478bd9Sstevel@tonic-gate } 17727c478bd9Sstevel@tonic-gate 17737c478bd9Sstevel@tonic-gate int 17747c478bd9Sstevel@tonic-gate dtrace_dynvar_step(mdb_walk_state_t *wsp) 17757c478bd9Sstevel@tonic-gate { 17767c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 17777c478bd9Sstevel@tonic-gate dtrace_dynvar_t dynvar, *dvar; 17787c478bd9Sstevel@tonic-gate size_t dvarsize; 17797c478bd9Sstevel@tonic-gate uintptr_t addr; 17807c478bd9Sstevel@tonic-gate int nkeys; 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate while ((addr = data->dtdvd_next) == NULL) { 17837c478bd9Sstevel@tonic-gate if (data->dtdvd_ndx == data->dtdvd_hashsize) 17847c478bd9Sstevel@tonic-gate return (WALK_DONE); 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate data->dtdvd_next = 17877c478bd9Sstevel@tonic-gate (uintptr_t)data->dtdvd_hash[data->dtdvd_ndx++].dtdh_chain; 17887c478bd9Sstevel@tonic-gate } 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate if (mdb_vread(&dynvar, sizeof (dynvar), addr) == -1) { 17917c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 17927c478bd9Sstevel@tonic-gate return (WALK_ERR); 17937c478bd9Sstevel@tonic-gate } 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate /* 17967c478bd9Sstevel@tonic-gate * Now we need to allocate the correct size. 17977c478bd9Sstevel@tonic-gate */ 17987c478bd9Sstevel@tonic-gate nkeys = dynvar.dtdv_tuple.dtt_nkeys; 17997c478bd9Sstevel@tonic-gate dvarsize = (uintptr_t)&dynvar.dtdv_tuple.dtt_key[nkeys] - 18007c478bd9Sstevel@tonic-gate (uintptr_t)&dynvar; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate dvar = alloca(dvarsize); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate if (mdb_vread(dvar, dvarsize, addr) == -1) { 18057c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 18067c478bd9Sstevel@tonic-gate return (WALK_ERR); 18077c478bd9Sstevel@tonic-gate } 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate data->dtdvd_next = (uintptr_t)dynvar.dtdv_next; 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, dvar, wsp->walk_cbdata)); 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate 18147c478bd9Sstevel@tonic-gate void 18157c478bd9Sstevel@tonic-gate dtrace_dynvar_fini(mdb_walk_state_t *wsp) 18167c478bd9Sstevel@tonic-gate { 18177c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 18187c478bd9Sstevel@tonic-gate size_t hsize; 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate hsize = data->dtdvd_hashsize * sizeof (dtrace_dynvar_t *); 18217c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 18227c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 18237c478bd9Sstevel@tonic-gate } 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate typedef struct dtrace_hashstat_data { 18267c478bd9Sstevel@tonic-gate size_t *dthsd_counts; 18277c478bd9Sstevel@tonic-gate size_t dthsd_hashsize; 18287c478bd9Sstevel@tonic-gate char *dthsd_data; 18297c478bd9Sstevel@tonic-gate size_t dthsd_size; 18307c478bd9Sstevel@tonic-gate int dthsd_header; 18317c478bd9Sstevel@tonic-gate } dtrace_hashstat_data_t; 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate typedef void (*dtrace_hashstat_func_t)(dtrace_hashstat_data_t *); 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate static void 18367c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(dtrace_hashstat_data_t *data) 18377c478bd9Sstevel@tonic-gate { 18387c478bd9Sstevel@tonic-gate int i; 18397c478bd9Sstevel@tonic-gate int hval = 0; 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 18427c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 18457c478bd9Sstevel@tonic-gate } 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate static void 18487c478bd9Sstevel@tonic-gate dtrace_hashstat_shifty(dtrace_hashstat_data_t *data) 18497c478bd9Sstevel@tonic-gate { 18507c478bd9Sstevel@tonic-gate uint64_t hval = 0; 18517c478bd9Sstevel@tonic-gate int i; 18527c478bd9Sstevel@tonic-gate 18537c478bd9Sstevel@tonic-gate if (data->dthsd_size < sizeof (uint64_t)) { 18547c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(data); 18557c478bd9Sstevel@tonic-gate return; 18567c478bd9Sstevel@tonic-gate } 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i += sizeof (uint64_t)) { 18597c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 18607c478bd9Sstevel@tonic-gate uint64_t val = *((uint64_t *)&data->dthsd_data[i]); 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate hval += (val & ((1 << NBBY) - 1)) + 18637c478bd9Sstevel@tonic-gate ((val >> NBBY) & ((1 << NBBY) - 1)) + 18647c478bd9Sstevel@tonic-gate ((val >> (NBBY << 1)) & ((1 << NBBY) - 1)) + 18657c478bd9Sstevel@tonic-gate ((val >> (NBBY << 2)) & ((1 << NBBY) - 1)) + 18667c478bd9Sstevel@tonic-gate (val & USHRT_MAX) + (val >> (NBBY << 1) & USHRT_MAX); 18677c478bd9Sstevel@tonic-gate } 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 18707c478bd9Sstevel@tonic-gate } 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate static void 18737c478bd9Sstevel@tonic-gate dtrace_hashstat_knuth(dtrace_hashstat_data_t *data) 18747c478bd9Sstevel@tonic-gate { 18757c478bd9Sstevel@tonic-gate int i; 18767c478bd9Sstevel@tonic-gate int hval = data->dthsd_size; 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 18797c478bd9Sstevel@tonic-gate hval = (hval << 4) ^ (hval >> 28) ^ data->dthsd_data[i]; 18807c478bd9Sstevel@tonic-gate 18817c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate static void 18857c478bd9Sstevel@tonic-gate dtrace_hashstat_oneatatime(dtrace_hashstat_data_t *data) 18867c478bd9Sstevel@tonic-gate { 18877c478bd9Sstevel@tonic-gate int i; 18887c478bd9Sstevel@tonic-gate uint32_t hval = 0; 18897c478bd9Sstevel@tonic-gate 18907c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 18917c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 18927c478bd9Sstevel@tonic-gate hval += (hval << 10); 18937c478bd9Sstevel@tonic-gate hval ^= (hval >> 6); 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate hval += (hval << 3); 18977c478bd9Sstevel@tonic-gate hval ^= (hval >> 11); 18987c478bd9Sstevel@tonic-gate hval += (hval << 15); 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 19017c478bd9Sstevel@tonic-gate } 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate static void 19047c478bd9Sstevel@tonic-gate dtrace_hashstat_fnv(dtrace_hashstat_data_t *data) 19057c478bd9Sstevel@tonic-gate { 19067c478bd9Sstevel@tonic-gate static const uint32_t prime = 0x01000193; 19077c478bd9Sstevel@tonic-gate uint32_t hval = 0; 19087c478bd9Sstevel@tonic-gate int i; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 19117c478bd9Sstevel@tonic-gate hval *= prime; 19127c478bd9Sstevel@tonic-gate hval ^= data->dthsd_data[i]; 19137c478bd9Sstevel@tonic-gate } 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 19167c478bd9Sstevel@tonic-gate } 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate static void 19197c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(char *name, dtrace_hashstat_data_t *data) 19207c478bd9Sstevel@tonic-gate { 19217c478bd9Sstevel@tonic-gate size_t nz = 0, i; 19227c478bd9Sstevel@tonic-gate int longest = 0; 19237c478bd9Sstevel@tonic-gate size_t ttl = 0; 19247c478bd9Sstevel@tonic-gate double sum = 0.0; 19257c478bd9Sstevel@tonic-gate double avg; 19267c478bd9Sstevel@tonic-gate uint_t util, stddev; 19277c478bd9Sstevel@tonic-gate 19287c478bd9Sstevel@tonic-gate if (!data->dthsd_header) { 19297c478bd9Sstevel@tonic-gate mdb_printf("%15s %11s %11s %11s %11s %11s\n", "NAME", 19307c478bd9Sstevel@tonic-gate "HASHSIZE", "%UTIL", "LONGEST", "AVERAGE", "STDDEV"); 19317c478bd9Sstevel@tonic-gate data->dthsd_header = 1; 19327c478bd9Sstevel@tonic-gate } 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 19357c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] != 0) { 19367c478bd9Sstevel@tonic-gate nz++; 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] > longest) 19397c478bd9Sstevel@tonic-gate longest = data->dthsd_counts[i]; 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate ttl += data->dthsd_counts[i]; 19427c478bd9Sstevel@tonic-gate } 19437c478bd9Sstevel@tonic-gate } 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate if (nz == 0) { 19467c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %11s %11s %11s %11s\n", name, 19477c478bd9Sstevel@tonic-gate data->dthsd_hashsize, "-", "-", "-", "-"); 19487c478bd9Sstevel@tonic-gate return; 19497c478bd9Sstevel@tonic-gate } 19507c478bd9Sstevel@tonic-gate 19517c478bd9Sstevel@tonic-gate avg = (double)ttl / (double)nz; 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 19547c478bd9Sstevel@tonic-gate double delta = (double)data->dthsd_counts[i] - avg; 19557c478bd9Sstevel@tonic-gate 19567c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] == 0) 19577c478bd9Sstevel@tonic-gate continue; 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate sum += delta * delta; 19607c478bd9Sstevel@tonic-gate } 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate util = (nz * 1000) / data->dthsd_hashsize; 19637c478bd9Sstevel@tonic-gate stddev = (uint_t)sqrt(sum / (double)nz) * 10; 19647c478bd9Sstevel@tonic-gate 19657c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %9u.%1u %11d %11d %9u.%1u\n", name, 19667c478bd9Sstevel@tonic-gate data->dthsd_hashsize, util / 10, util % 10, longest, ttl / nz, 19677c478bd9Sstevel@tonic-gate stddev / 10, stddev % 10); 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate static struct dtrace_hashstat { 19717c478bd9Sstevel@tonic-gate char *dths_name; 19727c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dths_func; 19737c478bd9Sstevel@tonic-gate } _dtrace_hashstat[] = { 19747c478bd9Sstevel@tonic-gate { "<actual>", NULL }, 19757c478bd9Sstevel@tonic-gate { "additive", dtrace_hashstat_additive }, 19767c478bd9Sstevel@tonic-gate { "shifty", dtrace_hashstat_shifty }, 19777c478bd9Sstevel@tonic-gate { "knuth", dtrace_hashstat_knuth }, 19787c478bd9Sstevel@tonic-gate { "one-at-a-time", dtrace_hashstat_oneatatime }, 19797c478bd9Sstevel@tonic-gate { "fnv", dtrace_hashstat_fnv }, 19807c478bd9Sstevel@tonic-gate { NULL, 0 } 19817c478bd9Sstevel@tonic-gate }; 19827c478bd9Sstevel@tonic-gate 19837c478bd9Sstevel@tonic-gate typedef struct dtrace_aggstat_data { 19847c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t dtagsd_hash; 19857c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dtagsd_func; 19867c478bd9Sstevel@tonic-gate } dtrace_aggstat_data_t; 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate static int 19897c478bd9Sstevel@tonic-gate dtrace_aggstat_walk(uintptr_t addr, dtrace_aggkey_t *key, 19907c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 19917c478bd9Sstevel@tonic-gate { 19927c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 19937c478bd9Sstevel@tonic-gate size_t size; 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 19967c478bd9Sstevel@tonic-gate size_t bucket = key->dtak_hashval % hdata->dthsd_hashsize; 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 19997c478bd9Sstevel@tonic-gate return (WALK_NEXT); 20007c478bd9Sstevel@tonic-gate } 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate /* 20037c478bd9Sstevel@tonic-gate * We need to read the data. 20047c478bd9Sstevel@tonic-gate */ 20057c478bd9Sstevel@tonic-gate size = key->dtak_size - sizeof (dtrace_aggid_t); 20067c478bd9Sstevel@tonic-gate addr = (uintptr_t)key->dtak_data + sizeof (dtrace_aggid_t); 20077c478bd9Sstevel@tonic-gate hdata->dthsd_data = alloca(size); 20087c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate if (mdb_vread(hdata->dthsd_data, size, addr) == -1) { 20117c478bd9Sstevel@tonic-gate mdb_warn("couldn't read data at %p", addr); 20127c478bd9Sstevel@tonic-gate return (WALK_ERR); 20137c478bd9Sstevel@tonic-gate } 20147c478bd9Sstevel@tonic-gate 20157c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate return (WALK_NEXT); 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 20217c478bd9Sstevel@tonic-gate int 20227c478bd9Sstevel@tonic-gate dtrace_aggstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 20237c478bd9Sstevel@tonic-gate { 20247c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 20257c478bd9Sstevel@tonic-gate uintptr_t aaddr; 20267c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 20277c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime, evenpow; 20287c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 20297c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 20307c478bd9Sstevel@tonic-gate 20317c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 20347c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 20377c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 20387c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20397c478bd9Sstevel@tonic-gate } 20407c478bd9Sstevel@tonic-gate 20417c478bd9Sstevel@tonic-gate aaddr = (uintptr_t)buf.dtb_tomax + 20427c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 20437c478bd9Sstevel@tonic-gate 20447c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), aaddr) == -1) { 20457c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", aaddr); 20467c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20477c478bd9Sstevel@tonic-gate } 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate hsize = (actual = agb.dtagb_hashsize) * sizeof (size_t); 20507c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 20517c478bd9Sstevel@tonic-gate 20527c478bd9Sstevel@tonic-gate /* 20537c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 20547c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 20557c478bd9Sstevel@tonic-gate * hell of it.) 20567c478bd9Sstevel@tonic-gate */ 20577c478bd9Sstevel@tonic-gate for (prime = agb.dtagb_hashsize - 1; prime > 7; prime--) { 20587c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 20597c478bd9Sstevel@tonic-gate 20607c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 20617c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 20627c478bd9Sstevel@tonic-gate break; 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate if (i == limit) 20667c478bd9Sstevel@tonic-gate break; 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate /* 20707c478bd9Sstevel@tonic-gate * And now we want to pick the largest power of two smaller than the 20717c478bd9Sstevel@tonic-gate * hashsize. 20727c478bd9Sstevel@tonic-gate */ 20737c478bd9Sstevel@tonic-gate for (i = 0; (1 << i) < agb.dtagb_hashsize; i++) 20747c478bd9Sstevel@tonic-gate continue; 20757c478bd9Sstevel@tonic-gate 20767c478bd9Sstevel@tonic-gate evenpow = (1 << (i - 1)); 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 20797c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 20827c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 20837c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 20867c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 20877c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 20887c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20897c478bd9Sstevel@tonic-gate } 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate /* 20947c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 20957c478bd9Sstevel@tonic-gate * any of the sizing experiments. 20967c478bd9Sstevel@tonic-gate */ 20977c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 20987c478bd9Sstevel@tonic-gate continue; 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 21017c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 21027c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 21057c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 21067c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 21077c478bd9Sstevel@tonic-gate return (DCMD_ERR); 21087c478bd9Sstevel@tonic-gate } 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = evenpow; 21137c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 21147c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 21177c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 21187c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 21197c478bd9Sstevel@tonic-gate return (DCMD_ERR); 21207c478bd9Sstevel@tonic-gate } 21217c478bd9Sstevel@tonic-gate 21227c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 21237c478bd9Sstevel@tonic-gate } 21247c478bd9Sstevel@tonic-gate 21257c478bd9Sstevel@tonic-gate return (DCMD_OK); 21267c478bd9Sstevel@tonic-gate } 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21297c478bd9Sstevel@tonic-gate static int 21307c478bd9Sstevel@tonic-gate dtrace_dynstat_walk(uintptr_t addr, dtrace_dynvar_t *dynvar, 21317c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 21327c478bd9Sstevel@tonic-gate { 21337c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 21347c478bd9Sstevel@tonic-gate dtrace_tuple_t *tuple = &dynvar->dtdv_tuple; 21357c478bd9Sstevel@tonic-gate dtrace_key_t *key = tuple->dtt_key; 21367c478bd9Sstevel@tonic-gate size_t size = 0, offs = 0; 21377c478bd9Sstevel@tonic-gate int i, nkeys = tuple->dtt_nkeys; 21387c478bd9Sstevel@tonic-gate char *buf; 21397c478bd9Sstevel@tonic-gate 21407c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 21417c478bd9Sstevel@tonic-gate size_t bucket = dynvar->dtdv_hashval % hdata->dthsd_hashsize; 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 21447c478bd9Sstevel@tonic-gate return (WALK_NEXT); 21457c478bd9Sstevel@tonic-gate } 21467c478bd9Sstevel@tonic-gate 21477c478bd9Sstevel@tonic-gate /* 21487c478bd9Sstevel@tonic-gate * We want to hand the hashing algorithm a contiguous buffer. First 21497c478bd9Sstevel@tonic-gate * run through the tuple and determine the size. 21507c478bd9Sstevel@tonic-gate */ 21517c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 21527c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 21537c478bd9Sstevel@tonic-gate size += sizeof (uint64_t); 21547c478bd9Sstevel@tonic-gate } else { 21557c478bd9Sstevel@tonic-gate size += key[i].dttk_size; 21567c478bd9Sstevel@tonic-gate } 21577c478bd9Sstevel@tonic-gate } 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate buf = alloca(size); 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate /* 21627c478bd9Sstevel@tonic-gate * Now go back through the tuple and copy the data into the buffer. 21637c478bd9Sstevel@tonic-gate */ 21647c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 21657c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 21667c478bd9Sstevel@tonic-gate bcopy(&key[i].dttk_value, &buf[offs], 21677c478bd9Sstevel@tonic-gate sizeof (uint64_t)); 21687c478bd9Sstevel@tonic-gate offs += sizeof (uint64_t); 21697c478bd9Sstevel@tonic-gate } else { 21707c478bd9Sstevel@tonic-gate if (mdb_vread(&buf[offs], key[i].dttk_size, 21717c478bd9Sstevel@tonic-gate key[i].dttk_value) == -1) { 21727c478bd9Sstevel@tonic-gate mdb_warn("couldn't read tuple data at %p", 21737c478bd9Sstevel@tonic-gate key[i].dttk_value); 21747c478bd9Sstevel@tonic-gate return (WALK_ERR); 21757c478bd9Sstevel@tonic-gate } 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate offs += key[i].dttk_size; 21787c478bd9Sstevel@tonic-gate } 21797c478bd9Sstevel@tonic-gate } 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate hdata->dthsd_data = buf; 21827c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 21857c478bd9Sstevel@tonic-gate 21867c478bd9Sstevel@tonic-gate return (WALK_NEXT); 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21907c478bd9Sstevel@tonic-gate int 21917c478bd9Sstevel@tonic-gate dtrace_dynstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 21927c478bd9Sstevel@tonic-gate { 21937c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 21947c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime; 21957c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 21967c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 21997c478bd9Sstevel@tonic-gate 22007c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 22017c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 22047c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic variable state at %p", addr); 22057c478bd9Sstevel@tonic-gate return (DCMD_ERR); 22067c478bd9Sstevel@tonic-gate } 22077c478bd9Sstevel@tonic-gate 22087c478bd9Sstevel@tonic-gate hsize = (actual = dstate.dtds_hashsize) * sizeof (size_t); 22097c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 22107c478bd9Sstevel@tonic-gate 22117c478bd9Sstevel@tonic-gate /* 22127c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 22137c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 22147c478bd9Sstevel@tonic-gate * hell of it.) 22157c478bd9Sstevel@tonic-gate */ 22167c478bd9Sstevel@tonic-gate for (prime = dstate.dtds_hashsize - 1; prime > 7; prime--) { 22177c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 22207c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 22217c478bd9Sstevel@tonic-gate break; 22227c478bd9Sstevel@tonic-gate } 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate if (i == limit) 22257c478bd9Sstevel@tonic-gate break; 22267c478bd9Sstevel@tonic-gate } 22277c478bd9Sstevel@tonic-gate 22287c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 22297c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 22307c478bd9Sstevel@tonic-gate 22317c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 22327c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 22337c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 22347c478bd9Sstevel@tonic-gate 22357c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 22367c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 22377c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_dynvar at %p", addr); 22387c478bd9Sstevel@tonic-gate return (DCMD_ERR); 22397c478bd9Sstevel@tonic-gate } 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 22427c478bd9Sstevel@tonic-gate 22437c478bd9Sstevel@tonic-gate /* 22447c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 22457c478bd9Sstevel@tonic-gate * any of the sizing experiments. 22467c478bd9Sstevel@tonic-gate */ 22477c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 22487c478bd9Sstevel@tonic-gate continue; 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 22517c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 22527c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 22537c478bd9Sstevel@tonic-gate 22547c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 22557c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 22567c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 22577c478bd9Sstevel@tonic-gate return (DCMD_ERR); 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 22617c478bd9Sstevel@tonic-gate } 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate return (DCMD_OK); 22647c478bd9Sstevel@tonic-gate } 22657c478bd9Sstevel@tonic-gate 22661a7c1b72Smws const mdb_dcmd_t kernel_dcmds[] = { 22677c478bd9Sstevel@tonic-gate { "id2probe", ":", "translate a dtrace_id_t to a dtrace_probe_t", 22687c478bd9Sstevel@tonic-gate id2probe }, 22697c478bd9Sstevel@tonic-gate { "dtrace", ":[-c cpu]", "print dtrace(1M)-like output", 22707c478bd9Sstevel@tonic-gate dtrace, dtrace_help }, 22717c478bd9Sstevel@tonic-gate { "dtrace_errhash", ":", "print DTrace error hash", dtrace_errhash }, 22727c478bd9Sstevel@tonic-gate { "dtrace_helptrace", ":", "print DTrace helper trace", 22737c478bd9Sstevel@tonic-gate dtrace_helptrace }, 22747c478bd9Sstevel@tonic-gate { "dtrace_state", ":", "print active DTrace consumers", dtrace_state, 22757c478bd9Sstevel@tonic-gate dtrace_state_help }, 22767c478bd9Sstevel@tonic-gate { "dtrace_aggstat", ":", 22777c478bd9Sstevel@tonic-gate "print DTrace aggregation hash statistics", dtrace_aggstat }, 22787c478bd9Sstevel@tonic-gate { "dtrace_dynstat", ":", 22797c478bd9Sstevel@tonic-gate "print DTrace dynamic variable hash statistics", dtrace_dynstat }, 22807c478bd9Sstevel@tonic-gate { NULL } 22817c478bd9Sstevel@tonic-gate }; 22827c478bd9Sstevel@tonic-gate 22831a7c1b72Smws const mdb_walker_t kernel_walkers[] = { 22847c478bd9Sstevel@tonic-gate { "dtrace_errhash", "walk hash of DTrace error messasges", 22857c478bd9Sstevel@tonic-gate dtrace_errhash_init, dtrace_errhash_step }, 22867c478bd9Sstevel@tonic-gate { "dtrace_helptrace", "walk DTrace helper trace entries", 22877c478bd9Sstevel@tonic-gate dtrace_helptrace_init, dtrace_helptrace_step }, 22887c478bd9Sstevel@tonic-gate { "dtrace_state", "walk DTrace per-consumer softstate", 22897c478bd9Sstevel@tonic-gate dtrace_state_init, dtrace_state_step }, 22907c478bd9Sstevel@tonic-gate { "dtrace_aggkey", "walk DTrace aggregation keys", 22917c478bd9Sstevel@tonic-gate dtrace_aggkey_init, dtrace_aggkey_step, dtrace_aggkey_fini }, 22927c478bd9Sstevel@tonic-gate { "dtrace_dynvar", "walk DTrace dynamic variables", 22937c478bd9Sstevel@tonic-gate dtrace_dynvar_init, dtrace_dynvar_step, dtrace_dynvar_fini }, 22947c478bd9Sstevel@tonic-gate { NULL } 22957c478bd9Sstevel@tonic-gate }; 2296