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.
25c3377ee9SJohn Levon * Copyright 2019 Joyent, Inc.
26*9f7719e7SJason King * Copyright 2022 Racktop Systems, Inc.
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * explicitly define DTRACE_ERRDEBUG to pull in definition of dtrace_errhash_t
317c478bd9Sstevel@tonic-gate * explicitly define _STDARG_H to avoid stdarg.h/varargs.h u/k defn conflict
327c478bd9Sstevel@tonic-gate */
337c478bd9Sstevel@tonic-gate #define DTRACE_ERRDEBUG
347c478bd9Sstevel@tonic-gate #define _STDARG_H
357c478bd9Sstevel@tonic-gate
367c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h>
377c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h>
387c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h>
397c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h>
407c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h>
417c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h>
427c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
437c478bd9Sstevel@tonic-gate #include <sys/kobj.h>
447c478bd9Sstevel@tonic-gate #include <dtrace.h>
457c478bd9Sstevel@tonic-gate #include <alloca.h>
467c478bd9Sstevel@tonic-gate #include <ctype.h>
477c478bd9Sstevel@tonic-gate #include <errno.h>
487c478bd9Sstevel@tonic-gate #include <math.h>
497994dfddSDan Kimmel #include <stdio.h>
507994dfddSDan Kimmel #include <unistd.h>
517c478bd9Sstevel@tonic-gate
527c478bd9Sstevel@tonic-gate /*ARGSUSED*/
537c478bd9Sstevel@tonic-gate int
id2probe(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)547c478bd9Sstevel@tonic-gate id2probe(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
557c478bd9Sstevel@tonic-gate {
56892ad162SToomas Soome uintptr_t probe = 0;
577c478bd9Sstevel@tonic-gate uintptr_t probes;
587c478bd9Sstevel@tonic-gate
597c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC))
607c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
617c478bd9Sstevel@tonic-gate
627c478bd9Sstevel@tonic-gate if (addr == DTRACE_IDNONE || addr > UINT32_MAX)
637c478bd9Sstevel@tonic-gate goto out;
647c478bd9Sstevel@tonic-gate
657c478bd9Sstevel@tonic-gate if (mdb_readvar(&probes, "dtrace_probes") == -1) {
667c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'");
677c478bd9Sstevel@tonic-gate return (DCMD_ERR);
687c478bd9Sstevel@tonic-gate }
697c478bd9Sstevel@tonic-gate
707c478bd9Sstevel@tonic-gate probes += (addr - 1) * sizeof (dtrace_probe_t *);
717c478bd9Sstevel@tonic-gate
727c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (uintptr_t), probes) == -1) {
737c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_probes[%d]", addr - 1);
747c478bd9Sstevel@tonic-gate return (DCMD_ERR);
757c478bd9Sstevel@tonic-gate }
767c478bd9Sstevel@tonic-gate
777c478bd9Sstevel@tonic-gate out:
787c478bd9Sstevel@tonic-gate mdb_printf("%p\n", probe);
797c478bd9Sstevel@tonic-gate return (DCMD_OK);
807c478bd9Sstevel@tonic-gate }
817c478bd9Sstevel@tonic-gate
827c478bd9Sstevel@tonic-gate void
dtrace_help(void)837c478bd9Sstevel@tonic-gate dtrace_help(void)
847c478bd9Sstevel@tonic-gate {
857c478bd9Sstevel@tonic-gate
867c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure that represents a "
877c478bd9Sstevel@tonic-gate "DTrace consumer, prints\n"
88bbf21555SRichard Lowe "dtrace(8)-like output for in-kernel DTrace data. (The "
897c478bd9Sstevel@tonic-gate "dtrace_state_t\n"
907c478bd9Sstevel@tonic-gate "structures for all DTrace consumers may be obtained by running "
917c478bd9Sstevel@tonic-gate "the \n"
927c478bd9Sstevel@tonic-gate "::dtrace_state dcmd.) When data is present on multiple CPUs, "
937c478bd9Sstevel@tonic-gate "data are\n"
947c478bd9Sstevel@tonic-gate "presented in CPU order, with records within each CPU ordered "
957c478bd9Sstevel@tonic-gate "oldest to \n"
967c478bd9Sstevel@tonic-gate "youngest. Options:\n\n"
977c478bd9Sstevel@tonic-gate "-c cpu Only provide output for specified CPU.\n");
987c478bd9Sstevel@tonic-gate }
997c478bd9Sstevel@tonic-gate
1007c478bd9Sstevel@tonic-gate static int
dtracemdb_eprobe(dtrace_state_t * state,dtrace_eprobedesc_t * epd)1017c478bd9Sstevel@tonic-gate dtracemdb_eprobe(dtrace_state_t *state, dtrace_eprobedesc_t *epd)
1027c478bd9Sstevel@tonic-gate {
1037c478bd9Sstevel@tonic-gate dtrace_epid_t epid = epd->dtepd_epid;
1047c478bd9Sstevel@tonic-gate dtrace_probe_t probe;
1057c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb;
1067c478bd9Sstevel@tonic-gate uintptr_t addr, paddr, ap;
1077c478bd9Sstevel@tonic-gate dtrace_action_t act;
1087c478bd9Sstevel@tonic-gate int nactions, nrecs;
1097c478bd9Sstevel@tonic-gate
1107c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_ecbs +
1117c478bd9Sstevel@tonic-gate (epid - 1) * sizeof (dtrace_ecb_t *);
1127c478bd9Sstevel@tonic-gate
1137c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) {
1147c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for epid %d", epid);
1157c478bd9Sstevel@tonic-gate return (-1);
1167c478bd9Sstevel@tonic-gate }
1177c478bd9Sstevel@tonic-gate
118892ad162SToomas Soome if (addr == 0) {
1197c478bd9Sstevel@tonic-gate mdb_warn("epid %d doesn't match an ecb\n", epid);
1207c478bd9Sstevel@tonic-gate return (-1);
1217c478bd9Sstevel@tonic-gate }
1227c478bd9Sstevel@tonic-gate
1237c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), addr) == -1) {
1247c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb at %p", addr);
1257c478bd9Sstevel@tonic-gate return (-1);
1267c478bd9Sstevel@tonic-gate }
1277c478bd9Sstevel@tonic-gate
1287c478bd9Sstevel@tonic-gate paddr = (uintptr_t)ecb.dte_probe;
1297c478bd9Sstevel@tonic-gate
1307c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) {
1317c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe for ecb %p", addr);
1327c478bd9Sstevel@tonic-gate return (-1);
1337c478bd9Sstevel@tonic-gate }
1347c478bd9Sstevel@tonic-gate
1357c478bd9Sstevel@tonic-gate /*
1367c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions,
1377c478bd9Sstevel@tonic-gate * we need to first walk through them.
1387c478bd9Sstevel@tonic-gate */
139892ad162SToomas Soome for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != 0; ) {
1407c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) {
1417c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p",
1427c478bd9Sstevel@tonic-gate ap, addr);
1437c478bd9Sstevel@tonic-gate return (-1);
1447c478bd9Sstevel@tonic-gate }
1457c478bd9Sstevel@tonic-gate
1467c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple)
1477c478bd9Sstevel@tonic-gate nactions++;
1487c478bd9Sstevel@tonic-gate
1497c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next;
1507c478bd9Sstevel@tonic-gate }
1517c478bd9Sstevel@tonic-gate
1527c478bd9Sstevel@tonic-gate nrecs = epd->dtepd_nrecs;
1537c478bd9Sstevel@tonic-gate epd->dtepd_nrecs = nactions;
1547c478bd9Sstevel@tonic-gate epd->dtepd_probeid = probe.dtpr_id;
1557c478bd9Sstevel@tonic-gate epd->dtepd_uarg = ecb.dte_uarg;
1567c478bd9Sstevel@tonic-gate epd->dtepd_size = ecb.dte_size;
1577c478bd9Sstevel@tonic-gate
158892ad162SToomas Soome for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != 0; ) {
1597c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) {
1607c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p",
1617c478bd9Sstevel@tonic-gate ap, addr);
1627c478bd9Sstevel@tonic-gate return (-1);
1637c478bd9Sstevel@tonic-gate }
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) {
1667c478bd9Sstevel@tonic-gate if (nrecs-- == 0)
1677c478bd9Sstevel@tonic-gate break;
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate epd->dtepd_rec[nactions++] = act.dta_rec;
1707c478bd9Sstevel@tonic-gate }
1717c478bd9Sstevel@tonic-gate
1727c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next;
1737c478bd9Sstevel@tonic-gate }
1747c478bd9Sstevel@tonic-gate
1757c478bd9Sstevel@tonic-gate return (0);
1767c478bd9Sstevel@tonic-gate }
1777c478bd9Sstevel@tonic-gate
1787c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1797c478bd9Sstevel@tonic-gate static int
dtracemdb_probe(dtrace_state_t * state,dtrace_probedesc_t * pd)1807c478bd9Sstevel@tonic-gate dtracemdb_probe(dtrace_state_t *state, dtrace_probedesc_t *pd)
1817c478bd9Sstevel@tonic-gate {
1827c478bd9Sstevel@tonic-gate uintptr_t base, addr, paddr, praddr;
1837c478bd9Sstevel@tonic-gate int nprobes, i;
1847c478bd9Sstevel@tonic-gate dtrace_probe_t probe;
1857c478bd9Sstevel@tonic-gate dtrace_provider_t prov;
1867c478bd9Sstevel@tonic-gate
1877c478bd9Sstevel@tonic-gate if (pd->dtpd_id == DTRACE_IDNONE)
1887c478bd9Sstevel@tonic-gate pd->dtpd_id++;
1897c478bd9Sstevel@tonic-gate
1907c478bd9Sstevel@tonic-gate if (mdb_readvar(&base, "dtrace_probes") == -1) {
1917c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'");
1927c478bd9Sstevel@tonic-gate return (-1);
1937c478bd9Sstevel@tonic-gate }
1947c478bd9Sstevel@tonic-gate
1957c478bd9Sstevel@tonic-gate if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) {
1967c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_nprobes'");
1977c478bd9Sstevel@tonic-gate return (-1);
1987c478bd9Sstevel@tonic-gate }
1997c478bd9Sstevel@tonic-gate
2007c478bd9Sstevel@tonic-gate for (i = pd->dtpd_id; i <= nprobes; i++) {
2017c478bd9Sstevel@tonic-gate addr = base + (i - 1) * sizeof (dtrace_probe_t *);
2027c478bd9Sstevel@tonic-gate
2037c478bd9Sstevel@tonic-gate if (mdb_vread(&paddr, sizeof (paddr), addr) == -1) {
2047c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe pointer at %p", addr);
2057c478bd9Sstevel@tonic-gate return (-1);
2067c478bd9Sstevel@tonic-gate }
2077c478bd9Sstevel@tonic-gate
208892ad162SToomas Soome if (paddr != 0)
2097c478bd9Sstevel@tonic-gate break;
2107c478bd9Sstevel@tonic-gate }
2117c478bd9Sstevel@tonic-gate
212892ad162SToomas Soome if (paddr == 0) {
2137c478bd9Sstevel@tonic-gate errno = ESRCH;
2147c478bd9Sstevel@tonic-gate return (-1);
2157c478bd9Sstevel@tonic-gate }
2167c478bd9Sstevel@tonic-gate
2177c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) {
2187c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe at %p", paddr);
2197c478bd9Sstevel@tonic-gate return (-1);
2207c478bd9Sstevel@tonic-gate }
2217c478bd9Sstevel@tonic-gate
2227c478bd9Sstevel@tonic-gate pd->dtpd_id = probe.dtpr_id;
2237c478bd9Sstevel@tonic-gate
2247c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_name, DTRACE_NAMELEN,
2257c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_name) == -1) {
2267c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe name for probe %p", paddr);
2277c478bd9Sstevel@tonic-gate return (-1);
2287c478bd9Sstevel@tonic-gate }
2297c478bd9Sstevel@tonic-gate
2307c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_func, DTRACE_FUNCNAMELEN,
2317c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_func) == -1) {
2327c478bd9Sstevel@tonic-gate mdb_warn("failed to read function name for probe %p", paddr);
2337c478bd9Sstevel@tonic-gate return (-1);
2347c478bd9Sstevel@tonic-gate }
2357c478bd9Sstevel@tonic-gate
2367c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_mod, DTRACE_MODNAMELEN,
2377c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_mod) == -1) {
2387c478bd9Sstevel@tonic-gate mdb_warn("failed to read module name for probe %p", paddr);
2397c478bd9Sstevel@tonic-gate return (-1);
2407c478bd9Sstevel@tonic-gate }
2417c478bd9Sstevel@tonic-gate
2427c478bd9Sstevel@tonic-gate praddr = (uintptr_t)probe.dtpr_provider;
2437c478bd9Sstevel@tonic-gate
2447c478bd9Sstevel@tonic-gate if (mdb_vread(&prov, sizeof (prov), praddr) == -1) {
2457c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider for probe %p", paddr);
2467c478bd9Sstevel@tonic-gate return (-1);
2477c478bd9Sstevel@tonic-gate }
2487c478bd9Sstevel@tonic-gate
2497c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_provider, DTRACE_PROVNAMELEN,
2507c478bd9Sstevel@tonic-gate (uintptr_t)prov.dtpv_name) == -1) {
2517c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider name for probe %p", paddr);
2527c478bd9Sstevel@tonic-gate return (-1);
2537c478bd9Sstevel@tonic-gate }
2547c478bd9Sstevel@tonic-gate
2557c478bd9Sstevel@tonic-gate return (0);
2567c478bd9Sstevel@tonic-gate }
2577c478bd9Sstevel@tonic-gate
2587c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2597c478bd9Sstevel@tonic-gate static int
dtracemdb_aggdesc(dtrace_state_t * state,dtrace_aggdesc_t * agd)2607c478bd9Sstevel@tonic-gate dtracemdb_aggdesc(dtrace_state_t *state, dtrace_aggdesc_t *agd)
2617c478bd9Sstevel@tonic-gate {
2627c478bd9Sstevel@tonic-gate dtrace_aggid_t aggid = agd->dtagd_id;
2637c478bd9Sstevel@tonic-gate dtrace_aggregation_t agg;
2647c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb;
2657c478bd9Sstevel@tonic-gate uintptr_t addr, eaddr, ap, last;
2667c478bd9Sstevel@tonic-gate dtrace_action_t act;
2677c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec;
2687c478bd9Sstevel@tonic-gate int nactions, nrecs;
2697c478bd9Sstevel@tonic-gate
2707c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_aggregations +
2717c478bd9Sstevel@tonic-gate (aggid - 1) * sizeof (dtrace_aggregation_t *);
2727c478bd9Sstevel@tonic-gate
2737c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) {
2747c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation for aggid %d", aggid);
2757c478bd9Sstevel@tonic-gate return (-1);
2767c478bd9Sstevel@tonic-gate }
2777c478bd9Sstevel@tonic-gate
278892ad162SToomas Soome if (addr == 0) {
2797c478bd9Sstevel@tonic-gate mdb_warn("aggid %d doesn't match an aggregation\n", aggid);
2807c478bd9Sstevel@tonic-gate return (-1);
2817c478bd9Sstevel@tonic-gate }
2827c478bd9Sstevel@tonic-gate
2837c478bd9Sstevel@tonic-gate if (mdb_vread(&agg, sizeof (agg), addr) == -1) {
2847c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation at %p", addr);
2857c478bd9Sstevel@tonic-gate return (-1);
2867c478bd9Sstevel@tonic-gate }
2877c478bd9Sstevel@tonic-gate
2887c478bd9Sstevel@tonic-gate eaddr = (uintptr_t)agg.dtag_ecb;
2897c478bd9Sstevel@tonic-gate
2907c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), eaddr) == -1) {
2917c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for aggregation %p", addr);
2927c478bd9Sstevel@tonic-gate return (-1);
2937c478bd9Sstevel@tonic-gate }
2947c478bd9Sstevel@tonic-gate
2957c478bd9Sstevel@tonic-gate last = (uintptr_t)addr + offsetof(dtrace_aggregation_t, dtag_action);
2967c478bd9Sstevel@tonic-gate
2977c478bd9Sstevel@tonic-gate /*
2987c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions,
2997c478bd9Sstevel@tonic-gate * we need to first walk through them.
3007c478bd9Sstevel@tonic-gate */
3017c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first;
3027c478bd9Sstevel@tonic-gate nactions = 0;
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate for (;;) {
3057c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) {
3067c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p",
3077c478bd9Sstevel@tonic-gate ap, addr);
3087c478bd9Sstevel@tonic-gate return (-1);
3097c478bd9Sstevel@tonic-gate }
3107c478bd9Sstevel@tonic-gate
3117c478bd9Sstevel@tonic-gate nactions++;
3127c478bd9Sstevel@tonic-gate
3137c478bd9Sstevel@tonic-gate if (ap == last)
3147c478bd9Sstevel@tonic-gate break;
3157c478bd9Sstevel@tonic-gate
3167c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next;
3177c478bd9Sstevel@tonic-gate }
3187c478bd9Sstevel@tonic-gate
3197c478bd9Sstevel@tonic-gate lrec = &act.dta_rec;
3207c478bd9Sstevel@tonic-gate agd->dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - agg.dtag_base;
3217c478bd9Sstevel@tonic-gate
3227c478bd9Sstevel@tonic-gate nrecs = agd->dtagd_nrecs;
3237c478bd9Sstevel@tonic-gate agd->dtagd_nrecs = nactions;
3247c478bd9Sstevel@tonic-gate agd->dtagd_epid = ecb.dte_epid;
3257c478bd9Sstevel@tonic-gate
3267c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first;
3277c478bd9Sstevel@tonic-gate nactions = 0;
3287c478bd9Sstevel@tonic-gate
3297c478bd9Sstevel@tonic-gate for (;;) {
3307c478bd9Sstevel@tonic-gate dtrace_recdesc_t rec;
3317c478bd9Sstevel@tonic-gate
3327c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) {
3337c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p",
3347c478bd9Sstevel@tonic-gate ap, addr);
3357c478bd9Sstevel@tonic-gate return (-1);
3367c478bd9Sstevel@tonic-gate }
3377c478bd9Sstevel@tonic-gate
3387c478bd9Sstevel@tonic-gate if (nrecs-- == 0)
3397c478bd9Sstevel@tonic-gate break;
3407c478bd9Sstevel@tonic-gate
3417c478bd9Sstevel@tonic-gate rec = act.dta_rec;
3427c478bd9Sstevel@tonic-gate rec.dtrd_offset -= agg.dtag_base;
3437c478bd9Sstevel@tonic-gate rec.dtrd_uarg = 0;
3447c478bd9Sstevel@tonic-gate agd->dtagd_rec[nactions++] = rec;
3457c478bd9Sstevel@tonic-gate
3467c478bd9Sstevel@tonic-gate if (ap == last)
3477c478bd9Sstevel@tonic-gate break;
3487c478bd9Sstevel@tonic-gate
3497c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next;
3507c478bd9Sstevel@tonic-gate }
3517c478bd9Sstevel@tonic-gate
3527c478bd9Sstevel@tonic-gate return (0);
3537c478bd9Sstevel@tonic-gate }
3547c478bd9Sstevel@tonic-gate
3557c478bd9Sstevel@tonic-gate static int
dtracemdb_bufsnap(dtrace_buffer_t * which,dtrace_bufdesc_t * desc)3567c478bd9Sstevel@tonic-gate dtracemdb_bufsnap(dtrace_buffer_t *which, dtrace_bufdesc_t *desc)
3577c478bd9Sstevel@tonic-gate {
358*9f7719e7SJason King static hrtime_t hr_offset = 0;
359*9f7719e7SJason King static boolean_t offset_set = B_FALSE;
3607c478bd9Sstevel@tonic-gate uintptr_t addr;
3617c478bd9Sstevel@tonic-gate size_t bufsize;
3627c478bd9Sstevel@tonic-gate dtrace_buffer_t buf;
3637c478bd9Sstevel@tonic-gate caddr_t data = desc->dtbd_data;
3647c478bd9Sstevel@tonic-gate processorid_t max_cpuid, cpu = desc->dtbd_cpu;
3657c478bd9Sstevel@tonic-gate
3667c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) {
3677c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'");
3687c478bd9Sstevel@tonic-gate errno = EIO;
3697c478bd9Sstevel@tonic-gate return (-1);
3707c478bd9Sstevel@tonic-gate }
3717c478bd9Sstevel@tonic-gate
3727c478bd9Sstevel@tonic-gate if (cpu < 0 || cpu > max_cpuid) {
3737c478bd9Sstevel@tonic-gate errno = EINVAL;
3747c478bd9Sstevel@tonic-gate return (-1);
3757c478bd9Sstevel@tonic-gate }
3767c478bd9Sstevel@tonic-gate
3777c478bd9Sstevel@tonic-gate addr = (uintptr_t)which + cpu * sizeof (dtrace_buffer_t);
3787c478bd9Sstevel@tonic-gate
3797c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
3807c478bd9Sstevel@tonic-gate mdb_warn("failed to read buffer description at %p", addr);
3817c478bd9Sstevel@tonic-gate errno = EIO;
3827c478bd9Sstevel@tonic-gate return (-1);
3837c478bd9Sstevel@tonic-gate }
3847c478bd9Sstevel@tonic-gate
3857c478bd9Sstevel@tonic-gate if (buf.dtb_tomax == NULL) {
3867c478bd9Sstevel@tonic-gate errno = ENOENT;
3877c478bd9Sstevel@tonic-gate return (-1);
3887c478bd9Sstevel@tonic-gate }
3897c478bd9Sstevel@tonic-gate
3907c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) {
3917c478bd9Sstevel@tonic-gate bufsize = buf.dtb_size;
3927c478bd9Sstevel@tonic-gate } else {
3937c478bd9Sstevel@tonic-gate bufsize = buf.dtb_offset;
3947c478bd9Sstevel@tonic-gate }
3957c478bd9Sstevel@tonic-gate
3967c478bd9Sstevel@tonic-gate if (mdb_vread(data, bufsize, (uintptr_t)buf.dtb_tomax) == -1) {
3977c478bd9Sstevel@tonic-gate mdb_warn("couldn't read buffer for CPU %d", cpu);
3987c478bd9Sstevel@tonic-gate errno = EIO;
3997c478bd9Sstevel@tonic-gate return (-1);
4007c478bd9Sstevel@tonic-gate }
4017c478bd9Sstevel@tonic-gate
4027c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_size) {
4037c478bd9Sstevel@tonic-gate mdb_warn("buffer for CPU %d has corrupt offset\n", cpu);
4047c478bd9Sstevel@tonic-gate errno = EIO;
4057c478bd9Sstevel@tonic-gate return (-1);
4067c478bd9Sstevel@tonic-gate }
4077c478bd9Sstevel@tonic-gate
4087c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) {
4097c478bd9Sstevel@tonic-gate if (buf.dtb_xamot_offset > buf.dtb_size) {
4107c478bd9Sstevel@tonic-gate mdb_warn("ringbuffer for CPU %d has corrupt "
4117c478bd9Sstevel@tonic-gate "wrapped offset\n", cpu);
4127c478bd9Sstevel@tonic-gate errno = EIO;
4137c478bd9Sstevel@tonic-gate return (-1);
4147c478bd9Sstevel@tonic-gate }
4157c478bd9Sstevel@tonic-gate
4167c478bd9Sstevel@tonic-gate /*
4177c478bd9Sstevel@tonic-gate * If the ring buffer has wrapped, it needs to be polished.
4187c478bd9Sstevel@tonic-gate * See the comment in dtrace_buffer_polish() for details.
4197c478bd9Sstevel@tonic-gate */
4207c478bd9Sstevel@tonic-gate if (buf.dtb_offset < buf.dtb_xamot_offset) {
4217c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset,
4227c478bd9Sstevel@tonic-gate buf.dtb_xamot_offset - buf.dtb_offset);
4237c478bd9Sstevel@tonic-gate }
4247c478bd9Sstevel@tonic-gate
4257c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_xamot_offset) {
4267c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset,
4277c478bd9Sstevel@tonic-gate buf.dtb_size - buf.dtb_offset);
4287c478bd9Sstevel@tonic-gate bzero(data, buf.dtb_xamot_offset);
4297c478bd9Sstevel@tonic-gate }
4307c478bd9Sstevel@tonic-gate
4317c478bd9Sstevel@tonic-gate desc->dtbd_oldest = buf.dtb_xamot_offset;
4327c478bd9Sstevel@tonic-gate } else {
4337c478bd9Sstevel@tonic-gate desc->dtbd_oldest = 0;
4347c478bd9Sstevel@tonic-gate }
4357c478bd9Sstevel@tonic-gate
436*9f7719e7SJason King /*
437*9f7719e7SJason King * On a live system, dtbd_timestamp is set to gethrtime() when the
438*9f7719e7SJason King * DTRACEIOC_BUFSNAP ioctl is called. The effect of this is that the
439*9f7719e7SJason King * timestamps of all the enabled probe records in the buf will always
440*9f7719e7SJason King * be less than dtbd_timestamp. dtrace_consume() relies on this
441*9f7719e7SJason King * invariant to determine when it needs to retrieve more dtrace bufs
442*9f7719e7SJason King * from the kernel.
443*9f7719e7SJason King *
444*9f7719e7SJason King * However when mdb is reading a crash dump, the value of
445*9f7719e7SJason King * gethrtime() on the system running mdb may smaller than the
446*9f7719e7SJason King * enabled probe records in the crash dump, violating the invariant
447*9f7719e7SJason King * dtrace_consume() is relying on. This can cause dtrace_consume()
448*9f7719e7SJason King * to prematurely stop processing records.
449*9f7719e7SJason King *
450*9f7719e7SJason King * To preserve the invariant dtrace_consume() requires, we simply
451*9f7719e7SJason King * add the value of panic_hrtime to gethrtime() when setting
452*9f7719e7SJason King * dtdb_timestamp. On a live system, panic_hrtime will be 0, and
453*9f7719e7SJason King * the invariant will be preserved by virtue of being running on
454*9f7719e7SJason King * a live system. On a crash dump, no valid probe record can have a
455*9f7719e7SJason King * timestamp greater than panic_hrtime, so adding this to the value
456*9f7719e7SJason King * of gethrtime() will guarantee the invariant expected by
457*9f7719e7SJason King * dtrace_consume() is preserved.
458*9f7719e7SJason King */
459*9f7719e7SJason King if (!offset_set) {
460*9f7719e7SJason King hrtime_t panic_hrtime;
461*9f7719e7SJason King
462*9f7719e7SJason King /*
463*9f7719e7SJason King * We could be slightly more clever and only set hr_offset
464*9f7719e7SJason King * if gethrtime() in mdb is < panic_hrtime, but it doesn't
465*9f7719e7SJason King * seem necessary. If for some reason, we cannot read
466*9f7719e7SJason King * panic_hrtime, we'll try to continue -- ::dtrace may
467*9f7719e7SJason King * still succeed, so we just warn and continue.
468*9f7719e7SJason King */
469*9f7719e7SJason King if (mdb_readvar(&panic_hrtime, "panic_hrtime") == -1) {
470*9f7719e7SJason King mdb_warn("failed to read 'panic_hrtime' -- "
471*9f7719e7SJason King "some dtrace data may not be displayed");
472*9f7719e7SJason King } else {
473*9f7719e7SJason King hr_offset = panic_hrtime;
474*9f7719e7SJason King }
475*9f7719e7SJason King offset_set = B_TRUE;
476*9f7719e7SJason King }
477*9f7719e7SJason King
4787c478bd9Sstevel@tonic-gate desc->dtbd_size = bufsize;
4797c478bd9Sstevel@tonic-gate desc->dtbd_drops = buf.dtb_drops;
4807c478bd9Sstevel@tonic-gate desc->dtbd_errors = buf.dtb_errors;
481*9f7719e7SJason King desc->dtbd_timestamp = gethrtime() + hr_offset;
4827c478bd9Sstevel@tonic-gate
4837c478bd9Sstevel@tonic-gate return (0);
4847c478bd9Sstevel@tonic-gate }
4857c478bd9Sstevel@tonic-gate
4867c478bd9Sstevel@tonic-gate /*
487c9a6ea2eSBryan Cantrill * This is essentially identical to its cousin in the kernel -- with the
488c9a6ea2eSBryan Cantrill * notable exception that we automatically set DTRACEOPT_GRABANON if this
489c9a6ea2eSBryan Cantrill * state is an anonymous enabling.
4907c478bd9Sstevel@tonic-gate */
4917c478bd9Sstevel@tonic-gate static dof_hdr_t *
dtracemdb_dof_create(dtrace_state_t * state,int isanon)492c9a6ea2eSBryan Cantrill dtracemdb_dof_create(dtrace_state_t *state, int isanon)
4937c478bd9Sstevel@tonic-gate {
4947c478bd9Sstevel@tonic-gate dof_hdr_t *dof;
4957c478bd9Sstevel@tonic-gate dof_sec_t *sec;
4967c478bd9Sstevel@tonic-gate dof_optdesc_t *opt;
4977c478bd9Sstevel@tonic-gate int i, len = sizeof (dof_hdr_t) +
4987c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t)) +
4997c478bd9Sstevel@tonic-gate sizeof (dof_optdesc_t) * DTRACEOPT_MAX;
5007c478bd9Sstevel@tonic-gate
5017c478bd9Sstevel@tonic-gate dof = mdb_zalloc(len, UM_SLEEP);
5027c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0;
5037c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1;
5047c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2;
5057c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3;
5067c478bd9Sstevel@tonic-gate
5077c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MODEL] = DOF_MODEL_NATIVE;
5087c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE;
509ac448965Sahl dof->dofh_ident[DOF_ID_VERSION] = DOF_VERSION;
5107c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFVERS] = DIF_VERSION;
5117c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFIREG] = DIF_DIR_NREGS;
5127c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFTREG] = DIF_DTR_NREGS;
5137c478bd9Sstevel@tonic-gate
5147c478bd9Sstevel@tonic-gate dof->dofh_flags = 0;
5157c478bd9Sstevel@tonic-gate dof->dofh_hdrsize = sizeof (dof_hdr_t);
5167c478bd9Sstevel@tonic-gate dof->dofh_secsize = sizeof (dof_sec_t);
5177c478bd9Sstevel@tonic-gate dof->dofh_secnum = 1; /* only DOF_SECT_OPTDESC */
5187c478bd9Sstevel@tonic-gate dof->dofh_secoff = sizeof (dof_hdr_t);
5197c478bd9Sstevel@tonic-gate dof->dofh_loadsz = len;
5207c478bd9Sstevel@tonic-gate dof->dofh_filesz = len;
5217c478bd9Sstevel@tonic-gate dof->dofh_pad = 0;
5227c478bd9Sstevel@tonic-gate
5237c478bd9Sstevel@tonic-gate /*
5247c478bd9Sstevel@tonic-gate * Fill in the option section header...
5257c478bd9Sstevel@tonic-gate */
5267c478bd9Sstevel@tonic-gate sec = (dof_sec_t *)((uintptr_t)dof + sizeof (dof_hdr_t));
5277c478bd9Sstevel@tonic-gate sec->dofs_type = DOF_SECT_OPTDESC;
5287c478bd9Sstevel@tonic-gate sec->dofs_align = sizeof (uint64_t);
5297c478bd9Sstevel@tonic-gate sec->dofs_flags = DOF_SECF_LOAD;
5307c478bd9Sstevel@tonic-gate sec->dofs_entsize = sizeof (dof_optdesc_t);
5317c478bd9Sstevel@tonic-gate
5327c478bd9Sstevel@tonic-gate opt = (dof_optdesc_t *)((uintptr_t)sec +
5337c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t)));
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate sec->dofs_offset = (uintptr_t)opt - (uintptr_t)dof;
5367c478bd9Sstevel@tonic-gate sec->dofs_size = sizeof (dof_optdesc_t) * DTRACEOPT_MAX;
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACEOPT_MAX; i++) {
5397c478bd9Sstevel@tonic-gate opt[i].dofo_option = i;
5407c478bd9Sstevel@tonic-gate opt[i].dofo_strtab = DOF_SECIDX_NONE;
5417c478bd9Sstevel@tonic-gate opt[i].dofo_value = state->dts_options[i];
5427c478bd9Sstevel@tonic-gate }
5437c478bd9Sstevel@tonic-gate
544c9a6ea2eSBryan Cantrill if (isanon)
545c9a6ea2eSBryan Cantrill opt[DTRACEOPT_GRABANON].dofo_value = 1;
546c9a6ea2eSBryan Cantrill
5477c478bd9Sstevel@tonic-gate return (dof);
5487c478bd9Sstevel@tonic-gate }
5497c478bd9Sstevel@tonic-gate
5507c478bd9Sstevel@tonic-gate static int
dtracemdb_format(dtrace_state_t * state,dtrace_fmtdesc_t * desc)5517c478bd9Sstevel@tonic-gate dtracemdb_format(dtrace_state_t *state, dtrace_fmtdesc_t *desc)
5527c478bd9Sstevel@tonic-gate {
5537c478bd9Sstevel@tonic-gate uintptr_t addr, faddr;
5547c478bd9Sstevel@tonic-gate char c;
5557c478bd9Sstevel@tonic-gate int len = 0;
5567c478bd9Sstevel@tonic-gate
5577c478bd9Sstevel@tonic-gate if (desc->dtfd_format == 0 || desc->dtfd_format > state->dts_nformats) {
5587c478bd9Sstevel@tonic-gate errno = EINVAL;
5597c478bd9Sstevel@tonic-gate return (-1);
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate
5627c478bd9Sstevel@tonic-gate faddr = (uintptr_t)state->dts_formats +
5637c478bd9Sstevel@tonic-gate (desc->dtfd_format - 1) * sizeof (char *);
5647c478bd9Sstevel@tonic-gate
5657c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), faddr) == -1) {
5667c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string pointer at %p", faddr);
5677c478bd9Sstevel@tonic-gate return (-1);
5687c478bd9Sstevel@tonic-gate }
5697c478bd9Sstevel@tonic-gate
5707c478bd9Sstevel@tonic-gate do {
5717c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), addr + len++) == -1) {
5727c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string at %p", addr);
5737c478bd9Sstevel@tonic-gate return (-1);
5747c478bd9Sstevel@tonic-gate }
5757c478bd9Sstevel@tonic-gate } while (c != '\0');
5767c478bd9Sstevel@tonic-gate
5777c478bd9Sstevel@tonic-gate if (len > desc->dtfd_length) {
5787c478bd9Sstevel@tonic-gate desc->dtfd_length = len;
5797c478bd9Sstevel@tonic-gate return (0);
5807c478bd9Sstevel@tonic-gate }
5817c478bd9Sstevel@tonic-gate
5827c478bd9Sstevel@tonic-gate if (mdb_vread(desc->dtfd_string, len, addr) == -1) {
5837c478bd9Sstevel@tonic-gate mdb_warn("failed to reread format string at %p", addr);
5847c478bd9Sstevel@tonic-gate return (-1);
5857c478bd9Sstevel@tonic-gate }
5867c478bd9Sstevel@tonic-gate
5877c478bd9Sstevel@tonic-gate return (0);
5887c478bd9Sstevel@tonic-gate }
5897c478bd9Sstevel@tonic-gate
5907c478bd9Sstevel@tonic-gate static int
dtracemdb_status(dtrace_state_t * state,dtrace_status_t * status)5917c478bd9Sstevel@tonic-gate dtracemdb_status(dtrace_state_t *state, dtrace_status_t *status)
5927c478bd9Sstevel@tonic-gate {
5937c478bd9Sstevel@tonic-gate dtrace_dstate_t *dstate;
5947c478bd9Sstevel@tonic-gate int i, j;
5957c478bd9Sstevel@tonic-gate uint64_t nerrs;
5967c478bd9Sstevel@tonic-gate uintptr_t addr;
5977c478bd9Sstevel@tonic-gate int ncpu;
5987c478bd9Sstevel@tonic-gate
5997c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) {
6007c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'");
6017c478bd9Sstevel@tonic-gate return (DCMD_ERR);
6027c478bd9Sstevel@tonic-gate }
6037c478bd9Sstevel@tonic-gate
6047c478bd9Sstevel@tonic-gate bzero(status, sizeof (dtrace_status_t));
6057c478bd9Sstevel@tonic-gate
6067c478bd9Sstevel@tonic-gate if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) {
6077c478bd9Sstevel@tonic-gate errno = ENOENT;
6087c478bd9Sstevel@tonic-gate return (-1);
6097c478bd9Sstevel@tonic-gate }
6107c478bd9Sstevel@tonic-gate
6117c478bd9Sstevel@tonic-gate /*
6127c478bd9Sstevel@tonic-gate * For the MDB backend, we never set dtst_exiting or dtst_filled. This
6137c478bd9Sstevel@tonic-gate * is by design: we don't want the library to try to stop tracing,
6147c478bd9Sstevel@tonic-gate * because it doesn't particularly mean anything.
6157c478bd9Sstevel@tonic-gate */
6167c478bd9Sstevel@tonic-gate nerrs = state->dts_errors;
6177c478bd9Sstevel@tonic-gate dstate = &state->dts_vstate.dtvs_dynvars;
6187c478bd9Sstevel@tonic-gate
6197c478bd9Sstevel@tonic-gate for (i = 0; i < ncpu; i++) {
6207c478bd9Sstevel@tonic-gate dtrace_dstate_percpu_t dcpu;
6217c478bd9Sstevel@tonic-gate dtrace_buffer_t buf;
6227c478bd9Sstevel@tonic-gate
6237c478bd9Sstevel@tonic-gate addr = (uintptr_t)&dstate->dtds_percpu[i];
6247c478bd9Sstevel@tonic-gate
6257c478bd9Sstevel@tonic-gate if (mdb_vread(&dcpu, sizeof (dcpu), addr) == -1) {
6267c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU dstate at %p", addr);
6277c478bd9Sstevel@tonic-gate return (-1);
6287c478bd9Sstevel@tonic-gate }
6297c478bd9Sstevel@tonic-gate
6307c478bd9Sstevel@tonic-gate status->dtst_dyndrops += dcpu.dtdsc_drops;
6317c478bd9Sstevel@tonic-gate status->dtst_dyndrops_dirty += dcpu.dtdsc_dirty_drops;
6327c478bd9Sstevel@tonic-gate status->dtst_dyndrops_rinsing += dcpu.dtdsc_rinsing_drops;
6337c478bd9Sstevel@tonic-gate
6347c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_buffer[i];
6357c478bd9Sstevel@tonic-gate
6367c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
6377c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU buffer at %p", addr);
6387c478bd9Sstevel@tonic-gate return (-1);
6397c478bd9Sstevel@tonic-gate }
6407c478bd9Sstevel@tonic-gate
6417c478bd9Sstevel@tonic-gate nerrs += buf.dtb_errors;
6427c478bd9Sstevel@tonic-gate
6437c478bd9Sstevel@tonic-gate for (j = 0; j < state->dts_nspeculations; j++) {
6447c478bd9Sstevel@tonic-gate dtrace_speculation_t spec;
6457c478bd9Sstevel@tonic-gate
6467c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_speculations[j];
6477c478bd9Sstevel@tonic-gate
6487c478bd9Sstevel@tonic-gate if (mdb_vread(&spec, sizeof (spec), addr) == -1) {
6497c478bd9Sstevel@tonic-gate mdb_warn("failed to read "
6507c478bd9Sstevel@tonic-gate "speculation at %p", addr);
6517c478bd9Sstevel@tonic-gate return (-1);
6527c478bd9Sstevel@tonic-gate }
6537c478bd9Sstevel@tonic-gate
6547c478bd9Sstevel@tonic-gate addr = (uintptr_t)&spec.dtsp_buffer[i];
6557c478bd9Sstevel@tonic-gate
6567c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
6577c478bd9Sstevel@tonic-gate mdb_warn("failed to read "
6587c478bd9Sstevel@tonic-gate "speculative buffer at %p", addr);
6597c478bd9Sstevel@tonic-gate return (-1);
6607c478bd9Sstevel@tonic-gate }
6617c478bd9Sstevel@tonic-gate
6627c478bd9Sstevel@tonic-gate status->dtst_specdrops += buf.dtb_xamot_drops;
6637c478bd9Sstevel@tonic-gate }
6647c478bd9Sstevel@tonic-gate }
6657c478bd9Sstevel@tonic-gate
6667c478bd9Sstevel@tonic-gate status->dtst_specdrops_busy = state->dts_speculations_busy;
6677c478bd9Sstevel@tonic-gate status->dtst_specdrops_unavail = state->dts_speculations_unavail;
6687c478bd9Sstevel@tonic-gate status->dtst_errors = nerrs;
6697c478bd9Sstevel@tonic-gate
6707c478bd9Sstevel@tonic-gate return (0);
6717c478bd9Sstevel@tonic-gate }
6727c478bd9Sstevel@tonic-gate
6737c478bd9Sstevel@tonic-gate typedef struct dtracemdb_data {
6747c478bd9Sstevel@tonic-gate dtrace_state_t *dtmd_state;
6757c478bd9Sstevel@tonic-gate char *dtmd_symstr;
6767c478bd9Sstevel@tonic-gate char *dtmd_modstr;
6777c478bd9Sstevel@tonic-gate uintptr_t dtmd_addr;
678c9a6ea2eSBryan Cantrill int dtmd_isanon;
6797c478bd9Sstevel@tonic-gate } dtracemdb_data_t;
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate static int
dtracemdb_ioctl(void * varg,int cmd,void * arg)6827c478bd9Sstevel@tonic-gate dtracemdb_ioctl(void *varg, int cmd, void *arg)
6837c478bd9Sstevel@tonic-gate {
6847c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg;
6857c478bd9Sstevel@tonic-gate dtrace_state_t *state = data->dtmd_state;
6867c478bd9Sstevel@tonic-gate
6877c478bd9Sstevel@tonic-gate switch (cmd) {
6887c478bd9Sstevel@tonic-gate case DTRACEIOC_CONF: {
6897c478bd9Sstevel@tonic-gate dtrace_conf_t *conf = arg;
6907c478bd9Sstevel@tonic-gate
6917c478bd9Sstevel@tonic-gate bzero(conf, sizeof (conf));
6927c478bd9Sstevel@tonic-gate conf->dtc_difversion = DIF_VERSION;
6937c478bd9Sstevel@tonic-gate conf->dtc_difintregs = DIF_DIR_NREGS;
6947c478bd9Sstevel@tonic-gate conf->dtc_diftupregs = DIF_DTR_NREGS;
6957c478bd9Sstevel@tonic-gate conf->dtc_ctfmodel = CTF_MODEL_NATIVE;
6967c478bd9Sstevel@tonic-gate
6977c478bd9Sstevel@tonic-gate return (0);
6987c478bd9Sstevel@tonic-gate }
6997c478bd9Sstevel@tonic-gate
7007c478bd9Sstevel@tonic-gate case DTRACEIOC_DOFGET: {
7017c478bd9Sstevel@tonic-gate dof_hdr_t *hdr = arg, *dof;
7027c478bd9Sstevel@tonic-gate
703c9a6ea2eSBryan Cantrill dof = dtracemdb_dof_create(state, data->dtmd_isanon);
7047c478bd9Sstevel@tonic-gate bcopy(dof, hdr, MIN(hdr->dofh_loadsz, dof->dofh_loadsz));
7057c478bd9Sstevel@tonic-gate mdb_free(dof, dof->dofh_loadsz);
7067c478bd9Sstevel@tonic-gate
7077c478bd9Sstevel@tonic-gate return (0);
7087c478bd9Sstevel@tonic-gate }
7097c478bd9Sstevel@tonic-gate
7107c478bd9Sstevel@tonic-gate case DTRACEIOC_BUFSNAP:
7117c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_buffer, arg));
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGSNAP:
7147c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_aggbuffer, arg));
7157c478bd9Sstevel@tonic-gate
7167c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGDESC:
7177c478bd9Sstevel@tonic-gate return (dtracemdb_aggdesc(state, arg));
7187c478bd9Sstevel@tonic-gate
7197c478bd9Sstevel@tonic-gate case DTRACEIOC_EPROBE:
7207c478bd9Sstevel@tonic-gate return (dtracemdb_eprobe(state, arg));
7217c478bd9Sstevel@tonic-gate
7227c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBES:
7237c478bd9Sstevel@tonic-gate return (dtracemdb_probe(state, arg));
7247c478bd9Sstevel@tonic-gate
7257c478bd9Sstevel@tonic-gate case DTRACEIOC_FORMAT:
7267c478bd9Sstevel@tonic-gate return (dtracemdb_format(state, arg));
7277c478bd9Sstevel@tonic-gate
7287c478bd9Sstevel@tonic-gate case DTRACEIOC_STATUS:
7297c478bd9Sstevel@tonic-gate return (dtracemdb_status(state, arg));
7307c478bd9Sstevel@tonic-gate
7317c478bd9Sstevel@tonic-gate case DTRACEIOC_GO:
7327c478bd9Sstevel@tonic-gate *(processorid_t *)arg = -1;
7337c478bd9Sstevel@tonic-gate return (0);
7347c478bd9Sstevel@tonic-gate
7357c478bd9Sstevel@tonic-gate case DTRACEIOC_ENABLE:
7367c478bd9Sstevel@tonic-gate errno = ENOTTY; /* see dt_open.c:dtrace_go() */
7377c478bd9Sstevel@tonic-gate return (-1);
7387c478bd9Sstevel@tonic-gate
7397c478bd9Sstevel@tonic-gate case DTRACEIOC_PROVIDER:
7407c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBEMATCH:
7417c478bd9Sstevel@tonic-gate errno = ESRCH;
7427c478bd9Sstevel@tonic-gate return (-1);
7437c478bd9Sstevel@tonic-gate
7447c478bd9Sstevel@tonic-gate default:
7457c478bd9Sstevel@tonic-gate mdb_warn("unexpected ioctl 0x%x (%s)\n", cmd,
7467c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROVIDER ? "DTRACEIOC_PROVIDER" :
7477c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBES ? "DTRACEIOC_PROBES" :
7487c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_BUFSNAP ? "DTRACEIOC_BUFSNAP" :
7497c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEMATCH ? "DTRACEIOC_PROBEMATCH" :
7507c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_ENABLE ? "DTRACEIOC_ENABLE" :
7517c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGSNAP ? "DTRACEIOC_AGGSNAP" :
7527c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_EPROBE ? "DTRACEIOC_EPROBE" :
7537c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEARG ? "DTRACEIOC_PROBEARG" :
7547c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_CONF ? "DTRACEIOC_CONF" :
7557c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STATUS ? "DTRACEIOC_STATUS" :
7567c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_GO ? "DTRACEIOC_GO" :
7577c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STOP ? "DTRACEIOC_STOP" :
7587c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGDESC ? "DTRACEIOC_AGGDESC" :
7597c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_FORMAT ? "DTRACEIOC_FORMAT" :
7607c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_DOFGET ? "DTRACEIOC_DOFGET" :
7617c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_REPLICATE ? "DTRACEIOC_REPLICATE" :
7627c478bd9Sstevel@tonic-gate "???");
7637c478bd9Sstevel@tonic-gate errno = ENXIO;
7647c478bd9Sstevel@tonic-gate return (-1);
7657c478bd9Sstevel@tonic-gate }
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate
7687c478bd9Sstevel@tonic-gate static int
dtracemdb_modctl(uintptr_t addr,const struct modctl * m,dtracemdb_data_t * data)7697c478bd9Sstevel@tonic-gate dtracemdb_modctl(uintptr_t addr, const struct modctl *m, dtracemdb_data_t *data)
7707c478bd9Sstevel@tonic-gate {
7717c478bd9Sstevel@tonic-gate struct module mod;
7727c478bd9Sstevel@tonic-gate
7737c478bd9Sstevel@tonic-gate if (m->mod_mp == NULL)
7747c478bd9Sstevel@tonic-gate return (WALK_NEXT);
7757c478bd9Sstevel@tonic-gate
7767c478bd9Sstevel@tonic-gate if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) {
7777c478bd9Sstevel@tonic-gate mdb_warn("couldn't read modctl %p's module", addr);
7787c478bd9Sstevel@tonic-gate return (WALK_NEXT);
7797c478bd9Sstevel@tonic-gate }
7807c478bd9Sstevel@tonic-gate
7817c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text > data->dtmd_addr)
7827c478bd9Sstevel@tonic-gate return (WALK_NEXT);
7837c478bd9Sstevel@tonic-gate
7847c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text + mod.text_size <= data->dtmd_addr)
7857c478bd9Sstevel@tonic-gate return (WALK_NEXT);
7867c478bd9Sstevel@tonic-gate
7877c478bd9Sstevel@tonic-gate if (mdb_readstr(data->dtmd_modstr, MDB_SYM_NAMLEN,
7887c478bd9Sstevel@tonic-gate (uintptr_t)m->mod_modname) == -1)
7897c478bd9Sstevel@tonic-gate return (WALK_ERR);
7907c478bd9Sstevel@tonic-gate
7917c478bd9Sstevel@tonic-gate return (WALK_DONE);
7927c478bd9Sstevel@tonic-gate }
7937c478bd9Sstevel@tonic-gate
7947c478bd9Sstevel@tonic-gate static int
dtracemdb_lookup_by_addr(void * varg,GElf_Addr addr,GElf_Sym * symp,dtrace_syminfo_t * sip)7957c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr(void *varg, GElf_Addr addr, GElf_Sym *symp,
7967c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip)
7977c478bd9Sstevel@tonic-gate {
7987c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg;
7997c478bd9Sstevel@tonic-gate
8007c478bd9Sstevel@tonic-gate if (data->dtmd_symstr == NULL) {
8017c478bd9Sstevel@tonic-gate data->dtmd_symstr = mdb_zalloc(MDB_SYM_NAMLEN,
8027c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC);
8037c478bd9Sstevel@tonic-gate }
8047c478bd9Sstevel@tonic-gate
8057c478bd9Sstevel@tonic-gate if (data->dtmd_modstr == NULL) {
8067c478bd9Sstevel@tonic-gate data->dtmd_modstr = mdb_zalloc(MDB_SYM_NAMLEN,
8077c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC);
8087c478bd9Sstevel@tonic-gate }
8097c478bd9Sstevel@tonic-gate
8107c478bd9Sstevel@tonic-gate if (symp != NULL) {
8117c478bd9Sstevel@tonic-gate if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, data->dtmd_symstr,
8127c478bd9Sstevel@tonic-gate MDB_SYM_NAMLEN, symp) == -1)
8137c478bd9Sstevel@tonic-gate return (-1);
8147c478bd9Sstevel@tonic-gate }
8157c478bd9Sstevel@tonic-gate
8167c478bd9Sstevel@tonic-gate if (sip != NULL) {
8177c478bd9Sstevel@tonic-gate data->dtmd_addr = addr;
8187c478bd9Sstevel@tonic-gate
8197c478bd9Sstevel@tonic-gate (void) strcpy(data->dtmd_modstr, "???");
8207c478bd9Sstevel@tonic-gate
8217c478bd9Sstevel@tonic-gate if (mdb_walk("modctl",
8227c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtracemdb_modctl, varg) == -1) {
8237c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'modctl'");
8247c478bd9Sstevel@tonic-gate return (-1);
8257c478bd9Sstevel@tonic-gate }
8267c478bd9Sstevel@tonic-gate
8277c478bd9Sstevel@tonic-gate sip->dts_object = data->dtmd_modstr;
8287c478bd9Sstevel@tonic-gate sip->dts_id = 0;
8297c478bd9Sstevel@tonic-gate sip->dts_name = symp != NULL ? data->dtmd_symstr : NULL;
8307c478bd9Sstevel@tonic-gate }
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate return (0);
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate
8357c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8367c478bd9Sstevel@tonic-gate static int
dtracemdb_stat(void * varg,processorid_t cpu)8377c478bd9Sstevel@tonic-gate dtracemdb_stat(void *varg, processorid_t cpu)
8387c478bd9Sstevel@tonic-gate {
8397c478bd9Sstevel@tonic-gate GElf_Sym sym;
8407c478bd9Sstevel@tonic-gate cpu_t c;
8417c478bd9Sstevel@tonic-gate uintptr_t caddr, addr;
8427c478bd9Sstevel@tonic-gate
8437c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("cpu", &sym) == -1) {
8447c478bd9Sstevel@tonic-gate mdb_warn("failed to find symbol for 'cpu'");
8457c478bd9Sstevel@tonic-gate return (-1);
8467c478bd9Sstevel@tonic-gate }
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate if (cpu * sizeof (uintptr_t) > sym.st_size)
8497c478bd9Sstevel@tonic-gate return (-1);
8507c478bd9Sstevel@tonic-gate
8517c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value + cpu * sizeof (uintptr_t);
8527c478bd9Sstevel@tonic-gate
8537c478bd9Sstevel@tonic-gate if (mdb_vread(&caddr, sizeof (caddr), addr) == -1) {
8547c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu[%d]", cpu);
8557c478bd9Sstevel@tonic-gate return (-1);
8567c478bd9Sstevel@tonic-gate }
8577c478bd9Sstevel@tonic-gate
858892ad162SToomas Soome if (caddr == 0)
8597c478bd9Sstevel@tonic-gate return (-1);
8607c478bd9Sstevel@tonic-gate
8617c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), caddr) == -1) {
8627c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu at %p", caddr);
8637c478bd9Sstevel@tonic-gate return (-1);
8647c478bd9Sstevel@tonic-gate }
8657c478bd9Sstevel@tonic-gate
8667c478bd9Sstevel@tonic-gate if (c.cpu_flags & CPU_POWEROFF) {
8677c478bd9Sstevel@tonic-gate return (P_POWEROFF);
8687c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_SPARE) {
8697c478bd9Sstevel@tonic-gate return (P_SPARE);
8707c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_FAULTED) {
8717c478bd9Sstevel@tonic-gate return (P_FAULTED);
872c3377ee9SJohn Levon } else if (c.cpu_flags & CPU_DISABLED) {
873c3377ee9SJohn Levon return (P_DISABLED);
8747c478bd9Sstevel@tonic-gate } else if ((c.cpu_flags & (CPU_READY | CPU_OFFLINE)) != CPU_READY) {
8757c478bd9Sstevel@tonic-gate return (P_OFFLINE);
8767c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_ENABLE) {
8777c478bd9Sstevel@tonic-gate return (P_ONLINE);
8787c478bd9Sstevel@tonic-gate } else {
8797c478bd9Sstevel@tonic-gate return (P_NOINTR);
8807c478bd9Sstevel@tonic-gate }
8817c478bd9Sstevel@tonic-gate }
8827c478bd9Sstevel@tonic-gate
8837c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8847c478bd9Sstevel@tonic-gate static long
dtracemdb_sysconf(void * varg,int name)8857c478bd9Sstevel@tonic-gate dtracemdb_sysconf(void *varg, int name)
8867c478bd9Sstevel@tonic-gate {
8877c478bd9Sstevel@tonic-gate int max_ncpus;
8887c478bd9Sstevel@tonic-gate processorid_t max_cpuid;
8897c478bd9Sstevel@tonic-gate
8907c478bd9Sstevel@tonic-gate switch (name) {
8917c478bd9Sstevel@tonic-gate case _SC_CPUID_MAX:
8927c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) {
8937c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'");
8947c478bd9Sstevel@tonic-gate return (-1);
8957c478bd9Sstevel@tonic-gate }
8967c478bd9Sstevel@tonic-gate
8977c478bd9Sstevel@tonic-gate return (max_cpuid);
8987c478bd9Sstevel@tonic-gate
8997c478bd9Sstevel@tonic-gate case _SC_NPROCESSORS_MAX:
9007c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
9017c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_ncpus'");
9027c478bd9Sstevel@tonic-gate return (-1);
9037c478bd9Sstevel@tonic-gate }
9047c478bd9Sstevel@tonic-gate
9057c478bd9Sstevel@tonic-gate return (max_ncpus);
9067c478bd9Sstevel@tonic-gate
9077c478bd9Sstevel@tonic-gate default:
9087c478bd9Sstevel@tonic-gate mdb_warn("unexpected sysconf code %d\n", name);
9097c478bd9Sstevel@tonic-gate return (-1);
9107c478bd9Sstevel@tonic-gate }
9117c478bd9Sstevel@tonic-gate }
9127c478bd9Sstevel@tonic-gate
9137c478bd9Sstevel@tonic-gate const dtrace_vector_t dtrace_mdbops = {
9147c478bd9Sstevel@tonic-gate dtracemdb_ioctl,
9157c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr,
9167c478bd9Sstevel@tonic-gate dtracemdb_stat,
9177c478bd9Sstevel@tonic-gate dtracemdb_sysconf
9187c478bd9Sstevel@tonic-gate };
9197c478bd9Sstevel@tonic-gate
9207c478bd9Sstevel@tonic-gate typedef struct dtrace_dcmddata {
9217c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtdd_dtp;
9227c478bd9Sstevel@tonic-gate int dtdd_cpu;
9237c478bd9Sstevel@tonic-gate int dtdd_quiet;
9247c478bd9Sstevel@tonic-gate int dtdd_flowindent;
9257c478bd9Sstevel@tonic-gate int dtdd_heading;
9267994dfddSDan Kimmel FILE *dtdd_output;
9277c478bd9Sstevel@tonic-gate } dtrace_dcmddata_t;
9287c478bd9Sstevel@tonic-gate
9297994dfddSDan Kimmel /*
9307994dfddSDan Kimmel * Helper to grab all the content from a file, spit it into a string, and erase
9317994dfddSDan Kimmel * and reset the file.
9327994dfddSDan Kimmel */
9337994dfddSDan Kimmel static void
print_and_truncate_file(FILE * fp)9347994dfddSDan Kimmel print_and_truncate_file(FILE *fp)
9357994dfddSDan Kimmel {
9367994dfddSDan Kimmel long len;
9377994dfddSDan Kimmel char *out;
9387994dfddSDan Kimmel
9397994dfddSDan Kimmel /* flush, find length of file, seek to beginning, initialize buffer */
9407994dfddSDan Kimmel if (fflush(fp) || (len = ftell(fp)) < 0 ||
9417994dfddSDan Kimmel fseek(fp, 0, SEEK_SET) < 0) {
9427994dfddSDan Kimmel mdb_warn("couldn't prepare DTrace output file: %d\n", errno);
9437994dfddSDan Kimmel return;
9447994dfddSDan Kimmel }
9457994dfddSDan Kimmel
9467994dfddSDan Kimmel out = mdb_alloc(len + 1, UM_SLEEP);
9477994dfddSDan Kimmel out[len] = '\0';
9487994dfddSDan Kimmel
9497994dfddSDan Kimmel /* read file into buffer, truncate file, and seek to beginning */
9507994dfddSDan Kimmel if ((fread(out, len + 1, sizeof (char), fp) == 0 && ferror(fp)) ||
9517994dfddSDan Kimmel ftruncate(fileno(fp), 0) < 0 || fseek(fp, 0, SEEK_SET) < 0) {
9527994dfddSDan Kimmel mdb_warn("couldn't read DTrace output file: %d\n", errno);
9537994dfddSDan Kimmel mdb_free(out, len + 1);
9547994dfddSDan Kimmel return;
9557994dfddSDan Kimmel }
9567994dfddSDan Kimmel
9577994dfddSDan Kimmel mdb_printf("%s", out);
9587994dfddSDan Kimmel mdb_free(out, len + 1);
9597994dfddSDan Kimmel }
9607994dfddSDan Kimmel
9617c478bd9Sstevel@tonic-gate /*ARGSUSED*/
9627c478bd9Sstevel@tonic-gate static int
dtrace_dcmdrec(const dtrace_probedata_t * data,const dtrace_recdesc_t * rec,void * arg)9637c478bd9Sstevel@tonic-gate dtrace_dcmdrec(const dtrace_probedata_t *data,
9647c478bd9Sstevel@tonic-gate const dtrace_recdesc_t *rec, void *arg)
9657c478bd9Sstevel@tonic-gate {
9667c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg;
9677c478bd9Sstevel@tonic-gate
9687994dfddSDan Kimmel print_and_truncate_file(dd->dtdd_output);
9697994dfddSDan Kimmel
9707c478bd9Sstevel@tonic-gate if (rec == NULL) {
9717c478bd9Sstevel@tonic-gate /*
9727c478bd9Sstevel@tonic-gate * We have processed the final record; output the newline if
9737c478bd9Sstevel@tonic-gate * we're not in quiet mode.
9747c478bd9Sstevel@tonic-gate */
9757c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet)
9767c478bd9Sstevel@tonic-gate mdb_printf("\n");
9777c478bd9Sstevel@tonic-gate
9787c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT);
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate
9817c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS);
9827c478bd9Sstevel@tonic-gate }
9837c478bd9Sstevel@tonic-gate
9847c478bd9Sstevel@tonic-gate /*ARGSUSED*/
9857c478bd9Sstevel@tonic-gate static int
dtrace_dcmdprobe(const dtrace_probedata_t * data,void * arg)9867c478bd9Sstevel@tonic-gate dtrace_dcmdprobe(const dtrace_probedata_t *data, void *arg)
9877c478bd9Sstevel@tonic-gate {
9887c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pd = data->dtpda_pdesc;
9897c478bd9Sstevel@tonic-gate processorid_t cpu = data->dtpda_cpu;
9907c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg;
9917c478bd9Sstevel@tonic-gate char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2];
9927c478bd9Sstevel@tonic-gate
9937c478bd9Sstevel@tonic-gate if (dd->dtdd_cpu != -1UL && dd->dtdd_cpu != cpu)
9947c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT);
9957c478bd9Sstevel@tonic-gate
9967c478bd9Sstevel@tonic-gate if (dd->dtdd_heading == 0) {
9977c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) {
9987c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) {
9997c478bd9Sstevel@tonic-gate mdb_printf("%3s %6s %32s\n",
10007c478bd9Sstevel@tonic-gate "CPU", "ID", "FUNCTION:NAME");
10017c478bd9Sstevel@tonic-gate }
10027c478bd9Sstevel@tonic-gate } else {
10037c478bd9Sstevel@tonic-gate mdb_printf("%3s %-41s\n", "CPU", "FUNCTION");
10047c478bd9Sstevel@tonic-gate }
10057c478bd9Sstevel@tonic-gate dd->dtdd_heading = 1;
10067c478bd9Sstevel@tonic-gate }
10077c478bd9Sstevel@tonic-gate
10087c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) {
10097c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) {
10107c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%s:%s",
10117c478bd9Sstevel@tonic-gate pd->dtpd_func, pd->dtpd_name);
10127c478bd9Sstevel@tonic-gate
10137c478bd9Sstevel@tonic-gate mdb_printf("%3d %6d %32s ", cpu, pd->dtpd_id, name);
10147c478bd9Sstevel@tonic-gate }
10157c478bd9Sstevel@tonic-gate } else {
10167c478bd9Sstevel@tonic-gate int indent = data->dtpda_indent;
10177c478bd9Sstevel@tonic-gate
10187c478bd9Sstevel@tonic-gate if (data->dtpda_flow == DTRACEFLOW_NONE) {
10197c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s:%s",
10207c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func,
10217c478bd9Sstevel@tonic-gate pd->dtpd_name);
10227c478bd9Sstevel@tonic-gate } else {
10237c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s",
10247c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func);
10257c478bd9Sstevel@tonic-gate }
10267c478bd9Sstevel@tonic-gate
10277c478bd9Sstevel@tonic-gate mdb_printf("%3d %-41s ", cpu, name);
10287c478bd9Sstevel@tonic-gate }
10297c478bd9Sstevel@tonic-gate
10307c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS);
10317c478bd9Sstevel@tonic-gate }
10327c478bd9Sstevel@tonic-gate
10337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
10347c478bd9Sstevel@tonic-gate static int
dtrace_dcmderr(const dtrace_errdata_t * data,void * arg)1035a1b5e537Sbmc dtrace_dcmderr(const dtrace_errdata_t *data, void *arg)
10367c478bd9Sstevel@tonic-gate {
10377c478bd9Sstevel@tonic-gate mdb_warn(data->dteda_msg);
10387c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK);
10397c478bd9Sstevel@tonic-gate }
10407c478bd9Sstevel@tonic-gate
10417c478bd9Sstevel@tonic-gate /*ARGSUSED*/
10427c478bd9Sstevel@tonic-gate static int
dtrace_dcmddrop(const dtrace_dropdata_t * data,void * arg)1043a1b5e537Sbmc dtrace_dcmddrop(const dtrace_dropdata_t *data, void *arg)
10447c478bd9Sstevel@tonic-gate {
10457c478bd9Sstevel@tonic-gate mdb_warn(data->dtdda_msg);
10467c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK);
10477c478bd9Sstevel@tonic-gate }
10487c478bd9Sstevel@tonic-gate
10497c478bd9Sstevel@tonic-gate /*ARGSUSED*/
10507c478bd9Sstevel@tonic-gate static int
dtrace_dcmdbuffered(const dtrace_bufdata_t * bufdata,void * arg)1051a1b5e537Sbmc dtrace_dcmdbuffered(const dtrace_bufdata_t *bufdata, void *arg)
10527c478bd9Sstevel@tonic-gate {
10537c478bd9Sstevel@tonic-gate mdb_printf("%s", bufdata->dtbda_buffered);
10547c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK);
10557c478bd9Sstevel@tonic-gate }
10567c478bd9Sstevel@tonic-gate
10577c478bd9Sstevel@tonic-gate /*ARGSUSED*/
10587c478bd9Sstevel@tonic-gate int
dtrace(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)10597c478bd9Sstevel@tonic-gate dtrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
10607c478bd9Sstevel@tonic-gate {
10617c478bd9Sstevel@tonic-gate dtrace_state_t state;
10627c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp;
10637c478bd9Sstevel@tonic-gate int ncpu, err;
10647c478bd9Sstevel@tonic-gate uintptr_t c = -1UL;
10657c478bd9Sstevel@tonic-gate dtrace_dcmddata_t dd;
10667c478bd9Sstevel@tonic-gate dtrace_optval_t val;
10677c478bd9Sstevel@tonic-gate dtracemdb_data_t md;
10687c478bd9Sstevel@tonic-gate int rval = DCMD_ERR;
1069c9a6ea2eSBryan Cantrill dtrace_anon_t anon;
10707c478bd9Sstevel@tonic-gate
10717c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC))
10727c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
10737c478bd9Sstevel@tonic-gate
10747c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'c', MDB_OPT_UINTPTR, &c, NULL) != argc)
10757c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
10767c478bd9Sstevel@tonic-gate
10777c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) {
10787c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'");
10797c478bd9Sstevel@tonic-gate return (DCMD_ERR);
10807c478bd9Sstevel@tonic-gate }
10817c478bd9Sstevel@tonic-gate
10827c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) {
10837c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", addr);
10847c478bd9Sstevel@tonic-gate return (DCMD_ERR);
10857c478bd9Sstevel@tonic-gate }
10867c478bd9Sstevel@tonic-gate
1087c9a6ea2eSBryan Cantrill if (state.dts_anon != NULL) {
1088c9a6ea2eSBryan Cantrill addr = (uintptr_t)state.dts_anon;
1089c9a6ea2eSBryan Cantrill
1090c9a6ea2eSBryan Cantrill if (mdb_vread(&state, sizeof (state), addr) == -1) {
1091c9a6ea2eSBryan Cantrill mdb_warn("couldn't read anonymous state at %p", addr);
1092c9a6ea2eSBryan Cantrill return (DCMD_ERR);
1093c9a6ea2eSBryan Cantrill }
1094c9a6ea2eSBryan Cantrill }
1095c9a6ea2eSBryan Cantrill
10967c478bd9Sstevel@tonic-gate bzero(&md, sizeof (md));
10977c478bd9Sstevel@tonic-gate md.dtmd_state = &state;
10987c478bd9Sstevel@tonic-gate
10997c478bd9Sstevel@tonic-gate if ((dtp = dtrace_vopen(DTRACE_VERSION, DTRACE_O_NOSYS, &err,
11007c478bd9Sstevel@tonic-gate &dtrace_mdbops, &md)) == NULL) {
11017c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n",
11027c478bd9Sstevel@tonic-gate dtrace_errmsg(NULL, err));
11037c478bd9Sstevel@tonic-gate return (DCMD_ERR);
11047c478bd9Sstevel@tonic-gate }
11057c478bd9Sstevel@tonic-gate
1106c9a6ea2eSBryan Cantrill /*
1107c9a6ea2eSBryan Cantrill * If this is the anonymous enabling, we need to set a bit indicating
1108c9a6ea2eSBryan Cantrill * that DTRACEOPT_GRABANON should be set.
1109c9a6ea2eSBryan Cantrill */
1110c9a6ea2eSBryan Cantrill if (mdb_readvar(&anon, "dtrace_anon") == -1) {
1111c9a6ea2eSBryan Cantrill mdb_warn("failed to read 'dtrace_anon'");
1112c9a6ea2eSBryan Cantrill return (DCMD_ERR);
1113c9a6ea2eSBryan Cantrill }
1114c9a6ea2eSBryan Cantrill
1115c9a6ea2eSBryan Cantrill md.dtmd_isanon = ((uintptr_t)anon.dta_state == addr);
1116c9a6ea2eSBryan Cantrill
11177c478bd9Sstevel@tonic-gate if (dtrace_go(dtp) != 0) {
11187c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n",
11197c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11207c478bd9Sstevel@tonic-gate goto err;
11217c478bd9Sstevel@tonic-gate }
11227c478bd9Sstevel@tonic-gate
11237c478bd9Sstevel@tonic-gate bzero(&dd, sizeof (dd));
11247c478bd9Sstevel@tonic-gate dd.dtdd_dtp = dtp;
11257c478bd9Sstevel@tonic-gate dd.dtdd_cpu = c;
11267c478bd9Sstevel@tonic-gate
11277c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "flowindent", &val) == -1) {
11287c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'flowindent' option: %s\n",
11297c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11307c478bd9Sstevel@tonic-gate goto err;
11317c478bd9Sstevel@tonic-gate }
11327c478bd9Sstevel@tonic-gate
11337c478bd9Sstevel@tonic-gate dd.dtdd_flowindent = (val != DTRACEOPT_UNSET);
11347c478bd9Sstevel@tonic-gate
11357c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "quiet", &val) == -1) {
11367c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'quiet' option: %s\n",
11377c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11387c478bd9Sstevel@tonic-gate goto err;
11397c478bd9Sstevel@tonic-gate }
11407c478bd9Sstevel@tonic-gate
11417c478bd9Sstevel@tonic-gate dd.dtdd_quiet = (val != DTRACEOPT_UNSET);
11427c478bd9Sstevel@tonic-gate
11437c478bd9Sstevel@tonic-gate if (dtrace_handle_err(dtp, dtrace_dcmderr, NULL) == -1) {
11447c478bd9Sstevel@tonic-gate mdb_warn("couldn't add err handler: %s\n",
11457c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11467c478bd9Sstevel@tonic-gate goto err;
11477c478bd9Sstevel@tonic-gate }
11487c478bd9Sstevel@tonic-gate
11497c478bd9Sstevel@tonic-gate if (dtrace_handle_drop(dtp, dtrace_dcmddrop, NULL) == -1) {
11507c478bd9Sstevel@tonic-gate mdb_warn("couldn't add drop handler: %s\n",
11517c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11527c478bd9Sstevel@tonic-gate goto err;
11537c478bd9Sstevel@tonic-gate }
11547c478bd9Sstevel@tonic-gate
11557c478bd9Sstevel@tonic-gate if (dtrace_handle_buffered(dtp, dtrace_dcmdbuffered, NULL) == -1) {
11567c478bd9Sstevel@tonic-gate mdb_warn("couldn't add buffered handler: %s\n",
11577c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11587c478bd9Sstevel@tonic-gate goto err;
11597c478bd9Sstevel@tonic-gate }
11607c478bd9Sstevel@tonic-gate
11617c478bd9Sstevel@tonic-gate if (dtrace_status(dtp) == -1) {
11627c478bd9Sstevel@tonic-gate mdb_warn("couldn't get status: %s\n",
11637c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11647c478bd9Sstevel@tonic-gate goto err;
11657c478bd9Sstevel@tonic-gate }
11667c478bd9Sstevel@tonic-gate
11677c478bd9Sstevel@tonic-gate if (dtrace_aggregate_snap(dtp) == -1) {
11687c478bd9Sstevel@tonic-gate mdb_warn("couldn't snapshot aggregation: %s\n",
11697c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11707c478bd9Sstevel@tonic-gate goto err;
11717c478bd9Sstevel@tonic-gate }
11727c478bd9Sstevel@tonic-gate
11737994dfddSDan Kimmel if ((dd.dtdd_output = tmpfile()) == NULL) {
11747994dfddSDan Kimmel mdb_warn("couldn't open DTrace output file: %d\n", errno);
11757994dfddSDan Kimmel goto err;
11767994dfddSDan Kimmel }
11777994dfddSDan Kimmel
11787994dfddSDan Kimmel if (dtrace_consume(dtp, dd.dtdd_output,
11797c478bd9Sstevel@tonic-gate dtrace_dcmdprobe, dtrace_dcmdrec, &dd) == -1) {
11807c478bd9Sstevel@tonic-gate mdb_warn("couldn't consume DTrace buffers: %s\n",
11817c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11827c478bd9Sstevel@tonic-gate }
11837c478bd9Sstevel@tonic-gate
11847c478bd9Sstevel@tonic-gate if (dtrace_aggregate_print(dtp, NULL, NULL) == -1) {
11857c478bd9Sstevel@tonic-gate mdb_warn("couldn't print aggregation: %s\n",
11867c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp)));
11877c478bd9Sstevel@tonic-gate goto err;
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate
11907c478bd9Sstevel@tonic-gate rval = DCMD_OK;
11917c478bd9Sstevel@tonic-gate err:
11927c478bd9Sstevel@tonic-gate dtrace_close(dtp);
11937994dfddSDan Kimmel fclose(dd.dtdd_output);
11947c478bd9Sstevel@tonic-gate return (rval);
11957c478bd9Sstevel@tonic-gate }
11967c478bd9Sstevel@tonic-gate
11977c478bd9Sstevel@tonic-gate static int
dtrace_errhash_cmp(const void * l,const void * r)11987c478bd9Sstevel@tonic-gate dtrace_errhash_cmp(const void *l, const void *r)
11997c478bd9Sstevel@tonic-gate {
12007c478bd9Sstevel@tonic-gate uintptr_t lhs = *((uintptr_t *)l);
12017c478bd9Sstevel@tonic-gate uintptr_t rhs = *((uintptr_t *)r);
12027c478bd9Sstevel@tonic-gate dtrace_errhash_t lerr, rerr;
12037c478bd9Sstevel@tonic-gate char lmsg[256], rmsg[256];
12047c478bd9Sstevel@tonic-gate
12057c478bd9Sstevel@tonic-gate (void) mdb_vread(&lerr, sizeof (lerr), lhs);
12067c478bd9Sstevel@tonic-gate (void) mdb_vread(&rerr, sizeof (rerr), rhs);
12077c478bd9Sstevel@tonic-gate
12087c478bd9Sstevel@tonic-gate if (lerr.dter_msg == NULL)
12097c478bd9Sstevel@tonic-gate return (-1);
12107c478bd9Sstevel@tonic-gate
12117c478bd9Sstevel@tonic-gate if (rerr.dter_msg == NULL)
12127c478bd9Sstevel@tonic-gate return (1);
12137c478bd9Sstevel@tonic-gate
12147c478bd9Sstevel@tonic-gate (void) mdb_readstr(lmsg, sizeof (lmsg), (uintptr_t)lerr.dter_msg);
12157c478bd9Sstevel@tonic-gate (void) mdb_readstr(rmsg, sizeof (rmsg), (uintptr_t)rerr.dter_msg);
12167c478bd9Sstevel@tonic-gate
12177c478bd9Sstevel@tonic-gate return (strcmp(lmsg, rmsg));
12187c478bd9Sstevel@tonic-gate }
12197c478bd9Sstevel@tonic-gate
12207c478bd9Sstevel@tonic-gate int
dtrace_errhash_init(mdb_walk_state_t * wsp)12217c478bd9Sstevel@tonic-gate dtrace_errhash_init(mdb_walk_state_t *wsp)
12227c478bd9Sstevel@tonic-gate {
12237c478bd9Sstevel@tonic-gate GElf_Sym sym;
12247c478bd9Sstevel@tonic-gate uintptr_t *hash, addr;
12257c478bd9Sstevel@tonic-gate int i;
12267c478bd9Sstevel@tonic-gate
1227892ad162SToomas Soome if (wsp->walk_addr != 0) {
12287c478bd9Sstevel@tonic-gate mdb_warn("dtrace_errhash walk only supports global walks\n");
12297c478bd9Sstevel@tonic-gate return (WALK_ERR);
12307c478bd9Sstevel@tonic-gate }
12317c478bd9Sstevel@tonic-gate
12327c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("dtrace_errhash", &sym) == -1) {
12337c478bd9Sstevel@tonic-gate mdb_warn("couldn't find 'dtrace_errhash' (non-DEBUG kernel?)");
12347c478bd9Sstevel@tonic-gate return (WALK_ERR);
12357c478bd9Sstevel@tonic-gate }
12367c478bd9Sstevel@tonic-gate
12377c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value;
12387c478bd9Sstevel@tonic-gate hash = mdb_alloc(DTRACE_ERRHASHSZ * sizeof (uintptr_t),
12397c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC);
12407c478bd9Sstevel@tonic-gate
12417c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACE_ERRHASHSZ; i++)
12427c478bd9Sstevel@tonic-gate hash[i] = addr + i * sizeof (dtrace_errhash_t);
12437c478bd9Sstevel@tonic-gate
12447c478bd9Sstevel@tonic-gate qsort(hash, DTRACE_ERRHASHSZ, sizeof (uintptr_t), dtrace_errhash_cmp);
12457c478bd9Sstevel@tonic-gate
12467c478bd9Sstevel@tonic-gate wsp->walk_addr = 0;
12477c478bd9Sstevel@tonic-gate wsp->walk_data = hash;
12487c478bd9Sstevel@tonic-gate
12497c478bd9Sstevel@tonic-gate return (WALK_NEXT);
12507c478bd9Sstevel@tonic-gate }
12517c478bd9Sstevel@tonic-gate
12527c478bd9Sstevel@tonic-gate int
dtrace_errhash_step(mdb_walk_state_t * wsp)12537c478bd9Sstevel@tonic-gate dtrace_errhash_step(mdb_walk_state_t *wsp)
12547c478bd9Sstevel@tonic-gate {
12557c478bd9Sstevel@tonic-gate int ndx = (int)wsp->walk_addr;
12567c478bd9Sstevel@tonic-gate uintptr_t *hash = wsp->walk_data;
12577c478bd9Sstevel@tonic-gate dtrace_errhash_t err;
12587c478bd9Sstevel@tonic-gate uintptr_t addr;
12597c478bd9Sstevel@tonic-gate
12607c478bd9Sstevel@tonic-gate if (ndx >= DTRACE_ERRHASHSZ)
12617c478bd9Sstevel@tonic-gate return (WALK_DONE);
12627c478bd9Sstevel@tonic-gate
12637c478bd9Sstevel@tonic-gate wsp->walk_addr = ndx + 1;
12647c478bd9Sstevel@tonic-gate addr = hash[ndx];
12657c478bd9Sstevel@tonic-gate
12667c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) {
12677c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr);
12687c478bd9Sstevel@tonic-gate return (WALK_DONE);
12697c478bd9Sstevel@tonic-gate }
12707c478bd9Sstevel@tonic-gate
12717c478bd9Sstevel@tonic-gate if (err.dter_msg == NULL)
12727c478bd9Sstevel@tonic-gate return (WALK_NEXT);
12737c478bd9Sstevel@tonic-gate
12747c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &err, wsp->walk_cbdata));
12757c478bd9Sstevel@tonic-gate }
12767c478bd9Sstevel@tonic-gate
12777c478bd9Sstevel@tonic-gate /*ARGSUSED*/
12787c478bd9Sstevel@tonic-gate int
dtrace_errhash(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)12797c478bd9Sstevel@tonic-gate dtrace_errhash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
12807c478bd9Sstevel@tonic-gate {
12817c478bd9Sstevel@tonic-gate dtrace_errhash_t err;
12827c478bd9Sstevel@tonic-gate char msg[256];
12837c478bd9Sstevel@tonic-gate
12847c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) {
12857c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_errhash", "dtrace_errhash",
12867c478bd9Sstevel@tonic-gate argc, argv) == -1) {
12877c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_errhash'");
12887c478bd9Sstevel@tonic-gate return (DCMD_ERR);
12897c478bd9Sstevel@tonic-gate }
12907c478bd9Sstevel@tonic-gate
12917c478bd9Sstevel@tonic-gate return (DCMD_OK);
12927c478bd9Sstevel@tonic-gate }
12937c478bd9Sstevel@tonic-gate
12947c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags))
12957c478bd9Sstevel@tonic-gate mdb_printf("%8s %s\n", "COUNT", "ERROR");
12967c478bd9Sstevel@tonic-gate
12977c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) {
12987c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr);
12997c478bd9Sstevel@tonic-gate return (DCMD_ERR);
13007c478bd9Sstevel@tonic-gate }
13017c478bd9Sstevel@tonic-gate
13027c478bd9Sstevel@tonic-gate addr = (uintptr_t)err.dter_msg;
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate if (mdb_readstr(msg, sizeof (msg), addr) == -1) {
13057c478bd9Sstevel@tonic-gate mdb_warn("failed to read error msg at %p", addr);
13067c478bd9Sstevel@tonic-gate return (DCMD_ERR);
13077c478bd9Sstevel@tonic-gate }
13087c478bd9Sstevel@tonic-gate
13097c478bd9Sstevel@tonic-gate mdb_printf("%8d %s", err.dter_count, msg);
13107c478bd9Sstevel@tonic-gate
13117c478bd9Sstevel@tonic-gate /*
13127c478bd9Sstevel@tonic-gate * Some error messages include a newline -- only print the newline
13137c478bd9Sstevel@tonic-gate * if the message doesn't have one.
13147c478bd9Sstevel@tonic-gate */
13157c478bd9Sstevel@tonic-gate if (msg[strlen(msg) - 1] != '\n')
13167c478bd9Sstevel@tonic-gate mdb_printf("\n");
13177c478bd9Sstevel@tonic-gate
13187c478bd9Sstevel@tonic-gate return (DCMD_OK);
13197c478bd9Sstevel@tonic-gate }
13207c478bd9Sstevel@tonic-gate
13217c478bd9Sstevel@tonic-gate int
dtrace_helptrace_init(mdb_walk_state_t * wsp)13227c478bd9Sstevel@tonic-gate dtrace_helptrace_init(mdb_walk_state_t *wsp)
13237c478bd9Sstevel@tonic-gate {
13247c478bd9Sstevel@tonic-gate uint32_t next;
1325902686d1SBryan Cantrill uintptr_t buffer;
13267c478bd9Sstevel@tonic-gate
1327892ad162SToomas Soome if (wsp->walk_addr != 0) {
13287c478bd9Sstevel@tonic-gate mdb_warn("dtrace_helptrace only supports global walks\n");
13297c478bd9Sstevel@tonic-gate return (WALK_ERR);
13307c478bd9Sstevel@tonic-gate }
13317c478bd9Sstevel@tonic-gate
1332902686d1SBryan Cantrill if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) {
1333902686d1SBryan Cantrill mdb_warn("couldn't read 'dtrace_helptrace_buffer'");
13347c478bd9Sstevel@tonic-gate return (WALK_ERR);
13357c478bd9Sstevel@tonic-gate }
13367c478bd9Sstevel@tonic-gate
1337892ad162SToomas Soome if (buffer == 0) {
13387c478bd9Sstevel@tonic-gate mdb_warn("helper tracing is not enabled\n");
13397c478bd9Sstevel@tonic-gate return (WALK_ERR);
13407c478bd9Sstevel@tonic-gate }
13417c478bd9Sstevel@tonic-gate
13427c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) {
13437c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'");
13447c478bd9Sstevel@tonic-gate return (WALK_ERR);
13457c478bd9Sstevel@tonic-gate }
13467c478bd9Sstevel@tonic-gate
13477c478bd9Sstevel@tonic-gate wsp->walk_addr = next;
13487c478bd9Sstevel@tonic-gate
13497c478bd9Sstevel@tonic-gate return (WALK_NEXT);
13507c478bd9Sstevel@tonic-gate }
13517c478bd9Sstevel@tonic-gate
13527c478bd9Sstevel@tonic-gate int
dtrace_helptrace_step(mdb_walk_state_t * wsp)13537c478bd9Sstevel@tonic-gate dtrace_helptrace_step(mdb_walk_state_t *wsp)
13547c478bd9Sstevel@tonic-gate {
13557c478bd9Sstevel@tonic-gate uint32_t next, size, nlocals, bufsize;
13567c478bd9Sstevel@tonic-gate uintptr_t buffer, addr;
13577c478bd9Sstevel@tonic-gate dtrace_helptrace_t *ht;
13587c478bd9Sstevel@tonic-gate int rval;
13597c478bd9Sstevel@tonic-gate
13607c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) {
13617c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'");
13627c478bd9Sstevel@tonic-gate return (WALK_ERR);
13637c478bd9Sstevel@tonic-gate }
13647c478bd9Sstevel@tonic-gate
13657c478bd9Sstevel@tonic-gate if (mdb_readvar(&bufsize, "dtrace_helptrace_bufsize") == -1) {
13667c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_bufsize'");
13677c478bd9Sstevel@tonic-gate return (WALK_ERR);
13687c478bd9Sstevel@tonic-gate }
13697c478bd9Sstevel@tonic-gate
13707c478bd9Sstevel@tonic-gate if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) {
13717c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_buffer'");
13727c478bd9Sstevel@tonic-gate return (WALK_ERR);
13737c478bd9Sstevel@tonic-gate }
13747c478bd9Sstevel@tonic-gate
13757c478bd9Sstevel@tonic-gate if (mdb_readvar(&nlocals, "dtrace_helptrace_nlocals") == -1) {
13767c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_nlocals'");
13777c478bd9Sstevel@tonic-gate return (WALK_ERR);
13787c478bd9Sstevel@tonic-gate }
13797c478bd9Sstevel@tonic-gate
13807c478bd9Sstevel@tonic-gate size = sizeof (dtrace_helptrace_t) +
13817c478bd9Sstevel@tonic-gate nlocals * sizeof (uint64_t) - sizeof (uint64_t);
13827c478bd9Sstevel@tonic-gate
13837c478bd9Sstevel@tonic-gate if (wsp->walk_addr + size > bufsize) {
13847c478bd9Sstevel@tonic-gate if (next == 0)
13857c478bd9Sstevel@tonic-gate return (WALK_DONE);
13867c478bd9Sstevel@tonic-gate
13877c478bd9Sstevel@tonic-gate wsp->walk_addr = 0;
13887c478bd9Sstevel@tonic-gate }
13897c478bd9Sstevel@tonic-gate
13907c478bd9Sstevel@tonic-gate addr = buffer + wsp->walk_addr;
13917c478bd9Sstevel@tonic-gate ht = alloca(size);
13927c478bd9Sstevel@tonic-gate
13937c478bd9Sstevel@tonic-gate if (mdb_vread(ht, size, addr) == -1) {
13947c478bd9Sstevel@tonic-gate mdb_warn("couldn't read entry at %p", addr);
13957c478bd9Sstevel@tonic-gate return (WALK_ERR);
13967c478bd9Sstevel@tonic-gate }
13977c478bd9Sstevel@tonic-gate
13987c478bd9Sstevel@tonic-gate if (ht->dtht_helper != NULL) {
13997c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(addr, ht, wsp->walk_cbdata);
14007c478bd9Sstevel@tonic-gate
14017c478bd9Sstevel@tonic-gate if (rval != WALK_NEXT)
14027c478bd9Sstevel@tonic-gate return (rval);
14037c478bd9Sstevel@tonic-gate }
14047c478bd9Sstevel@tonic-gate
14057c478bd9Sstevel@tonic-gate if (wsp->walk_addr < next && wsp->walk_addr + size >= next)
14067c478bd9Sstevel@tonic-gate return (WALK_DONE);
14077c478bd9Sstevel@tonic-gate
14087c478bd9Sstevel@tonic-gate wsp->walk_addr += size;
14097c478bd9Sstevel@tonic-gate return (WALK_NEXT);
14107c478bd9Sstevel@tonic-gate }
14117c478bd9Sstevel@tonic-gate
14127c478bd9Sstevel@tonic-gate int
dtrace_helptrace(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)14137c478bd9Sstevel@tonic-gate dtrace_helptrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
14147c478bd9Sstevel@tonic-gate {
14157c478bd9Sstevel@tonic-gate dtrace_helptrace_t help;
14167c478bd9Sstevel@tonic-gate dtrace_helper_action_t helper;
14177c478bd9Sstevel@tonic-gate char where[30];
14187c478bd9Sstevel@tonic-gate uint_t opt_v = FALSE;
14197c478bd9Sstevel@tonic-gate uintptr_t haddr;
14207c478bd9Sstevel@tonic-gate
14217c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) {
14227c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_helptrace", "dtrace_helptrace",
14237c478bd9Sstevel@tonic-gate argc, argv) == -1) {
14247c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_helptrace'");
14257c478bd9Sstevel@tonic-gate return (DCMD_ERR);
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate
14287c478bd9Sstevel@tonic-gate return (DCMD_OK);
14297c478bd9Sstevel@tonic-gate }
14307c478bd9Sstevel@tonic-gate
14317c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'v',
14327c478bd9Sstevel@tonic-gate MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
14337c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
14347c478bd9Sstevel@tonic-gate
14357c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) {
14367c478bd9Sstevel@tonic-gate mdb_printf(" %?s %?s %12s %s\n",
14377c478bd9Sstevel@tonic-gate "ADDR", "HELPER", "WHERE", "DIFO");
14387c478bd9Sstevel@tonic-gate }
14397c478bd9Sstevel@tonic-gate
14407c478bd9Sstevel@tonic-gate if (mdb_vread(&help, sizeof (help), addr) == -1) {
14417c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_helptrace_t at %p", addr);
14427c478bd9Sstevel@tonic-gate return (DCMD_ERR);
14437c478bd9Sstevel@tonic-gate }
14447c478bd9Sstevel@tonic-gate
14457c478bd9Sstevel@tonic-gate switch (help.dtht_where) {
14467c478bd9Sstevel@tonic-gate case 0:
14477c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "predicate");
14487c478bd9Sstevel@tonic-gate break;
14497c478bd9Sstevel@tonic-gate
14507c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT:
14517c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "next");
14527c478bd9Sstevel@tonic-gate break;
14537c478bd9Sstevel@tonic-gate
14547c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE:
14557c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "done");
14567c478bd9Sstevel@tonic-gate break;
14577c478bd9Sstevel@tonic-gate
14587c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR:
14597c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "err");
14607c478bd9Sstevel@tonic-gate break;
14617c478bd9Sstevel@tonic-gate
14627c478bd9Sstevel@tonic-gate default:
14637c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where),
14647c478bd9Sstevel@tonic-gate "action #%d", help.dtht_where);
14657c478bd9Sstevel@tonic-gate break;
14667c478bd9Sstevel@tonic-gate }
14677c478bd9Sstevel@tonic-gate
14687c478bd9Sstevel@tonic-gate mdb_printf(" %?p %?p %12s ", addr, help.dtht_helper, where);
14697c478bd9Sstevel@tonic-gate
14707c478bd9Sstevel@tonic-gate haddr = (uintptr_t)help.dtht_helper;
14717c478bd9Sstevel@tonic-gate
14727c478bd9Sstevel@tonic-gate if (mdb_vread(&helper, sizeof (helper), haddr) == -1) {
14737c478bd9Sstevel@tonic-gate /*
14747c478bd9Sstevel@tonic-gate * We're not going to warn in this case -- we're just not going
14757c478bd9Sstevel@tonic-gate * to print anything exciting.
14767c478bd9Sstevel@tonic-gate */
14777c478bd9Sstevel@tonic-gate mdb_printf("???\n");
14787c478bd9Sstevel@tonic-gate } else {
14797c478bd9Sstevel@tonic-gate switch (help.dtht_where) {
14807c478bd9Sstevel@tonic-gate case 0:
148199fd1a49Sahl mdb_printf("%p\n", helper.dtha_predicate);
14827c478bd9Sstevel@tonic-gate break;
14837c478bd9Sstevel@tonic-gate
14847c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT:
14857c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE:
14867c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR:
14877c478bd9Sstevel@tonic-gate mdb_printf("-\n");
14887c478bd9Sstevel@tonic-gate break;
14897c478bd9Sstevel@tonic-gate
14907c478bd9Sstevel@tonic-gate default:
149199fd1a49Sahl haddr = (uintptr_t)helper.dtha_actions +
14927c478bd9Sstevel@tonic-gate (help.dtht_where - 1) * sizeof (uintptr_t);
14937c478bd9Sstevel@tonic-gate
14947c478bd9Sstevel@tonic-gate if (mdb_vread(&haddr, sizeof (haddr), haddr) == -1) {
14957c478bd9Sstevel@tonic-gate mdb_printf("???\n");
14967c478bd9Sstevel@tonic-gate } else {
14977c478bd9Sstevel@tonic-gate mdb_printf("%p\n", haddr);
14987c478bd9Sstevel@tonic-gate }
14997c478bd9Sstevel@tonic-gate }
15007c478bd9Sstevel@tonic-gate }
15017c478bd9Sstevel@tonic-gate
15027c478bd9Sstevel@tonic-gate if (opt_v) {
15037c478bd9Sstevel@tonic-gate int i;
15047c478bd9Sstevel@tonic-gate
1505187eccf8Sbmc if (help.dtht_where == DTRACE_HELPTRACE_ERR) {
1506187eccf8Sbmc int f = help.dtht_fault;
1507187eccf8Sbmc
1508187eccf8Sbmc mdb_printf("%?s| %?s %10s |\n", "", "", "");
1509187eccf8Sbmc mdb_printf("%?s| %?s %10s +-> fault: %s\n", "", "", "",
1510187eccf8Sbmc f == DTRACEFLT_BADADDR ? "BADADDR" :
1511187eccf8Sbmc f == DTRACEFLT_BADALIGN ? "BADALIGN" :
1512187eccf8Sbmc f == DTRACEFLT_ILLOP ? "ILLOP" :
1513187eccf8Sbmc f == DTRACEFLT_DIVZERO ? "DIVZERO" :
1514187eccf8Sbmc f == DTRACEFLT_NOSCRATCH ? "NOSCRATCH" :
1515187eccf8Sbmc f == DTRACEFLT_KPRIV ? "KPRIV" :
1516187eccf8Sbmc f == DTRACEFLT_UPRIV ? "UPRIV" :
1517187eccf8Sbmc f == DTRACEFLT_TUPOFLOW ? "TUPOFLOW" :
1518b8fac8e1Sjhaslam f == DTRACEFLT_BADSTACK ? "BADSTACK" :
1519187eccf8Sbmc "DTRACEFLT_UNKNOWN");
1520187eccf8Sbmc mdb_printf("%?s| %?s %12s addr: 0x%x\n", "", "", "",
1521187eccf8Sbmc help.dtht_illval);
1522187eccf8Sbmc mdb_printf("%?s| %?s %12s offset: %d\n", "", "", "",
1523187eccf8Sbmc help.dtht_fltoffs);
1524187eccf8Sbmc }
1525187eccf8Sbmc
15267c478bd9Sstevel@tonic-gate mdb_printf("%?s|\n%?s+--> %?s %4s %s\n", "", "",
15277c478bd9Sstevel@tonic-gate "ADDR", "NDX", "VALUE");
15287c478bd9Sstevel@tonic-gate addr += sizeof (help) - sizeof (uint64_t);
15297c478bd9Sstevel@tonic-gate
15307c478bd9Sstevel@tonic-gate for (i = 0; i < help.dtht_nlocals; i++) {
15317c478bd9Sstevel@tonic-gate uint64_t val;
15327c478bd9Sstevel@tonic-gate
15337c478bd9Sstevel@tonic-gate if (mdb_vread(&val, sizeof (val), addr) == -1) {
15347c478bd9Sstevel@tonic-gate mdb_warn("couldn't read local at %p", addr);
15357c478bd9Sstevel@tonic-gate continue;
15367c478bd9Sstevel@tonic-gate }
15377c478bd9Sstevel@tonic-gate
15387c478bd9Sstevel@tonic-gate mdb_printf("%?s %?p %4d %p\n", "", addr, i, val);
15397c478bd9Sstevel@tonic-gate addr += sizeof (uint64_t);
15407c478bd9Sstevel@tonic-gate }
15417c478bd9Sstevel@tonic-gate
15427c478bd9Sstevel@tonic-gate mdb_printf("\n");
15437c478bd9Sstevel@tonic-gate }
15447c478bd9Sstevel@tonic-gate
15457c478bd9Sstevel@tonic-gate return (DCMD_OK);
15467c478bd9Sstevel@tonic-gate }
15477c478bd9Sstevel@tonic-gate
15487c478bd9Sstevel@tonic-gate /*ARGSUSED*/
15497c478bd9Sstevel@tonic-gate static int
dtrace_state_walk(uintptr_t addr,const vmem_seg_t * seg,minor_t * highest)15507c478bd9Sstevel@tonic-gate dtrace_state_walk(uintptr_t addr, const vmem_seg_t *seg, minor_t *highest)
15517c478bd9Sstevel@tonic-gate {
15527c478bd9Sstevel@tonic-gate if (seg->vs_end > *highest)
15537c478bd9Sstevel@tonic-gate *highest = seg->vs_end;
15547c478bd9Sstevel@tonic-gate
15557c478bd9Sstevel@tonic-gate return (WALK_NEXT);
15567c478bd9Sstevel@tonic-gate }
15577c478bd9Sstevel@tonic-gate
15587c478bd9Sstevel@tonic-gate typedef struct dtrace_state_walk {
15597c478bd9Sstevel@tonic-gate uintptr_t dtsw_softstate;
15607c478bd9Sstevel@tonic-gate minor_t dtsw_max;
15617c478bd9Sstevel@tonic-gate minor_t dtsw_current;
15627c478bd9Sstevel@tonic-gate } dtrace_state_walk_t;
15637c478bd9Sstevel@tonic-gate
15647c478bd9Sstevel@tonic-gate int
dtrace_state_init(mdb_walk_state_t * wsp)15657c478bd9Sstevel@tonic-gate dtrace_state_init(mdb_walk_state_t *wsp)
15667c478bd9Sstevel@tonic-gate {
15677c478bd9Sstevel@tonic-gate uintptr_t dtrace_minor;
15687c478bd9Sstevel@tonic-gate minor_t max = 0;
15697c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw;
15707c478bd9Sstevel@tonic-gate
1571892ad162SToomas Soome if (wsp->walk_addr != 0) {
15727c478bd9Sstevel@tonic-gate mdb_warn("dtrace_state only supports global walks\n");
15737c478bd9Sstevel@tonic-gate return (WALK_ERR);
15747c478bd9Sstevel@tonic-gate }
15757c478bd9Sstevel@tonic-gate
15767c478bd9Sstevel@tonic-gate /*
15777c478bd9Sstevel@tonic-gate * Find the dtrace_minor vmem arena and walk it to get the maximum
15787c478bd9Sstevel@tonic-gate * minor number.
15797c478bd9Sstevel@tonic-gate */
15807c478bd9Sstevel@tonic-gate if (mdb_readvar(&dtrace_minor, "dtrace_minor") == -1) {
15817c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_minor'");
15827c478bd9Sstevel@tonic-gate return (WALK_ERR);
15837c478bd9Sstevel@tonic-gate }
15847c478bd9Sstevel@tonic-gate
15857c478bd9Sstevel@tonic-gate if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)dtrace_state_walk,
15867c478bd9Sstevel@tonic-gate &max, dtrace_minor) == -1) {
15877c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'vmem_alloc'");
15887c478bd9Sstevel@tonic-gate return (WALK_ERR);
15897c478bd9Sstevel@tonic-gate }
15907c478bd9Sstevel@tonic-gate
15917c478bd9Sstevel@tonic-gate dw = mdb_zalloc(sizeof (dtrace_state_walk_t), UM_SLEEP | UM_GC);
15927c478bd9Sstevel@tonic-gate dw->dtsw_current = 0;
15937c478bd9Sstevel@tonic-gate dw->dtsw_max = max;
15947c478bd9Sstevel@tonic-gate
15957c478bd9Sstevel@tonic-gate if (mdb_readvar(&dw->dtsw_softstate, "dtrace_softstate") == -1) {
15967c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'");
15977c478bd9Sstevel@tonic-gate return (DCMD_ERR);
15987c478bd9Sstevel@tonic-gate }
15997c478bd9Sstevel@tonic-gate
16007c478bd9Sstevel@tonic-gate wsp->walk_data = dw;
16017c478bd9Sstevel@tonic-gate
16027c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16037c478bd9Sstevel@tonic-gate }
16047c478bd9Sstevel@tonic-gate
16057c478bd9Sstevel@tonic-gate int
dtrace_state_step(mdb_walk_state_t * wsp)16067c478bd9Sstevel@tonic-gate dtrace_state_step(mdb_walk_state_t *wsp)
16077c478bd9Sstevel@tonic-gate {
16087c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw = wsp->walk_data;
16097c478bd9Sstevel@tonic-gate uintptr_t statep;
16107c478bd9Sstevel@tonic-gate dtrace_state_t state;
16117c478bd9Sstevel@tonic-gate int rval;
16127c478bd9Sstevel@tonic-gate
16137c478bd9Sstevel@tonic-gate while (mdb_get_soft_state_byaddr(dw->dtsw_softstate, dw->dtsw_current,
16147c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) {
16157c478bd9Sstevel@tonic-gate if (dw->dtsw_current >= dw->dtsw_max)
16167c478bd9Sstevel@tonic-gate return (WALK_DONE);
16177c478bd9Sstevel@tonic-gate
16187c478bd9Sstevel@tonic-gate dw->dtsw_current++;
16197c478bd9Sstevel@tonic-gate }
16207c478bd9Sstevel@tonic-gate
16217c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), statep) == -1) {
16227c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", statep);
16237c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16247c478bd9Sstevel@tonic-gate }
16257c478bd9Sstevel@tonic-gate
16267c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(statep, &state, wsp->walk_cbdata);
16277c478bd9Sstevel@tonic-gate dw->dtsw_current++;
16287c478bd9Sstevel@tonic-gate
16297c478bd9Sstevel@tonic-gate return (rval);
16307c478bd9Sstevel@tonic-gate }
16317c478bd9Sstevel@tonic-gate
16327c478bd9Sstevel@tonic-gate typedef struct dtrace_state_data {
16337c478bd9Sstevel@tonic-gate int dtsd_major;
16347c478bd9Sstevel@tonic-gate uintptr_t dtsd_proc;
16357c478bd9Sstevel@tonic-gate uintptr_t dtsd_softstate;
16367c478bd9Sstevel@tonic-gate uintptr_t dtsd_state;
16377c478bd9Sstevel@tonic-gate } dtrace_state_data_t;
16387c478bd9Sstevel@tonic-gate
16397c478bd9Sstevel@tonic-gate static int
dtrace_state_file(uintptr_t addr,struct file * f,dtrace_state_data_t * data)16407c478bd9Sstevel@tonic-gate dtrace_state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data)
16417c478bd9Sstevel@tonic-gate {
16427c478bd9Sstevel@tonic-gate vnode_t vnode;
16437c478bd9Sstevel@tonic-gate proc_t proc;
16447c478bd9Sstevel@tonic-gate minor_t minor;
16457c478bd9Sstevel@tonic-gate uintptr_t statep;
16467c478bd9Sstevel@tonic-gate
16477c478bd9Sstevel@tonic-gate if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) {
16487c478bd9Sstevel@tonic-gate mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode);
16497c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16507c478bd9Sstevel@tonic-gate }
16517c478bd9Sstevel@tonic-gate
16527c478bd9Sstevel@tonic-gate if (getmajor(vnode.v_rdev) != data->dtsd_major)
16537c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16547c478bd9Sstevel@tonic-gate
16557c478bd9Sstevel@tonic-gate minor = getminor(vnode.v_rdev);
16567c478bd9Sstevel@tonic-gate
16577c478bd9Sstevel@tonic-gate if (mdb_vread(&proc, sizeof (proc), data->dtsd_proc) == -1) {
16587c478bd9Sstevel@tonic-gate mdb_warn("failed to read proc at %p", data->dtsd_proc);
16597c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16607c478bd9Sstevel@tonic-gate }
16617c478bd9Sstevel@tonic-gate
16627c478bd9Sstevel@tonic-gate if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor,
16637c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) {
16647c478bd9Sstevel@tonic-gate mdb_warn("failed to read softstate for minor %d", minor);
16657c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16667c478bd9Sstevel@tonic-gate }
16677c478bd9Sstevel@tonic-gate
16687c478bd9Sstevel@tonic-gate if (statep != data->dtsd_state)
16697c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16707c478bd9Sstevel@tonic-gate
16717c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?p %-*s %?p\n", statep, minor,
16727c478bd9Sstevel@tonic-gate data->dtsd_proc, MAXCOMLEN, proc.p_user.u_comm, addr);
16737c478bd9Sstevel@tonic-gate
16747c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16757c478bd9Sstevel@tonic-gate }
16767c478bd9Sstevel@tonic-gate
16777c478bd9Sstevel@tonic-gate /*ARGSUSED*/
16787c478bd9Sstevel@tonic-gate static int
dtrace_state_proc(uintptr_t addr,void * ignored,dtrace_state_data_t * data)16797c478bd9Sstevel@tonic-gate dtrace_state_proc(uintptr_t addr, void *ignored, dtrace_state_data_t *data)
16807c478bd9Sstevel@tonic-gate {
16817c478bd9Sstevel@tonic-gate data->dtsd_proc = addr;
16827c478bd9Sstevel@tonic-gate
16837c478bd9Sstevel@tonic-gate if (mdb_pwalk("file",
16847c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_state_file, data, addr) == -1) {
16857c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'file' for proc %p", addr);
16867c478bd9Sstevel@tonic-gate return (WALK_ERR);
16877c478bd9Sstevel@tonic-gate }
16887c478bd9Sstevel@tonic-gate
16897c478bd9Sstevel@tonic-gate return (WALK_NEXT);
16907c478bd9Sstevel@tonic-gate }
16917c478bd9Sstevel@tonic-gate
16927c478bd9Sstevel@tonic-gate void
dtrace_state_help(void)16937c478bd9Sstevel@tonic-gate dtrace_state_help(void)
16947c478bd9Sstevel@tonic-gate {
16957c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure, displays all "
16967c478bd9Sstevel@tonic-gate /*CSTYLED*/
16977c478bd9Sstevel@tonic-gate "consumers, or \"<anonymous>\"\nif the consumer is anonymous. If "
16987c478bd9Sstevel@tonic-gate "no state structure is provided, iterates\nover all state "
16997c478bd9Sstevel@tonic-gate "structures.\n\n"
17007c478bd9Sstevel@tonic-gate "Addresses in ADDR column may be provided to ::dtrace to obtain\n"
1701bbf21555SRichard Lowe "dtrace(8)-like output for in-kernel DTrace data.\n");
17027c478bd9Sstevel@tonic-gate }
17037c478bd9Sstevel@tonic-gate
17047c478bd9Sstevel@tonic-gate int
dtrace_state(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)17057c478bd9Sstevel@tonic-gate dtrace_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17067c478bd9Sstevel@tonic-gate {
17077c478bd9Sstevel@tonic-gate uintptr_t devi;
17087c478bd9Sstevel@tonic-gate struct dev_info info;
17097c478bd9Sstevel@tonic-gate dtrace_state_data_t data;
17107c478bd9Sstevel@tonic-gate dtrace_anon_t anon;
17117c478bd9Sstevel@tonic-gate dtrace_state_t state;
17127c478bd9Sstevel@tonic-gate
17137c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) {
17147c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_state",
17157c478bd9Sstevel@tonic-gate "dtrace_state", argc, argv) == -1) {
17167c478bd9Sstevel@tonic-gate mdb_warn("can't walk dtrace_state");
17177c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17187c478bd9Sstevel@tonic-gate }
17197c478bd9Sstevel@tonic-gate return (DCMD_OK);
17207c478bd9Sstevel@tonic-gate }
17217c478bd9Sstevel@tonic-gate
17227c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) {
17237c478bd9Sstevel@tonic-gate mdb_printf("%?s %5s %?s %-*s %?s\n", "ADDR", "MINOR", "PROC",
17247c478bd9Sstevel@tonic-gate MAXCOMLEN, "NAME", "FILE");
17257c478bd9Sstevel@tonic-gate }
17267c478bd9Sstevel@tonic-gate
17277c478bd9Sstevel@tonic-gate /*
17287c478bd9Sstevel@tonic-gate * First determine if this is anonymous state.
17297c478bd9Sstevel@tonic-gate */
17307c478bd9Sstevel@tonic-gate if (mdb_readvar(&anon, "dtrace_anon") == -1) {
17317c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_anon'");
17327c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17337c478bd9Sstevel@tonic-gate }
17347c478bd9Sstevel@tonic-gate
17357c478bd9Sstevel@tonic-gate if ((uintptr_t)anon.dta_state == addr) {
17367c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) {
17377c478bd9Sstevel@tonic-gate mdb_warn("failed to read anon at %p", addr);
17387c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17397c478bd9Sstevel@tonic-gate }
17407c478bd9Sstevel@tonic-gate
17417c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?s %-*s %?s\n", addr,
17427c478bd9Sstevel@tonic-gate getminor(state.dts_dev), "-", MAXCOMLEN,
17437c478bd9Sstevel@tonic-gate "<anonymous>", "-");
17447c478bd9Sstevel@tonic-gate
17457c478bd9Sstevel@tonic-gate return (DCMD_OK);
17467c478bd9Sstevel@tonic-gate }
17477c478bd9Sstevel@tonic-gate
17487c478bd9Sstevel@tonic-gate if (mdb_readvar(&devi, "dtrace_devi") == -1) {
17497c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_devi'");
17507c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17517c478bd9Sstevel@tonic-gate }
17527c478bd9Sstevel@tonic-gate
17537c478bd9Sstevel@tonic-gate if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) {
17547c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dev_info'");
17557c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17567c478bd9Sstevel@tonic-gate }
17577c478bd9Sstevel@tonic-gate
17587c478bd9Sstevel@tonic-gate data.dtsd_major = info.devi_major;
17597c478bd9Sstevel@tonic-gate
17607c478bd9Sstevel@tonic-gate if (mdb_readvar(&data.dtsd_softstate, "dtrace_softstate") == -1) {
17617c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'");
17627c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17637c478bd9Sstevel@tonic-gate }
17647c478bd9Sstevel@tonic-gate
17657c478bd9Sstevel@tonic-gate data.dtsd_state = addr;
17667c478bd9Sstevel@tonic-gate
17677c478bd9Sstevel@tonic-gate /*
17687c478bd9Sstevel@tonic-gate * Walk through all processes and all open files looking for this
17697c478bd9Sstevel@tonic-gate * state. It must be open somewhere...
17707c478bd9Sstevel@tonic-gate */
17717c478bd9Sstevel@tonic-gate if (mdb_walk("proc", (mdb_walk_cb_t)dtrace_state_proc, &data) == -1) {
17727c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'proc'");
17737c478bd9Sstevel@tonic-gate return (DCMD_ERR);
17747c478bd9Sstevel@tonic-gate }
17757c478bd9Sstevel@tonic-gate
17767c478bd9Sstevel@tonic-gate return (DCMD_OK);
17777c478bd9Sstevel@tonic-gate }
17787c478bd9Sstevel@tonic-gate
17797c478bd9Sstevel@tonic-gate typedef struct dtrace_aggkey_data {
17807c478bd9Sstevel@tonic-gate uintptr_t *dtakd_hash;
17817c478bd9Sstevel@tonic-gate uintptr_t dtakd_hashsize;
17827c478bd9Sstevel@tonic-gate uintptr_t dtakd_next;
17837c478bd9Sstevel@tonic-gate uintptr_t dtakd_ndx;
17847c478bd9Sstevel@tonic-gate } dtrace_aggkey_data_t;
17857c478bd9Sstevel@tonic-gate
17867c478bd9Sstevel@tonic-gate int
dtrace_aggkey_init(mdb_walk_state_t * wsp)17877c478bd9Sstevel@tonic-gate dtrace_aggkey_init(mdb_walk_state_t *wsp)
17887c478bd9Sstevel@tonic-gate {
17897c478bd9Sstevel@tonic-gate dtrace_buffer_t buf;
17907c478bd9Sstevel@tonic-gate uintptr_t addr;
17917c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb;
17927c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data;
17937c478bd9Sstevel@tonic-gate size_t hsize;
17947c478bd9Sstevel@tonic-gate
1795892ad162SToomas Soome if ((addr = wsp->walk_addr) == 0) {
17967c478bd9Sstevel@tonic-gate mdb_warn("dtrace_aggkey walk needs aggregation buffer\n");
17977c478bd9Sstevel@tonic-gate return (WALK_ERR);
17987c478bd9Sstevel@tonic-gate }
17997c478bd9Sstevel@tonic-gate
18007c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
18017c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr);
18027c478bd9Sstevel@tonic-gate return (WALK_ERR);
18037c478bd9Sstevel@tonic-gate }
18047c478bd9Sstevel@tonic-gate
18057c478bd9Sstevel@tonic-gate addr = (uintptr_t)buf.dtb_tomax +
18067c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t);
18077c478bd9Sstevel@tonic-gate
18087c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), addr) == -1) {
18097c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", addr);
18107c478bd9Sstevel@tonic-gate return (WALK_ERR);
18117c478bd9Sstevel@tonic-gate }
18127c478bd9Sstevel@tonic-gate
18137c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_aggkey_data_t), UM_SLEEP);
18147c478bd9Sstevel@tonic-gate
18157c478bd9Sstevel@tonic-gate data->dtakd_hashsize = agb.dtagb_hashsize;
18167c478bd9Sstevel@tonic-gate hsize = agb.dtagb_hashsize * sizeof (dtrace_aggkey_t *);
18177c478bd9Sstevel@tonic-gate data->dtakd_hash = mdb_alloc(hsize, UM_SLEEP);
18187c478bd9Sstevel@tonic-gate
18197c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtakd_hash, hsize,
18207c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash) == -1) {
18217c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p",
18227c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash);
18237c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize);
18247c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t));
18257c478bd9Sstevel@tonic-gate return (WALK_ERR);
18267c478bd9Sstevel@tonic-gate }
18277c478bd9Sstevel@tonic-gate
18287c478bd9Sstevel@tonic-gate wsp->walk_data = data;
18297c478bd9Sstevel@tonic-gate return (WALK_NEXT);
18307c478bd9Sstevel@tonic-gate }
18317c478bd9Sstevel@tonic-gate
18327c478bd9Sstevel@tonic-gate int
dtrace_aggkey_step(mdb_walk_state_t * wsp)18337c478bd9Sstevel@tonic-gate dtrace_aggkey_step(mdb_walk_state_t *wsp)
18347c478bd9Sstevel@tonic-gate {
18357c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data;
18367c478bd9Sstevel@tonic-gate dtrace_aggkey_t key;
18377c478bd9Sstevel@tonic-gate uintptr_t addr;
18387c478bd9Sstevel@tonic-gate
1839892ad162SToomas Soome while ((addr = data->dtakd_next) == 0) {
18407c478bd9Sstevel@tonic-gate if (data->dtakd_ndx == data->dtakd_hashsize)
18417c478bd9Sstevel@tonic-gate return (WALK_DONE);
18427c478bd9Sstevel@tonic-gate
18437c478bd9Sstevel@tonic-gate data->dtakd_next = data->dtakd_hash[data->dtakd_ndx++];
18447c478bd9Sstevel@tonic-gate }
18457c478bd9Sstevel@tonic-gate
18467c478bd9Sstevel@tonic-gate if (mdb_vread(&key, sizeof (key), addr) == -1) {
18477c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggkey_t at %p", addr);
18487c478bd9Sstevel@tonic-gate return (WALK_ERR);
18497c478bd9Sstevel@tonic-gate }
18507c478bd9Sstevel@tonic-gate
18517c478bd9Sstevel@tonic-gate data->dtakd_next = (uintptr_t)key.dtak_next;
18527c478bd9Sstevel@tonic-gate
18537c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &key, wsp->walk_cbdata));
18547c478bd9Sstevel@tonic-gate }
18557c478bd9Sstevel@tonic-gate
18567c478bd9Sstevel@tonic-gate void
dtrace_aggkey_fini(mdb_walk_state_t * wsp)18577c478bd9Sstevel@tonic-gate dtrace_aggkey_fini(mdb_walk_state_t *wsp)
18587c478bd9Sstevel@tonic-gate {
18597c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data;
18607c478bd9Sstevel@tonic-gate size_t hsize;
18617c478bd9Sstevel@tonic-gate
18627c478bd9Sstevel@tonic-gate hsize = data->dtakd_hashsize * sizeof (dtrace_aggkey_t *);
18637c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize);
18647c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t));
18657c478bd9Sstevel@tonic-gate }
18667c478bd9Sstevel@tonic-gate
18677c478bd9Sstevel@tonic-gate typedef struct dtrace_dynvar_data {
18687c478bd9Sstevel@tonic-gate dtrace_dynhash_t *dtdvd_hash;
18697c478bd9Sstevel@tonic-gate uintptr_t dtdvd_hashsize;
18707c478bd9Sstevel@tonic-gate uintptr_t dtdvd_next;
18717c478bd9Sstevel@tonic-gate uintptr_t dtdvd_ndx;
1872c9a6ea2eSBryan Cantrill uintptr_t dtdvd_sink;
18737c478bd9Sstevel@tonic-gate } dtrace_dynvar_data_t;
18747c478bd9Sstevel@tonic-gate
18757c478bd9Sstevel@tonic-gate int
dtrace_dynvar_init(mdb_walk_state_t * wsp)18767c478bd9Sstevel@tonic-gate dtrace_dynvar_init(mdb_walk_state_t *wsp)
18777c478bd9Sstevel@tonic-gate {
18787c478bd9Sstevel@tonic-gate uintptr_t addr;
18797c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate;
18807c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data;
18817c478bd9Sstevel@tonic-gate size_t hsize;
1882c9a6ea2eSBryan Cantrill GElf_Sym sym;
18837c478bd9Sstevel@tonic-gate
1884892ad162SToomas Soome if ((addr = wsp->walk_addr) == 0) {
18857c478bd9Sstevel@tonic-gate mdb_warn("dtrace_dynvar walk needs dtrace_dstate_t\n");
18867c478bd9Sstevel@tonic-gate return (WALK_ERR);
18877c478bd9Sstevel@tonic-gate }
18887c478bd9Sstevel@tonic-gate
18897c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) {
18907c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic state at %p", addr);
18917c478bd9Sstevel@tonic-gate return (WALK_ERR);
18927c478bd9Sstevel@tonic-gate }
18937c478bd9Sstevel@tonic-gate
1894c9a6ea2eSBryan Cantrill if (mdb_lookup_by_name("dtrace_dynhash_sink", &sym) == -1) {
1895c9a6ea2eSBryan Cantrill mdb_warn("couldn't find 'dtrace_dynhash_sink'");
1896c9a6ea2eSBryan Cantrill return (WALK_ERR);
1897c9a6ea2eSBryan Cantrill }
1898c9a6ea2eSBryan Cantrill
18997c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_dynvar_data_t), UM_SLEEP);
19007c478bd9Sstevel@tonic-gate
19017c478bd9Sstevel@tonic-gate data->dtdvd_hashsize = dstate.dtds_hashsize;
19027c478bd9Sstevel@tonic-gate hsize = dstate.dtds_hashsize * sizeof (dtrace_dynhash_t);
19037c478bd9Sstevel@tonic-gate data->dtdvd_hash = mdb_alloc(hsize, UM_SLEEP);
1904c9a6ea2eSBryan Cantrill data->dtdvd_sink = (uintptr_t)sym.st_value;
19057c478bd9Sstevel@tonic-gate
19067c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtdvd_hash, hsize,
19077c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash) == -1) {
19087c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p",
19097c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash);
19107c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize);
19117c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t));
19127c478bd9Sstevel@tonic-gate return (WALK_ERR);
19137c478bd9Sstevel@tonic-gate }
19147c478bd9Sstevel@tonic-gate
1915c9a6ea2eSBryan Cantrill data->dtdvd_next = (uintptr_t)data->dtdvd_hash[0].dtdh_chain;
1916c9a6ea2eSBryan Cantrill
19177c478bd9Sstevel@tonic-gate wsp->walk_data = data;
19187c478bd9Sstevel@tonic-gate return (WALK_NEXT);
19197c478bd9Sstevel@tonic-gate }
19207c478bd9Sstevel@tonic-gate
19217c478bd9Sstevel@tonic-gate int
dtrace_dynvar_step(mdb_walk_state_t * wsp)19227c478bd9Sstevel@tonic-gate dtrace_dynvar_step(mdb_walk_state_t *wsp)
19237c478bd9Sstevel@tonic-gate {
19247c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data;
19257c478bd9Sstevel@tonic-gate dtrace_dynvar_t dynvar, *dvar;
19267c478bd9Sstevel@tonic-gate size_t dvarsize;
19277c478bd9Sstevel@tonic-gate uintptr_t addr;
19287c478bd9Sstevel@tonic-gate int nkeys;
19297c478bd9Sstevel@tonic-gate
1930c9a6ea2eSBryan Cantrill while ((addr = data->dtdvd_next) == data->dtdvd_sink) {
19317c478bd9Sstevel@tonic-gate if (data->dtdvd_ndx == data->dtdvd_hashsize)
19327c478bd9Sstevel@tonic-gate return (WALK_DONE);
19337c478bd9Sstevel@tonic-gate
19347c478bd9Sstevel@tonic-gate data->dtdvd_next =
19357c478bd9Sstevel@tonic-gate (uintptr_t)data->dtdvd_hash[data->dtdvd_ndx++].dtdh_chain;
19367c478bd9Sstevel@tonic-gate }
19377c478bd9Sstevel@tonic-gate
19387c478bd9Sstevel@tonic-gate if (mdb_vread(&dynvar, sizeof (dynvar), addr) == -1) {
19397c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr);
19407c478bd9Sstevel@tonic-gate return (WALK_ERR);
19417c478bd9Sstevel@tonic-gate }
19427c478bd9Sstevel@tonic-gate
19437c478bd9Sstevel@tonic-gate /*
19447c478bd9Sstevel@tonic-gate * Now we need to allocate the correct size.
19457c478bd9Sstevel@tonic-gate */
19467c478bd9Sstevel@tonic-gate nkeys = dynvar.dtdv_tuple.dtt_nkeys;
19477c478bd9Sstevel@tonic-gate dvarsize = (uintptr_t)&dynvar.dtdv_tuple.dtt_key[nkeys] -
19487c478bd9Sstevel@tonic-gate (uintptr_t)&dynvar;
19497c478bd9Sstevel@tonic-gate
19507c478bd9Sstevel@tonic-gate dvar = alloca(dvarsize);
19517c478bd9Sstevel@tonic-gate
19527c478bd9Sstevel@tonic-gate if (mdb_vread(dvar, dvarsize, addr) == -1) {
19537c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr);
19547c478bd9Sstevel@tonic-gate return (WALK_ERR);
19557c478bd9Sstevel@tonic-gate }
19567c478bd9Sstevel@tonic-gate
19577c478bd9Sstevel@tonic-gate data->dtdvd_next = (uintptr_t)dynvar.dtdv_next;
19587c478bd9Sstevel@tonic-gate
19597c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, dvar, wsp->walk_cbdata));
19607c478bd9Sstevel@tonic-gate }
19617c478bd9Sstevel@tonic-gate
19627c478bd9Sstevel@tonic-gate void
dtrace_dynvar_fini(mdb_walk_state_t * wsp)19637c478bd9Sstevel@tonic-gate dtrace_dynvar_fini(mdb_walk_state_t *wsp)
19647c478bd9Sstevel@tonic-gate {
19657c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data;
19667c478bd9Sstevel@tonic-gate size_t hsize;
19677c478bd9Sstevel@tonic-gate
19687c478bd9Sstevel@tonic-gate hsize = data->dtdvd_hashsize * sizeof (dtrace_dynvar_t *);
19697c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize);
19707c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t));
19717c478bd9Sstevel@tonic-gate }
19727c478bd9Sstevel@tonic-gate
19737c478bd9Sstevel@tonic-gate typedef struct dtrace_hashstat_data {
19747c478bd9Sstevel@tonic-gate size_t *dthsd_counts;
19757c478bd9Sstevel@tonic-gate size_t dthsd_hashsize;
19767c478bd9Sstevel@tonic-gate char *dthsd_data;
19777c478bd9Sstevel@tonic-gate size_t dthsd_size;
19787c478bd9Sstevel@tonic-gate int dthsd_header;
19797c478bd9Sstevel@tonic-gate } dtrace_hashstat_data_t;
19807c478bd9Sstevel@tonic-gate
19817c478bd9Sstevel@tonic-gate typedef void (*dtrace_hashstat_func_t)(dtrace_hashstat_data_t *);
19827c478bd9Sstevel@tonic-gate
19837c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_additive(dtrace_hashstat_data_t * data)19847c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(dtrace_hashstat_data_t *data)
19857c478bd9Sstevel@tonic-gate {
19867c478bd9Sstevel@tonic-gate int i;
19877c478bd9Sstevel@tonic-gate int hval = 0;
19887c478bd9Sstevel@tonic-gate
19897c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++)
19907c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i];
19917c478bd9Sstevel@tonic-gate
19927c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++;
19937c478bd9Sstevel@tonic-gate }
19947c478bd9Sstevel@tonic-gate
19957c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_shifty(dtrace_hashstat_data_t * data)19967c478bd9Sstevel@tonic-gate dtrace_hashstat_shifty(dtrace_hashstat_data_t *data)
19977c478bd9Sstevel@tonic-gate {
19987c478bd9Sstevel@tonic-gate uint64_t hval = 0;
19997c478bd9Sstevel@tonic-gate int i;
20007c478bd9Sstevel@tonic-gate
20017c478bd9Sstevel@tonic-gate if (data->dthsd_size < sizeof (uint64_t)) {
20027c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(data);
20037c478bd9Sstevel@tonic-gate return;
20047c478bd9Sstevel@tonic-gate }
20057c478bd9Sstevel@tonic-gate
20067c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i += sizeof (uint64_t)) {
20077c478bd9Sstevel@tonic-gate /* LINTED - alignment */
20087c478bd9Sstevel@tonic-gate uint64_t val = *((uint64_t *)&data->dthsd_data[i]);
20097c478bd9Sstevel@tonic-gate
20107c478bd9Sstevel@tonic-gate hval += (val & ((1 << NBBY) - 1)) +
20117c478bd9Sstevel@tonic-gate ((val >> NBBY) & ((1 << NBBY) - 1)) +
20127c478bd9Sstevel@tonic-gate ((val >> (NBBY << 1)) & ((1 << NBBY) - 1)) +
20137c478bd9Sstevel@tonic-gate ((val >> (NBBY << 2)) & ((1 << NBBY) - 1)) +
20147c478bd9Sstevel@tonic-gate (val & USHRT_MAX) + (val >> (NBBY << 1) & USHRT_MAX);
20157c478bd9Sstevel@tonic-gate }
20167c478bd9Sstevel@tonic-gate
20177c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++;
20187c478bd9Sstevel@tonic-gate }
20197c478bd9Sstevel@tonic-gate
20207c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_knuth(dtrace_hashstat_data_t * data)20217c478bd9Sstevel@tonic-gate dtrace_hashstat_knuth(dtrace_hashstat_data_t *data)
20227c478bd9Sstevel@tonic-gate {
20237c478bd9Sstevel@tonic-gate int i;
20247c478bd9Sstevel@tonic-gate int hval = data->dthsd_size;
20257c478bd9Sstevel@tonic-gate
20267c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++)
20277c478bd9Sstevel@tonic-gate hval = (hval << 4) ^ (hval >> 28) ^ data->dthsd_data[i];
20287c478bd9Sstevel@tonic-gate
20297c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++;
20307c478bd9Sstevel@tonic-gate }
20317c478bd9Sstevel@tonic-gate
20327c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_oneatatime(dtrace_hashstat_data_t * data)20337c478bd9Sstevel@tonic-gate dtrace_hashstat_oneatatime(dtrace_hashstat_data_t *data)
20347c478bd9Sstevel@tonic-gate {
20357c478bd9Sstevel@tonic-gate int i;
20367c478bd9Sstevel@tonic-gate uint32_t hval = 0;
20377c478bd9Sstevel@tonic-gate
20387c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) {
20397c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i];
20407c478bd9Sstevel@tonic-gate hval += (hval << 10);
20417c478bd9Sstevel@tonic-gate hval ^= (hval >> 6);
20427c478bd9Sstevel@tonic-gate }
20437c478bd9Sstevel@tonic-gate
20447c478bd9Sstevel@tonic-gate hval += (hval << 3);
20457c478bd9Sstevel@tonic-gate hval ^= (hval >> 11);
20467c478bd9Sstevel@tonic-gate hval += (hval << 15);
20477c478bd9Sstevel@tonic-gate
20487c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++;
20497c478bd9Sstevel@tonic-gate }
20507c478bd9Sstevel@tonic-gate
20517c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_fnv(dtrace_hashstat_data_t * data)20527c478bd9Sstevel@tonic-gate dtrace_hashstat_fnv(dtrace_hashstat_data_t *data)
20537c478bd9Sstevel@tonic-gate {
20547c478bd9Sstevel@tonic-gate static const uint32_t prime = 0x01000193;
20557c478bd9Sstevel@tonic-gate uint32_t hval = 0;
20567c478bd9Sstevel@tonic-gate int i;
20577c478bd9Sstevel@tonic-gate
20587c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) {
20597c478bd9Sstevel@tonic-gate hval *= prime;
20607c478bd9Sstevel@tonic-gate hval ^= data->dthsd_data[i];
20617c478bd9Sstevel@tonic-gate }
20627c478bd9Sstevel@tonic-gate
20637c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++;
20647c478bd9Sstevel@tonic-gate }
20657c478bd9Sstevel@tonic-gate
20667c478bd9Sstevel@tonic-gate static void
dtrace_hashstat_stats(char * name,dtrace_hashstat_data_t * data)20677c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(char *name, dtrace_hashstat_data_t *data)
20687c478bd9Sstevel@tonic-gate {
20697c478bd9Sstevel@tonic-gate size_t nz = 0, i;
20707c478bd9Sstevel@tonic-gate int longest = 0;
20717c478bd9Sstevel@tonic-gate size_t ttl = 0;
20727c478bd9Sstevel@tonic-gate double sum = 0.0;
20737c478bd9Sstevel@tonic-gate double avg;
20747c478bd9Sstevel@tonic-gate uint_t util, stddev;
20757c478bd9Sstevel@tonic-gate
20767c478bd9Sstevel@tonic-gate if (!data->dthsd_header) {
20777c478bd9Sstevel@tonic-gate mdb_printf("%15s %11s %11s %11s %11s %11s\n", "NAME",
20787c478bd9Sstevel@tonic-gate "HASHSIZE", "%UTIL", "LONGEST", "AVERAGE", "STDDEV");
20797c478bd9Sstevel@tonic-gate data->dthsd_header = 1;
20807c478bd9Sstevel@tonic-gate }
20817c478bd9Sstevel@tonic-gate
20827c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) {
20837c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] != 0) {
20847c478bd9Sstevel@tonic-gate nz++;
20857c478bd9Sstevel@tonic-gate
20867c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] > longest)
20877c478bd9Sstevel@tonic-gate longest = data->dthsd_counts[i];
20887c478bd9Sstevel@tonic-gate
20897c478bd9Sstevel@tonic-gate ttl += data->dthsd_counts[i];
20907c478bd9Sstevel@tonic-gate }
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate
20937c478bd9Sstevel@tonic-gate if (nz == 0) {
20947c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %11s %11s %11s %11s\n", name,
20957c478bd9Sstevel@tonic-gate data->dthsd_hashsize, "-", "-", "-", "-");
20967c478bd9Sstevel@tonic-gate return;
20977c478bd9Sstevel@tonic-gate }
20987c478bd9Sstevel@tonic-gate
20997c478bd9Sstevel@tonic-gate avg = (double)ttl / (double)nz;
21007c478bd9Sstevel@tonic-gate
21017c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) {
21027c478bd9Sstevel@tonic-gate double delta = (double)data->dthsd_counts[i] - avg;
21037c478bd9Sstevel@tonic-gate
21047c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] == 0)
21057c478bd9Sstevel@tonic-gate continue;
21067c478bd9Sstevel@tonic-gate
21077c478bd9Sstevel@tonic-gate sum += delta * delta;
21087c478bd9Sstevel@tonic-gate }
21097c478bd9Sstevel@tonic-gate
21107c478bd9Sstevel@tonic-gate util = (nz * 1000) / data->dthsd_hashsize;
21117c478bd9Sstevel@tonic-gate stddev = (uint_t)sqrt(sum / (double)nz) * 10;
21127c478bd9Sstevel@tonic-gate
21137c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %9u.%1u %11d %11d %9u.%1u\n", name,
21147c478bd9Sstevel@tonic-gate data->dthsd_hashsize, util / 10, util % 10, longest, ttl / nz,
21157c478bd9Sstevel@tonic-gate stddev / 10, stddev % 10);
21167c478bd9Sstevel@tonic-gate }
21177c478bd9Sstevel@tonic-gate
21187c478bd9Sstevel@tonic-gate static struct dtrace_hashstat {
21197c478bd9Sstevel@tonic-gate char *dths_name;
21207c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dths_func;
21217c478bd9Sstevel@tonic-gate } _dtrace_hashstat[] = {
21227c478bd9Sstevel@tonic-gate { "<actual>", NULL },
21237c478bd9Sstevel@tonic-gate { "additive", dtrace_hashstat_additive },
21247c478bd9Sstevel@tonic-gate { "shifty", dtrace_hashstat_shifty },
21257c478bd9Sstevel@tonic-gate { "knuth", dtrace_hashstat_knuth },
21267c478bd9Sstevel@tonic-gate { "one-at-a-time", dtrace_hashstat_oneatatime },
21277c478bd9Sstevel@tonic-gate { "fnv", dtrace_hashstat_fnv },
21287c478bd9Sstevel@tonic-gate { NULL, 0 }
21297c478bd9Sstevel@tonic-gate };
21307c478bd9Sstevel@tonic-gate
21317c478bd9Sstevel@tonic-gate typedef struct dtrace_aggstat_data {
21327c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t dtagsd_hash;
21337c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dtagsd_func;
21347c478bd9Sstevel@tonic-gate } dtrace_aggstat_data_t;
21357c478bd9Sstevel@tonic-gate
21367c478bd9Sstevel@tonic-gate static int
dtrace_aggstat_walk(uintptr_t addr,dtrace_aggkey_t * key,dtrace_aggstat_data_t * data)21377c478bd9Sstevel@tonic-gate dtrace_aggstat_walk(uintptr_t addr, dtrace_aggkey_t *key,
21387c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data)
21397c478bd9Sstevel@tonic-gate {
21407c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash;
21417c478bd9Sstevel@tonic-gate size_t size;
21427c478bd9Sstevel@tonic-gate
21437c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) {
21447c478bd9Sstevel@tonic-gate size_t bucket = key->dtak_hashval % hdata->dthsd_hashsize;
21457c478bd9Sstevel@tonic-gate
21467c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++;
21477c478bd9Sstevel@tonic-gate return (WALK_NEXT);
21487c478bd9Sstevel@tonic-gate }
21497c478bd9Sstevel@tonic-gate
21507c478bd9Sstevel@tonic-gate /*
21517c478bd9Sstevel@tonic-gate * We need to read the data.
21527c478bd9Sstevel@tonic-gate */
21537c478bd9Sstevel@tonic-gate size = key->dtak_size - sizeof (dtrace_aggid_t);
21547c478bd9Sstevel@tonic-gate addr = (uintptr_t)key->dtak_data + sizeof (dtrace_aggid_t);
21557c478bd9Sstevel@tonic-gate hdata->dthsd_data = alloca(size);
21567c478bd9Sstevel@tonic-gate hdata->dthsd_size = size;
21577c478bd9Sstevel@tonic-gate
21587c478bd9Sstevel@tonic-gate if (mdb_vread(hdata->dthsd_data, size, addr) == -1) {
21597c478bd9Sstevel@tonic-gate mdb_warn("couldn't read data at %p", addr);
21607c478bd9Sstevel@tonic-gate return (WALK_ERR);
21617c478bd9Sstevel@tonic-gate }
21627c478bd9Sstevel@tonic-gate
21637c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata);
21647c478bd9Sstevel@tonic-gate
21657c478bd9Sstevel@tonic-gate return (WALK_NEXT);
21667c478bd9Sstevel@tonic-gate }
21677c478bd9Sstevel@tonic-gate
21687c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21697c478bd9Sstevel@tonic-gate int
dtrace_aggstat(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)21707c478bd9Sstevel@tonic-gate dtrace_aggstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
21717c478bd9Sstevel@tonic-gate {
21727c478bd9Sstevel@tonic-gate dtrace_buffer_t buf;
21737c478bd9Sstevel@tonic-gate uintptr_t aaddr;
21747c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb;
21757c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime, evenpow;
21767c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data;
21777c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash;
21787c478bd9Sstevel@tonic-gate
21797c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data));
21807c478bd9Sstevel@tonic-gate
21817c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC))
21827c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
21837c478bd9Sstevel@tonic-gate
21847c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) {
21857c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr);
21867c478bd9Sstevel@tonic-gate return (DCMD_ERR);
21877c478bd9Sstevel@tonic-gate }
21887c478bd9Sstevel@tonic-gate
21897c478bd9Sstevel@tonic-gate aaddr = (uintptr_t)buf.dtb_tomax +
21907c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t);
21917c478bd9Sstevel@tonic-gate
21927c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), aaddr) == -1) {
21937c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", aaddr);
21947c478bd9Sstevel@tonic-gate return (DCMD_ERR);
21957c478bd9Sstevel@tonic-gate }
21967c478bd9Sstevel@tonic-gate
21977c478bd9Sstevel@tonic-gate hsize = (actual = agb.dtagb_hashsize) * sizeof (size_t);
21987c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC);
21997c478bd9Sstevel@tonic-gate
22007c478bd9Sstevel@tonic-gate /*
22017c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the
22027c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the
22037c478bd9Sstevel@tonic-gate * hell of it.)
22047c478bd9Sstevel@tonic-gate */
22057c478bd9Sstevel@tonic-gate for (prime = agb.dtagb_hashsize - 1; prime > 7; prime--) {
22067c478bd9Sstevel@tonic-gate size_t limit = prime / 7;
22077c478bd9Sstevel@tonic-gate
22087c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) {
22097c478bd9Sstevel@tonic-gate if ((prime % i) == 0)
22107c478bd9Sstevel@tonic-gate break;
22117c478bd9Sstevel@tonic-gate }
22127c478bd9Sstevel@tonic-gate
22137c478bd9Sstevel@tonic-gate if (i == limit)
22147c478bd9Sstevel@tonic-gate break;
22157c478bd9Sstevel@tonic-gate }
22167c478bd9Sstevel@tonic-gate
22177c478bd9Sstevel@tonic-gate /*
22187c478bd9Sstevel@tonic-gate * And now we want to pick the largest power of two smaller than the
22197c478bd9Sstevel@tonic-gate * hashsize.
22207c478bd9Sstevel@tonic-gate */
22217c478bd9Sstevel@tonic-gate for (i = 0; (1 << i) < agb.dtagb_hashsize; i++)
22227c478bd9Sstevel@tonic-gate continue;
22237c478bd9Sstevel@tonic-gate
22247c478bd9Sstevel@tonic-gate evenpow = (1 << (i - 1));
22257c478bd9Sstevel@tonic-gate
22267c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) {
22277c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func;
22287c478bd9Sstevel@tonic-gate
22297c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual;
22307c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t);
22317c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize);
22327c478bd9Sstevel@tonic-gate
22337c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey",
22347c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
22357c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr);
22367c478bd9Sstevel@tonic-gate return (DCMD_ERR);
22377c478bd9Sstevel@tonic-gate }
22387c478bd9Sstevel@tonic-gate
22397c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
22407c478bd9Sstevel@tonic-gate
22417c478bd9Sstevel@tonic-gate /*
22427c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try
22437c478bd9Sstevel@tonic-gate * any of the sizing experiments.
22447c478bd9Sstevel@tonic-gate */
22457c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL)
22467c478bd9Sstevel@tonic-gate continue;
22477c478bd9Sstevel@tonic-gate
22487c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime;
22497c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t);
22507c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize);
22517c478bd9Sstevel@tonic-gate
22527c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey",
22537c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
22547c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr);
22557c478bd9Sstevel@tonic-gate return (DCMD_ERR);
22567c478bd9Sstevel@tonic-gate }
22577c478bd9Sstevel@tonic-gate
22587c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
22597c478bd9Sstevel@tonic-gate
22607c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = evenpow;
22617c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t);
22627c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize);
22637c478bd9Sstevel@tonic-gate
22647c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey",
22657c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) {
22667c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr);
22677c478bd9Sstevel@tonic-gate return (DCMD_ERR);
22687c478bd9Sstevel@tonic-gate }
22697c478bd9Sstevel@tonic-gate
22707c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
22717c478bd9Sstevel@tonic-gate }
22727c478bd9Sstevel@tonic-gate
22737c478bd9Sstevel@tonic-gate return (DCMD_OK);
22747c478bd9Sstevel@tonic-gate }
22757c478bd9Sstevel@tonic-gate
22767c478bd9Sstevel@tonic-gate /*ARGSUSED*/
22777c478bd9Sstevel@tonic-gate static int
dtrace_dynstat_walk(uintptr_t addr,dtrace_dynvar_t * dynvar,dtrace_aggstat_data_t * data)22787c478bd9Sstevel@tonic-gate dtrace_dynstat_walk(uintptr_t addr, dtrace_dynvar_t *dynvar,
22797c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data)
22807c478bd9Sstevel@tonic-gate {
22817c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash;
22827c478bd9Sstevel@tonic-gate dtrace_tuple_t *tuple = &dynvar->dtdv_tuple;
22837c478bd9Sstevel@tonic-gate dtrace_key_t *key = tuple->dtt_key;
22847c478bd9Sstevel@tonic-gate size_t size = 0, offs = 0;
22857c478bd9Sstevel@tonic-gate int i, nkeys = tuple->dtt_nkeys;
22867c478bd9Sstevel@tonic-gate char *buf;
22877c478bd9Sstevel@tonic-gate
22887c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) {
22897c478bd9Sstevel@tonic-gate size_t bucket = dynvar->dtdv_hashval % hdata->dthsd_hashsize;
22907c478bd9Sstevel@tonic-gate
22917c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++;
22927c478bd9Sstevel@tonic-gate return (WALK_NEXT);
22937c478bd9Sstevel@tonic-gate }
22947c478bd9Sstevel@tonic-gate
22957c478bd9Sstevel@tonic-gate /*
22967c478bd9Sstevel@tonic-gate * We want to hand the hashing algorithm a contiguous buffer. First
22977c478bd9Sstevel@tonic-gate * run through the tuple and determine the size.
22987c478bd9Sstevel@tonic-gate */
22997c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) {
23007c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) {
23017c478bd9Sstevel@tonic-gate size += sizeof (uint64_t);
23027c478bd9Sstevel@tonic-gate } else {
23037c478bd9Sstevel@tonic-gate size += key[i].dttk_size;
23047c478bd9Sstevel@tonic-gate }
23057c478bd9Sstevel@tonic-gate }
23067c478bd9Sstevel@tonic-gate
23077c478bd9Sstevel@tonic-gate buf = alloca(size);
23087c478bd9Sstevel@tonic-gate
23097c478bd9Sstevel@tonic-gate /*
23107c478bd9Sstevel@tonic-gate * Now go back through the tuple and copy the data into the buffer.
23117c478bd9Sstevel@tonic-gate */
23127c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) {
23137c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) {
23147c478bd9Sstevel@tonic-gate bcopy(&key[i].dttk_value, &buf[offs],
23157c478bd9Sstevel@tonic-gate sizeof (uint64_t));
23167c478bd9Sstevel@tonic-gate offs += sizeof (uint64_t);
23177c478bd9Sstevel@tonic-gate } else {
23187c478bd9Sstevel@tonic-gate if (mdb_vread(&buf[offs], key[i].dttk_size,
23197c478bd9Sstevel@tonic-gate key[i].dttk_value) == -1) {
23207c478bd9Sstevel@tonic-gate mdb_warn("couldn't read tuple data at %p",
23217c478bd9Sstevel@tonic-gate key[i].dttk_value);
23227c478bd9Sstevel@tonic-gate return (WALK_ERR);
23237c478bd9Sstevel@tonic-gate }
23247c478bd9Sstevel@tonic-gate
23257c478bd9Sstevel@tonic-gate offs += key[i].dttk_size;
23267c478bd9Sstevel@tonic-gate }
23277c478bd9Sstevel@tonic-gate }
23287c478bd9Sstevel@tonic-gate
23297c478bd9Sstevel@tonic-gate hdata->dthsd_data = buf;
23307c478bd9Sstevel@tonic-gate hdata->dthsd_size = size;
23317c478bd9Sstevel@tonic-gate
23327c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata);
23337c478bd9Sstevel@tonic-gate
23347c478bd9Sstevel@tonic-gate return (WALK_NEXT);
23357c478bd9Sstevel@tonic-gate }
23367c478bd9Sstevel@tonic-gate
23377c478bd9Sstevel@tonic-gate /*ARGSUSED*/
23387c478bd9Sstevel@tonic-gate int
dtrace_dynstat(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)23397c478bd9Sstevel@tonic-gate dtrace_dynstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
23407c478bd9Sstevel@tonic-gate {
23417c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate;
23427c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime;
23437c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data;
23447c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash;
23457c478bd9Sstevel@tonic-gate
23467c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data));
23477c478bd9Sstevel@tonic-gate
23487c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC))
23497c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
23507c478bd9Sstevel@tonic-gate
23517c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) {
23527c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic variable state at %p", addr);
23537c478bd9Sstevel@tonic-gate return (DCMD_ERR);
23547c478bd9Sstevel@tonic-gate }
23557c478bd9Sstevel@tonic-gate
23567c478bd9Sstevel@tonic-gate hsize = (actual = dstate.dtds_hashsize) * sizeof (size_t);
23577c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC);
23587c478bd9Sstevel@tonic-gate
23597c478bd9Sstevel@tonic-gate /*
23607c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the
23617c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the
23627c478bd9Sstevel@tonic-gate * hell of it.)
23637c478bd9Sstevel@tonic-gate */
23647c478bd9Sstevel@tonic-gate for (prime = dstate.dtds_hashsize - 1; prime > 7; prime--) {
23657c478bd9Sstevel@tonic-gate size_t limit = prime / 7;
23667c478bd9Sstevel@tonic-gate
23677c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) {
23687c478bd9Sstevel@tonic-gate if ((prime % i) == 0)
23697c478bd9Sstevel@tonic-gate break;
23707c478bd9Sstevel@tonic-gate }
23717c478bd9Sstevel@tonic-gate
23727c478bd9Sstevel@tonic-gate if (i == limit)
23737c478bd9Sstevel@tonic-gate break;
23747c478bd9Sstevel@tonic-gate }
23757c478bd9Sstevel@tonic-gate
23767c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) {
23777c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func;
23787c478bd9Sstevel@tonic-gate
23797c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual;
23807c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t);
23817c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize);
23827c478bd9Sstevel@tonic-gate
23837c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar",
23847c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) {
23857c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_dynvar at %p", addr);
23867c478bd9Sstevel@tonic-gate return (DCMD_ERR);
23877c478bd9Sstevel@tonic-gate }
23887c478bd9Sstevel@tonic-gate
23897c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
23907c478bd9Sstevel@tonic-gate
23917c478bd9Sstevel@tonic-gate /*
23927c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try
23937c478bd9Sstevel@tonic-gate * any of the sizing experiments.
23947c478bd9Sstevel@tonic-gate */
23957c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL)
23967c478bd9Sstevel@tonic-gate continue;
23977c478bd9Sstevel@tonic-gate
23987c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime;
23997c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t);
24007c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize);
24017c478bd9Sstevel@tonic-gate
24027c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar",
24037c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) {
24047c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr);
24057c478bd9Sstevel@tonic-gate return (DCMD_ERR);
24067c478bd9Sstevel@tonic-gate }
24077c478bd9Sstevel@tonic-gate
24087c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata);
24097c478bd9Sstevel@tonic-gate }
24107c478bd9Sstevel@tonic-gate
24117c478bd9Sstevel@tonic-gate return (DCMD_OK);
24127c478bd9Sstevel@tonic-gate }
24137c478bd9Sstevel@tonic-gate
2414c2580b93Sjhaslam typedef struct dtrace_ecb_walk {
2415c2580b93Sjhaslam dtrace_ecb_t **dtew_ecbs;
2416c2580b93Sjhaslam int dtew_necbs;
2417c2580b93Sjhaslam int dtew_curecb;
2418c2580b93Sjhaslam } dtrace_ecb_walk_t;
2419c2580b93Sjhaslam
2420c2580b93Sjhaslam static int
dtrace_ecb_init(mdb_walk_state_t * wsp)2421c2580b93Sjhaslam dtrace_ecb_init(mdb_walk_state_t *wsp)
2422c2580b93Sjhaslam {
2423c2580b93Sjhaslam uintptr_t addr;
2424c2580b93Sjhaslam dtrace_state_t state;
2425c2580b93Sjhaslam dtrace_ecb_walk_t *ecbwp;
2426c2580b93Sjhaslam
2427892ad162SToomas Soome if ((addr = wsp->walk_addr) == 0) {
2428c2580b93Sjhaslam mdb_warn("dtrace_ecb walk needs dtrace_state_t\n");
2429c2580b93Sjhaslam return (WALK_ERR);
2430c2580b93Sjhaslam }
2431c2580b93Sjhaslam
2432c2580b93Sjhaslam if (mdb_vread(&state, sizeof (state), addr) == -1) {
2433c2580b93Sjhaslam mdb_warn("failed to read dtrace state pointer at %p", addr);
2434c2580b93Sjhaslam return (WALK_ERR);
2435c2580b93Sjhaslam }
2436c2580b93Sjhaslam
2437c2580b93Sjhaslam ecbwp = mdb_zalloc(sizeof (dtrace_ecb_walk_t), UM_SLEEP | UM_GC);
2438c2580b93Sjhaslam
2439c2580b93Sjhaslam ecbwp->dtew_ecbs = state.dts_ecbs;
2440c2580b93Sjhaslam ecbwp->dtew_necbs = state.dts_necbs;
2441c2580b93Sjhaslam ecbwp->dtew_curecb = 0;
2442c2580b93Sjhaslam
2443c2580b93Sjhaslam wsp->walk_data = ecbwp;
2444c2580b93Sjhaslam
2445c2580b93Sjhaslam return (WALK_NEXT);
2446c2580b93Sjhaslam }
2447c2580b93Sjhaslam
2448c2580b93Sjhaslam static int
dtrace_ecb_step(mdb_walk_state_t * wsp)2449c2580b93Sjhaslam dtrace_ecb_step(mdb_walk_state_t *wsp)
2450c2580b93Sjhaslam {
2451c2580b93Sjhaslam uintptr_t ecbp, addr;
2452c2580b93Sjhaslam dtrace_ecb_walk_t *ecbwp = wsp->walk_data;
2453c2580b93Sjhaslam
2454c2580b93Sjhaslam addr = (uintptr_t)ecbwp->dtew_ecbs +
2455c2580b93Sjhaslam ecbwp->dtew_curecb * sizeof (dtrace_ecb_t *);
2456c2580b93Sjhaslam
2457c2580b93Sjhaslam if (ecbwp->dtew_curecb++ == ecbwp->dtew_necbs)
2458c2580b93Sjhaslam return (WALK_DONE);
2459c2580b93Sjhaslam
2460c2580b93Sjhaslam if (mdb_vread(&ecbp, sizeof (addr), addr) == -1) {
2461c2580b93Sjhaslam mdb_warn("failed to read ecb at entry %d\n",
2462c2580b93Sjhaslam ecbwp->dtew_curecb);
2463c2580b93Sjhaslam return (WALK_ERR);
2464c2580b93Sjhaslam }
2465c2580b93Sjhaslam
2466892ad162SToomas Soome if (ecbp == 0)
2467c2580b93Sjhaslam return (WALK_NEXT);
2468c2580b93Sjhaslam
2469c2580b93Sjhaslam return (wsp->walk_callback(ecbp, NULL, wsp->walk_cbdata));
2470c2580b93Sjhaslam }
2471c2580b93Sjhaslam
24720f1d7ad6SJonathan Haslam static void
dtrace_options_numtostr(uint64_t num,char * buf,size_t len)24730f1d7ad6SJonathan Haslam dtrace_options_numtostr(uint64_t num, char *buf, size_t len)
24740f1d7ad6SJonathan Haslam {
24750f1d7ad6SJonathan Haslam uint64_t n = num;
24760f1d7ad6SJonathan Haslam int index = 0;
24770f1d7ad6SJonathan Haslam char u;
24780f1d7ad6SJonathan Haslam
24790f1d7ad6SJonathan Haslam while (n >= 1024) {
24800f1d7ad6SJonathan Haslam n = (n + (1024 / 2)) / 1024; /* Round up or down */
24810f1d7ad6SJonathan Haslam index++;
24820f1d7ad6SJonathan Haslam }
24830f1d7ad6SJonathan Haslam
24840f1d7ad6SJonathan Haslam u = " KMGTPE"[index];
24850f1d7ad6SJonathan Haslam
24860f1d7ad6SJonathan Haslam if (index == 0) {
24870f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%llu", (u_longlong_t)n);
24880f1d7ad6SJonathan Haslam } else if (n < 10 && (num & (num - 1)) != 0) {
24890f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%.2f%c",
24900f1d7ad6SJonathan Haslam (double)num / (1ULL << 10 * index), u);
24910f1d7ad6SJonathan Haslam } else if (n < 100 && (num & (num - 1)) != 0) {
24920f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%.1f%c",
24930f1d7ad6SJonathan Haslam (double)num / (1ULL << 10 * index), u);
24940f1d7ad6SJonathan Haslam } else {
24950f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%llu%c", (u_longlong_t)n, u);
24960f1d7ad6SJonathan Haslam }
24970f1d7ad6SJonathan Haslam }
24980f1d7ad6SJonathan Haslam
24990f1d7ad6SJonathan Haslam static void
dtrace_options_numtohz(uint64_t num,char * buf,size_t len)25000f1d7ad6SJonathan Haslam dtrace_options_numtohz(uint64_t num, char *buf, size_t len)
25010f1d7ad6SJonathan Haslam {
25020f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%dhz", NANOSEC/num);
25030f1d7ad6SJonathan Haslam }
25040f1d7ad6SJonathan Haslam
25050f1d7ad6SJonathan Haslam static void
dtrace_options_numtobufpolicy(uint64_t num,char * buf,size_t len)25060f1d7ad6SJonathan Haslam dtrace_options_numtobufpolicy(uint64_t num, char *buf, size_t len)
25070f1d7ad6SJonathan Haslam {
25080f1d7ad6SJonathan Haslam char *policy = "unknown";
25090f1d7ad6SJonathan Haslam
25100f1d7ad6SJonathan Haslam switch (num) {
25110f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_RING:
25120f1d7ad6SJonathan Haslam policy = "ring";
25130f1d7ad6SJonathan Haslam break;
25140f1d7ad6SJonathan Haslam
25150f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_FILL:
25160f1d7ad6SJonathan Haslam policy = "fill";
25170f1d7ad6SJonathan Haslam break;
25180f1d7ad6SJonathan Haslam
25190f1d7ad6SJonathan Haslam case DTRACEOPT_BUFPOLICY_SWITCH:
25200f1d7ad6SJonathan Haslam policy = "switch";
25210f1d7ad6SJonathan Haslam break;
25220f1d7ad6SJonathan Haslam }
25230f1d7ad6SJonathan Haslam
25240f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%s", policy);
25250f1d7ad6SJonathan Haslam }
25260f1d7ad6SJonathan Haslam
25270f1d7ad6SJonathan Haslam static void
dtrace_options_numtocpu(uint64_t cpu,char * buf,size_t len)25280f1d7ad6SJonathan Haslam dtrace_options_numtocpu(uint64_t cpu, char *buf, size_t len)
25290f1d7ad6SJonathan Haslam {
25300f1d7ad6SJonathan Haslam if (cpu == DTRACE_CPUALL)
25310f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%7s", "unbound");
25320f1d7ad6SJonathan Haslam else
25330f1d7ad6SJonathan Haslam (void) mdb_snprintf(buf, len, "%d", cpu);
25340f1d7ad6SJonathan Haslam }
25350f1d7ad6SJonathan Haslam
25360f1d7ad6SJonathan Haslam typedef void (*dtrace_options_func_t)(uint64_t, char *, size_t);
25370f1d7ad6SJonathan Haslam
25380f1d7ad6SJonathan Haslam static struct dtrace_options {
25390f1d7ad6SJonathan Haslam char *dtop_optstr;
25400f1d7ad6SJonathan Haslam dtrace_options_func_t dtop_func;
25410f1d7ad6SJonathan Haslam } _dtrace_options[] = {
25420f1d7ad6SJonathan Haslam { "bufsize", dtrace_options_numtostr },
25430f1d7ad6SJonathan Haslam { "bufpolicy", dtrace_options_numtobufpolicy },
25440f1d7ad6SJonathan Haslam { "dynvarsize", dtrace_options_numtostr },
25450f1d7ad6SJonathan Haslam { "aggsize", dtrace_options_numtostr },
25460f1d7ad6SJonathan Haslam { "specsize", dtrace_options_numtostr },
25470f1d7ad6SJonathan Haslam { "nspec", dtrace_options_numtostr },
25480f1d7ad6SJonathan Haslam { "strsize", dtrace_options_numtostr },
25490f1d7ad6SJonathan Haslam { "cleanrate", dtrace_options_numtohz },
25500f1d7ad6SJonathan Haslam { "cpu", dtrace_options_numtocpu },
25510f1d7ad6SJonathan Haslam { "bufresize", dtrace_options_numtostr },
25520f1d7ad6SJonathan Haslam { "grabanon", dtrace_options_numtostr },
25530f1d7ad6SJonathan Haslam { "flowindent", dtrace_options_numtostr },
25540f1d7ad6SJonathan Haslam { "quiet", dtrace_options_numtostr },
25550f1d7ad6SJonathan Haslam { "stackframes", dtrace_options_numtostr },
25560f1d7ad6SJonathan Haslam { "ustackframes", dtrace_options_numtostr },
25570f1d7ad6SJonathan Haslam { "aggrate", dtrace_options_numtohz },
25580f1d7ad6SJonathan Haslam { "switchrate", dtrace_options_numtohz },
25590f1d7ad6SJonathan Haslam { "statusrate", dtrace_options_numtohz },
25600f1d7ad6SJonathan Haslam { "destructive", dtrace_options_numtostr },
25610f1d7ad6SJonathan Haslam { "stackindent", dtrace_options_numtostr },
25620f1d7ad6SJonathan Haslam { "rawbytes", dtrace_options_numtostr },
25630f1d7ad6SJonathan Haslam { "jstackframes", dtrace_options_numtostr },
25640f1d7ad6SJonathan Haslam { "jstackstrsize", dtrace_options_numtostr },
25650f1d7ad6SJonathan Haslam { "aggsortkey", dtrace_options_numtostr },
25660f1d7ad6SJonathan Haslam { "aggsortrev", dtrace_options_numtostr },
25670f1d7ad6SJonathan Haslam { "aggsortpos", dtrace_options_numtostr },
25689d0ac662SJohn Levon { "aggsortkeypos", dtrace_options_numtostr },
25699d0ac662SJohn Levon { "temporal", dtrace_options_numtostr },
25709d0ac662SJohn Levon { "agghist", dtrace_options_numtostr },
25719d0ac662SJohn Levon { "aggpack", dtrace_options_numtostr },
25729d0ac662SJohn Levon { "aggzoom", dtrace_options_numtostr },
25739d0ac662SJohn Levon { "zone", dtrace_options_numtostr }
25740f1d7ad6SJonathan Haslam };
25750f1d7ad6SJonathan Haslam
25769d0ac662SJohn Levon CTASSERT(ARRAY_SIZE(_dtrace_options) == DTRACEOPT_MAX);
25779d0ac662SJohn Levon
25780f1d7ad6SJonathan Haslam static void
dtrace_options_help(void)25790f1d7ad6SJonathan Haslam dtrace_options_help(void)
25800f1d7ad6SJonathan Haslam {
25810f1d7ad6SJonathan Haslam mdb_printf("Given a dtrace_state_t structure, displays the "
25820f1d7ad6SJonathan Haslam "current tunable option\nsettings.\n");
25830f1d7ad6SJonathan Haslam }
25840f1d7ad6SJonathan Haslam
25850f1d7ad6SJonathan Haslam /*ARGSUSED*/
25860f1d7ad6SJonathan Haslam static int
dtrace_options(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)25870f1d7ad6SJonathan Haslam dtrace_options(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
25880f1d7ad6SJonathan Haslam {
25890f1d7ad6SJonathan Haslam dtrace_state_t state;
25900f1d7ad6SJonathan Haslam int i = 0;
25910f1d7ad6SJonathan Haslam dtrace_optval_t *options;
25920f1d7ad6SJonathan Haslam char val[32];
25930f1d7ad6SJonathan Haslam
25940f1d7ad6SJonathan Haslam if (!(flags & DCMD_ADDRSPEC))
25950f1d7ad6SJonathan Haslam return (DCMD_USAGE);
25960f1d7ad6SJonathan Haslam
25970f1d7ad6SJonathan Haslam if (mdb_vread(&state, sizeof (dtrace_state_t), (uintptr_t)addr) == -1) {
25980f1d7ad6SJonathan Haslam mdb_warn("failed to read state pointer at %p\n", addr);
25990f1d7ad6SJonathan Haslam return (DCMD_ERR);
26000f1d7ad6SJonathan Haslam }
26010f1d7ad6SJonathan Haslam
26020f1d7ad6SJonathan Haslam options = &state.dts_options[0];
26030f1d7ad6SJonathan Haslam
26040f1d7ad6SJonathan Haslam mdb_printf("%<u>%-25s %s%</u>\n", "OPTION", "VALUE");
26050f1d7ad6SJonathan Haslam for (i = 0; i < DTRACEOPT_MAX; i++) {
26060f1d7ad6SJonathan Haslam if (options[i] == DTRACEOPT_UNSET) {
26070f1d7ad6SJonathan Haslam mdb_printf("%-25s %s\n",
26080f1d7ad6SJonathan Haslam _dtrace_options[i].dtop_optstr, "UNSET");
26090f1d7ad6SJonathan Haslam } else {
26100f1d7ad6SJonathan Haslam (void) _dtrace_options[i].dtop_func(options[i],
26110f1d7ad6SJonathan Haslam val, 32);
26120f1d7ad6SJonathan Haslam mdb_printf("%-25s %s\n",
26130f1d7ad6SJonathan Haslam _dtrace_options[i].dtop_optstr, val);
26140f1d7ad6SJonathan Haslam }
26150f1d7ad6SJonathan Haslam }
26160f1d7ad6SJonathan Haslam
26170f1d7ad6SJonathan Haslam return (DCMD_OK);
26180f1d7ad6SJonathan Haslam }
26190f1d7ad6SJonathan Haslam
26200f1d7ad6SJonathan Haslam static int
pid2state_init(mdb_walk_state_t * wsp)26210f1d7ad6SJonathan Haslam pid2state_init(mdb_walk_state_t *wsp)
26220f1d7ad6SJonathan Haslam {
26230f1d7ad6SJonathan Haslam dtrace_state_data_t *data;
26240f1d7ad6SJonathan Haslam uintptr_t devi;
26250f1d7ad6SJonathan Haslam uintptr_t proc;
26260f1d7ad6SJonathan Haslam struct dev_info info;
26270f1d7ad6SJonathan Haslam pid_t pid = (pid_t)wsp->walk_addr;
26280f1d7ad6SJonathan Haslam
2629892ad162SToomas Soome if (wsp->walk_addr == 0) {
26300f1d7ad6SJonathan Haslam mdb_warn("pid2state walk requires PID\n");
26310f1d7ad6SJonathan Haslam return (WALK_ERR);
26320f1d7ad6SJonathan Haslam }
26330f1d7ad6SJonathan Haslam
26340f1d7ad6SJonathan Haslam data = mdb_zalloc(sizeof (dtrace_state_data_t), UM_SLEEP | UM_GC);
26350f1d7ad6SJonathan Haslam
26360f1d7ad6SJonathan Haslam if (mdb_readvar(&data->dtsd_softstate, "dtrace_softstate") == -1) {
26370f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_softstate'");
26380f1d7ad6SJonathan Haslam return (DCMD_ERR);
26390f1d7ad6SJonathan Haslam }
26400f1d7ad6SJonathan Haslam
264175cebdd1SRyan Zezeski if ((proc = mdb_pid2proc(pid, NULL)) == 0) {
26420f1d7ad6SJonathan Haslam mdb_warn("PID 0t%d not found\n", pid);
26430f1d7ad6SJonathan Haslam return (DCMD_ERR);
26440f1d7ad6SJonathan Haslam }
26450f1d7ad6SJonathan Haslam
26460f1d7ad6SJonathan Haslam if (mdb_readvar(&devi, "dtrace_devi") == -1) {
26470f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_devi'");
26480f1d7ad6SJonathan Haslam return (DCMD_ERR);
26490f1d7ad6SJonathan Haslam }
26500f1d7ad6SJonathan Haslam
26510f1d7ad6SJonathan Haslam if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) {
26520f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dev_info'");
26530f1d7ad6SJonathan Haslam return (DCMD_ERR);
26540f1d7ad6SJonathan Haslam }
26550f1d7ad6SJonathan Haslam
26560f1d7ad6SJonathan Haslam data->dtsd_major = info.devi_major;
26570f1d7ad6SJonathan Haslam data->dtsd_proc = proc;
26580f1d7ad6SJonathan Haslam
26590f1d7ad6SJonathan Haslam wsp->walk_data = data;
26600f1d7ad6SJonathan Haslam
26610f1d7ad6SJonathan Haslam return (WALK_NEXT);
26620f1d7ad6SJonathan Haslam }
26630f1d7ad6SJonathan Haslam
26640f1d7ad6SJonathan Haslam /*ARGSUSED*/
26650f1d7ad6SJonathan Haslam static int
pid2state_file(uintptr_t addr,struct file * f,dtrace_state_data_t * data)26660f1d7ad6SJonathan Haslam pid2state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data)
26670f1d7ad6SJonathan Haslam {
26680f1d7ad6SJonathan Haslam vnode_t vnode;
26690f1d7ad6SJonathan Haslam minor_t minor;
26700f1d7ad6SJonathan Haslam uintptr_t statep;
26710f1d7ad6SJonathan Haslam
26720f1d7ad6SJonathan Haslam /* Get the vnode for this file */
26730f1d7ad6SJonathan Haslam if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) {
26740f1d7ad6SJonathan Haslam mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode);
26750f1d7ad6SJonathan Haslam return (WALK_NEXT);
26760f1d7ad6SJonathan Haslam }
26770f1d7ad6SJonathan Haslam
26780f1d7ad6SJonathan Haslam
26790f1d7ad6SJonathan Haslam /* Is this the dtrace device? */
26800f1d7ad6SJonathan Haslam if (getmajor(vnode.v_rdev) != data->dtsd_major)
26810f1d7ad6SJonathan Haslam return (WALK_NEXT);
26820f1d7ad6SJonathan Haslam
26830f1d7ad6SJonathan Haslam /* Get the minor number for this device entry */
26840f1d7ad6SJonathan Haslam minor = getminor(vnode.v_rdev);
26850f1d7ad6SJonathan Haslam
26860f1d7ad6SJonathan Haslam if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor,
26870f1d7ad6SJonathan Haslam &statep, NULL, 0) == -1) {
26880f1d7ad6SJonathan Haslam mdb_warn("failed to read softstate for minor %d", minor);
26890f1d7ad6SJonathan Haslam return (WALK_NEXT);
26900f1d7ad6SJonathan Haslam }
26910f1d7ad6SJonathan Haslam
26920f1d7ad6SJonathan Haslam mdb_printf("%p\n", statep);
26930f1d7ad6SJonathan Haslam
26940f1d7ad6SJonathan Haslam return (WALK_NEXT);
26950f1d7ad6SJonathan Haslam }
26960f1d7ad6SJonathan Haslam
26970f1d7ad6SJonathan Haslam static int
pid2state_step(mdb_walk_state_t * wsp)26980f1d7ad6SJonathan Haslam pid2state_step(mdb_walk_state_t *wsp)
26990f1d7ad6SJonathan Haslam {
27000f1d7ad6SJonathan Haslam dtrace_state_data_t *ds = wsp->walk_data;
27010f1d7ad6SJonathan Haslam
27020f1d7ad6SJonathan Haslam if (mdb_pwalk("file",
27030f1d7ad6SJonathan Haslam (mdb_walk_cb_t)pid2state_file, ds, ds->dtsd_proc) == -1) {
27040f1d7ad6SJonathan Haslam mdb_warn("couldn't walk 'file' for proc %p", ds->dtsd_proc);
27050f1d7ad6SJonathan Haslam return (WALK_ERR);
27060f1d7ad6SJonathan Haslam }
27070f1d7ad6SJonathan Haslam
27080f1d7ad6SJonathan Haslam return (WALK_DONE);
27090f1d7ad6SJonathan Haslam }
27100f1d7ad6SJonathan Haslam
27110f1d7ad6SJonathan Haslam /*ARGSUSED*/
27120f1d7ad6SJonathan Haslam static int
dtrace_probes_walk(uintptr_t addr,void * ignored,uintptr_t * target)27130f1d7ad6SJonathan Haslam dtrace_probes_walk(uintptr_t addr, void *ignored, uintptr_t *target)
27140f1d7ad6SJonathan Haslam {
27150f1d7ad6SJonathan Haslam dtrace_ecb_t ecb;
27160f1d7ad6SJonathan Haslam dtrace_probe_t probe;
27170f1d7ad6SJonathan Haslam dtrace_probedesc_t pd;
27180f1d7ad6SJonathan Haslam
2719892ad162SToomas Soome if (addr == 0)
27200f1d7ad6SJonathan Haslam return (WALK_ERR);
27210f1d7ad6SJonathan Haslam
27220f1d7ad6SJonathan Haslam if (mdb_vread(&ecb, sizeof (dtrace_ecb_t), addr) == -1) {
27230f1d7ad6SJonathan Haslam mdb_warn("failed to read ecb %p\n", addr);
27240f1d7ad6SJonathan Haslam return (WALK_ERR);
27250f1d7ad6SJonathan Haslam }
27260f1d7ad6SJonathan Haslam
27270f1d7ad6SJonathan Haslam if (ecb.dte_probe == NULL)
27280f1d7ad6SJonathan Haslam return (WALK_ERR);
27290f1d7ad6SJonathan Haslam
27300f1d7ad6SJonathan Haslam if (mdb_vread(&probe, sizeof (dtrace_probe_t),
27310f1d7ad6SJonathan Haslam (uintptr_t)ecb.dte_probe) == -1) {
27320f1d7ad6SJonathan Haslam mdb_warn("failed to read probe %p\n", ecb.dte_probe);
27330f1d7ad6SJonathan Haslam return (WALK_ERR);
27340f1d7ad6SJonathan Haslam }
27350f1d7ad6SJonathan Haslam
27360f1d7ad6SJonathan Haslam pd.dtpd_id = probe.dtpr_id;
27370f1d7ad6SJonathan Haslam dtracemdb_probe(NULL, &pd);
27380f1d7ad6SJonathan Haslam
27390f1d7ad6SJonathan Haslam mdb_printf("%5d %10s %17s %33s %s\n", pd.dtpd_id, pd.dtpd_provider,
27400f1d7ad6SJonathan Haslam pd.dtpd_mod, pd.dtpd_func, pd.dtpd_name);
27410f1d7ad6SJonathan Haslam
27420f1d7ad6SJonathan Haslam return (WALK_NEXT);
27430f1d7ad6SJonathan Haslam }
27440f1d7ad6SJonathan Haslam
27450f1d7ad6SJonathan Haslam static void
dtrace_probes_help(void)27460f1d7ad6SJonathan Haslam dtrace_probes_help(void)
27470f1d7ad6SJonathan Haslam {
27480f1d7ad6SJonathan Haslam mdb_printf("Given a dtrace_state_t structure, displays all "
27490f1d7ad6SJonathan Haslam "its active enablings. If no\nstate structure is provided, "
27500f1d7ad6SJonathan Haslam "all available probes are listed.\n");
27510f1d7ad6SJonathan Haslam }
27520f1d7ad6SJonathan Haslam
27530f1d7ad6SJonathan Haslam /*ARGSUSED*/
27540f1d7ad6SJonathan Haslam static int
dtrace_probes(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)27550f1d7ad6SJonathan Haslam dtrace_probes(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
27560f1d7ad6SJonathan Haslam {
27570f1d7ad6SJonathan Haslam dtrace_probedesc_t pd;
27580f1d7ad6SJonathan Haslam uintptr_t caddr, base, paddr;
27590f1d7ad6SJonathan Haslam int nprobes, i;
27600f1d7ad6SJonathan Haslam
27610f1d7ad6SJonathan Haslam mdb_printf("%5s %10s %17s %33s %s\n",
27620f1d7ad6SJonathan Haslam "ID", "PROVIDER", "MODULE", "FUNCTION", "NAME");
27630f1d7ad6SJonathan Haslam
27640f1d7ad6SJonathan Haslam if (!(flags & DCMD_ADDRSPEC)) {
27650f1d7ad6SJonathan Haslam /*
27660f1d7ad6SJonathan Haslam * If no argument is provided just display all available
27670f1d7ad6SJonathan Haslam * probes.
27680f1d7ad6SJonathan Haslam */
27690f1d7ad6SJonathan Haslam if (mdb_readvar(&base, "dtrace_probes") == -1) {
27700f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_probes'");
27710f1d7ad6SJonathan Haslam return (-1);
27720f1d7ad6SJonathan Haslam }
27730f1d7ad6SJonathan Haslam
27740f1d7ad6SJonathan Haslam if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) {
27750f1d7ad6SJonathan Haslam mdb_warn("failed to read 'dtrace_nprobes'");
27760f1d7ad6SJonathan Haslam return (-1);
27770f1d7ad6SJonathan Haslam }
27780f1d7ad6SJonathan Haslam
27790f1d7ad6SJonathan Haslam for (i = 0; i < nprobes; i++) {
27800f1d7ad6SJonathan Haslam caddr = base + i * sizeof (dtrace_probe_t *);
27810f1d7ad6SJonathan Haslam
27820f1d7ad6SJonathan Haslam if (mdb_vread(&paddr, sizeof (paddr), caddr) == -1) {
27830f1d7ad6SJonathan Haslam mdb_warn("couldn't read probe pointer at %p",
27840f1d7ad6SJonathan Haslam caddr);
27850f1d7ad6SJonathan Haslam continue;
27860f1d7ad6SJonathan Haslam }
27870f1d7ad6SJonathan Haslam
2788892ad162SToomas Soome if (paddr == 0)
27890f1d7ad6SJonathan Haslam continue;
27900f1d7ad6SJonathan Haslam
27910f1d7ad6SJonathan Haslam pd.dtpd_id = i + 1;
27920f1d7ad6SJonathan Haslam if (dtracemdb_probe(NULL, &pd) == 0) {
27930f1d7ad6SJonathan Haslam mdb_printf("%5d %10s %17s %33s %s\n",
27940f1d7ad6SJonathan Haslam pd.dtpd_id, pd.dtpd_provider,
27950f1d7ad6SJonathan Haslam pd.dtpd_mod, pd.dtpd_func, pd.dtpd_name);
27960f1d7ad6SJonathan Haslam }
27970f1d7ad6SJonathan Haslam }
27980f1d7ad6SJonathan Haslam } else {
27990f1d7ad6SJonathan Haslam if (mdb_pwalk("dtrace_ecb", (mdb_walk_cb_t)dtrace_probes_walk,
28000f1d7ad6SJonathan Haslam NULL, addr) == -1) {
28010f1d7ad6SJonathan Haslam mdb_warn("couldn't walk 'dtrace_ecb'");
28020f1d7ad6SJonathan Haslam return (DCMD_ERR);
28030f1d7ad6SJonathan Haslam }
28040f1d7ad6SJonathan Haslam }
28050f1d7ad6SJonathan Haslam
28060f1d7ad6SJonathan Haslam return (DCMD_OK);
28070f1d7ad6SJonathan Haslam }
28080f1d7ad6SJonathan Haslam
28091a7c1b72Smws const mdb_dcmd_t kernel_dcmds[] = {
28107c478bd9Sstevel@tonic-gate { "id2probe", ":", "translate a dtrace_id_t to a dtrace_probe_t",
28117c478bd9Sstevel@tonic-gate id2probe },
2812bbf21555SRichard Lowe { "dtrace", ":[-c cpu]", "print dtrace(8)-like output",
28137c478bd9Sstevel@tonic-gate dtrace, dtrace_help },
28147c478bd9Sstevel@tonic-gate { "dtrace_errhash", ":", "print DTrace error hash", dtrace_errhash },
28157c478bd9Sstevel@tonic-gate { "dtrace_helptrace", ":", "print DTrace helper trace",
28167c478bd9Sstevel@tonic-gate dtrace_helptrace },
28177c478bd9Sstevel@tonic-gate { "dtrace_state", ":", "print active DTrace consumers", dtrace_state,
28187c478bd9Sstevel@tonic-gate dtrace_state_help },
28197c478bd9Sstevel@tonic-gate { "dtrace_aggstat", ":",
28207c478bd9Sstevel@tonic-gate "print DTrace aggregation hash statistics", dtrace_aggstat },
28217c478bd9Sstevel@tonic-gate { "dtrace_dynstat", ":",
28227c478bd9Sstevel@tonic-gate "print DTrace dynamic variable hash statistics", dtrace_dynstat },
28230f1d7ad6SJonathan Haslam { "dtrace_options", ":",
28240f1d7ad6SJonathan Haslam "print a DTrace consumer's current tuneable options",
28250f1d7ad6SJonathan Haslam dtrace_options, dtrace_options_help },
28260f1d7ad6SJonathan Haslam { "dtrace_probes", "?", "print a DTrace consumer's enabled probes",
28270f1d7ad6SJonathan Haslam dtrace_probes, dtrace_probes_help },
28287c478bd9Sstevel@tonic-gate { NULL }
28297c478bd9Sstevel@tonic-gate };
28307c478bd9Sstevel@tonic-gate
28311a7c1b72Smws const mdb_walker_t kernel_walkers[] = {
28327c478bd9Sstevel@tonic-gate { "dtrace_errhash", "walk hash of DTrace error messasges",
28337c478bd9Sstevel@tonic-gate dtrace_errhash_init, dtrace_errhash_step },
28347c478bd9Sstevel@tonic-gate { "dtrace_helptrace", "walk DTrace helper trace entries",
28357c478bd9Sstevel@tonic-gate dtrace_helptrace_init, dtrace_helptrace_step },
28367c478bd9Sstevel@tonic-gate { "dtrace_state", "walk DTrace per-consumer softstate",
28377c478bd9Sstevel@tonic-gate dtrace_state_init, dtrace_state_step },
28387c478bd9Sstevel@tonic-gate { "dtrace_aggkey", "walk DTrace aggregation keys",
28397c478bd9Sstevel@tonic-gate dtrace_aggkey_init, dtrace_aggkey_step, dtrace_aggkey_fini },
28407c478bd9Sstevel@tonic-gate { "dtrace_dynvar", "walk DTrace dynamic variables",
28417c478bd9Sstevel@tonic-gate dtrace_dynvar_init, dtrace_dynvar_step, dtrace_dynvar_fini },
2842c2580b93Sjhaslam { "dtrace_ecb", "walk a DTrace consumer's enabling control blocks",
2843c2580b93Sjhaslam dtrace_ecb_init, dtrace_ecb_step },
28440f1d7ad6SJonathan Haslam { "pid2state", "walk a processes dtrace_state structures",
28450f1d7ad6SJonathan Haslam pid2state_init, pid2state_step },
28467c478bd9Sstevel@tonic-gate { NULL }
28477c478bd9Sstevel@tonic-gate };
2848