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