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