xref: /freebsd/sys/cddl/contrib/opensolaris/uts/common/sys/dtrace.h (revision 06e7bc83f6a49b99f87ad1a6034e2fad54ebe7f3)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
29  * Copyright (c) 2013 by Delphix. All rights reserved.
30  */
31 
32 #ifndef _SYS_DTRACE_H
33 #define	_SYS_DTRACE_H
34 
35 #ifdef	__cplusplus
36 extern "C" {
37 #endif
38 
39 /*
40  * DTrace Dynamic Tracing Software: Kernel Interfaces
41  *
42  * Note: The contents of this file are private to the implementation of the
43  * Solaris system and DTrace subsystem and are subject to change at any time
44  * without notice.  Applications and drivers using these interfaces will fail
45  * to run on future releases.  These interfaces should not be used for any
46  * purpose except those expressly outlined in dtrace(7D) and libdtrace(3LIB).
47  * Please refer to the "Solaris Dynamic Tracing Guide" for more information.
48  */
49 
50 #ifndef _ASM
51 
52 #include <sys/param.h>
53 #include <sys/stdint.h>
54 #ifdef _KERNEL
55 #include <sys/endian.h>
56 #endif
57 #if !defined(IN_BASE) && !defined(_KERNEL)
58 /* Compatibility types to allow including the CTF API */
59 typedef unsigned int zoneid_t;
60 typedef unsigned char uchar_t;
61 typedef unsigned short ushort_t;
62 typedef unsigned int uint_t;
63 typedef unsigned long ulong_t;
64 typedef int processorid_t;
65 #else
66 #include <sys/modctl.h>
67 #include <sys/processor.h>
68 #include <sys/cpuvar.h>
69 #include <sys/param.h>
70 #include <sys/linker.h>
71 #include <sys/ioccom.h>
72 #include <sys/cred.h>
73 #include <sys/proc.h>
74 #include <sys/types.h>
75 #include <sys/ucred.h>
76 #endif
77 typedef int model_t;
78 #include <sys/ctf_api.h>
79 
80 /*
81  * DTrace Universal Constants and Typedefs
82  */
83 #define	DTRACE_CPUALL		-1	/* all CPUs */
84 #define	DTRACE_IDNONE		0	/* invalid probe identifier */
85 #define	DTRACE_EPIDNONE		0	/* invalid enabled probe identifier */
86 #define	DTRACE_AGGIDNONE	0	/* invalid aggregation identifier */
87 #define	DTRACE_AGGVARIDNONE	0	/* invalid aggregation variable ID */
88 #define	DTRACE_CACHEIDNONE	0	/* invalid predicate cache */
89 #define	DTRACE_PROVNONE		0	/* invalid provider identifier */
90 #define	DTRACE_METAPROVNONE	0	/* invalid meta-provider identifier */
91 #define	DTRACE_ARGNONE		-1	/* invalid argument index */
92 
93 #define	DTRACE_PROVNAMELEN	64
94 #define	DTRACE_MODNAMELEN	64
95 #define	DTRACE_FUNCNAMELEN	192
96 #define	DTRACE_NAMELEN		64
97 #define	DTRACE_FULLNAMELEN	(DTRACE_PROVNAMELEN + DTRACE_MODNAMELEN + \
98 				DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 4)
99 #define	DTRACE_ARGTYPELEN	128
100 
101 typedef uint32_t dtrace_id_t;		/* probe identifier */
102 typedef uint32_t dtrace_epid_t;		/* enabled probe identifier */
103 typedef uint32_t dtrace_aggid_t;	/* aggregation identifier */
104 typedef int64_t dtrace_aggvarid_t;	/* aggregation variable identifier */
105 typedef uint16_t dtrace_actkind_t;	/* action kind */
106 typedef int64_t dtrace_optval_t;	/* option value */
107 typedef uint32_t dtrace_cacheid_t;	/* predicate cache identifier */
108 
109 typedef enum dtrace_probespec {
110 	DTRACE_PROBESPEC_NONE = -1,
111 	DTRACE_PROBESPEC_PROVIDER = 0,
112 	DTRACE_PROBESPEC_MOD,
113 	DTRACE_PROBESPEC_FUNC,
114 	DTRACE_PROBESPEC_NAME
115 } dtrace_probespec_t;
116 
117 /*
118  * DTrace Intermediate Format (DIF)
119  *
120  * The following definitions describe the DTrace Intermediate Format (DIF), a
121  * a RISC-like instruction set and program encoding used to represent
122  * predicates and actions that can be bound to DTrace probes.  The constants
123  * below defining the number of available registers are suggested minimums; the
124  * compiler should use DTRACEIOC_CONF to dynamically obtain the number of
125  * registers provided by the current DTrace implementation.
126  */
127 #define	DIF_VERSION_1	1		/* DIF version 1: Solaris 10 Beta */
128 #define	DIF_VERSION_2	2		/* DIF version 2: Solaris 10 FCS */
129 #define	DIF_VERSION	DIF_VERSION_2	/* latest DIF instruction set version */
130 #define	DIF_DIR_NREGS	8		/* number of DIF integer registers */
131 #define	DIF_DTR_NREGS	8		/* number of DIF tuple registers */
132 
133 #define	DIF_OP_OR	1		/* or	r1, r2, rd */
134 #define	DIF_OP_XOR	2		/* xor	r1, r2, rd */
135 #define	DIF_OP_AND	3		/* and	r1, r2, rd */
136 #define	DIF_OP_SLL	4		/* sll	r1, r2, rd */
137 #define	DIF_OP_SRL	5		/* srl	r1, r2, rd */
138 #define	DIF_OP_SUB	6		/* sub	r1, r2, rd */
139 #define	DIF_OP_ADD	7		/* add	r1, r2, rd */
140 #define	DIF_OP_MUL	8		/* mul	r1, r2, rd */
141 #define	DIF_OP_SDIV	9		/* sdiv	r1, r2, rd */
142 #define	DIF_OP_UDIV	10		/* udiv r1, r2, rd */
143 #define	DIF_OP_SREM	11		/* srem r1, r2, rd */
144 #define	DIF_OP_UREM	12		/* urem r1, r2, rd */
145 #define	DIF_OP_NOT	13		/* not	r1, rd */
146 #define	DIF_OP_MOV	14		/* mov	r1, rd */
147 #define	DIF_OP_CMP	15		/* cmp	r1, r2 */
148 #define	DIF_OP_TST	16		/* tst  r1 */
149 #define	DIF_OP_BA	17		/* ba	label */
150 #define	DIF_OP_BE	18		/* be	label */
151 #define	DIF_OP_BNE	19		/* bne	label */
152 #define	DIF_OP_BG	20		/* bg	label */
153 #define	DIF_OP_BGU	21		/* bgu	label */
154 #define	DIF_OP_BGE	22		/* bge	label */
155 #define	DIF_OP_BGEU	23		/* bgeu	label */
156 #define	DIF_OP_BL	24		/* bl	label */
157 #define	DIF_OP_BLU	25		/* blu	label */
158 #define	DIF_OP_BLE	26		/* ble	label */
159 #define	DIF_OP_BLEU	27		/* bleu	label */
160 #define	DIF_OP_LDSB	28		/* ldsb	[r1], rd */
161 #define	DIF_OP_LDSH	29		/* ldsh	[r1], rd */
162 #define	DIF_OP_LDSW	30		/* ldsw [r1], rd */
163 #define	DIF_OP_LDUB	31		/* ldub	[r1], rd */
164 #define	DIF_OP_LDUH	32		/* lduh	[r1], rd */
165 #define	DIF_OP_LDUW	33		/* lduw	[r1], rd */
166 #define	DIF_OP_LDX	34		/* ldx	[r1], rd */
167 #define	DIF_OP_RET	35		/* ret	rd */
168 #define	DIF_OP_NOP	36		/* nop */
169 #define	DIF_OP_SETX	37		/* setx	intindex, rd */
170 #define	DIF_OP_SETS	38		/* sets strindex, rd */
171 #define	DIF_OP_SCMP	39		/* scmp	r1, r2 */
172 #define	DIF_OP_LDGA	40		/* ldga	var, ri, rd */
173 #define	DIF_OP_LDGS	41		/* ldgs var, rd */
174 #define	DIF_OP_STGS	42		/* stgs var, rs */
175 #define	DIF_OP_LDTA	43		/* ldta var, ri, rd */
176 #define	DIF_OP_LDTS	44		/* ldts var, rd */
177 #define	DIF_OP_STTS	45		/* stts var, rs */
178 #define	DIF_OP_SRA	46		/* sra	r1, r2, rd */
179 #define	DIF_OP_CALL	47		/* call	subr, rd */
180 #define	DIF_OP_PUSHTR	48		/* pushtr type, rs, rr */
181 #define	DIF_OP_PUSHTV	49		/* pushtv type, rs, rv */
182 #define	DIF_OP_POPTS	50		/* popts */
183 #define	DIF_OP_FLUSHTS	51		/* flushts */
184 #define	DIF_OP_LDGAA	52		/* ldgaa var, rd */
185 #define	DIF_OP_LDTAA	53		/* ldtaa var, rd */
186 #define	DIF_OP_STGAA	54		/* stgaa var, rs */
187 #define	DIF_OP_STTAA	55		/* sttaa var, rs */
188 #define	DIF_OP_LDLS	56		/* ldls	var, rd */
189 #define	DIF_OP_STLS	57		/* stls	var, rs */
190 #define	DIF_OP_ALLOCS	58		/* allocs r1, rd */
191 #define	DIF_OP_COPYS	59		/* copys  r1, r2, rd */
192 #define	DIF_OP_STB	60		/* stb	r1, [rd] */
193 #define	DIF_OP_STH	61		/* sth	r1, [rd] */
194 #define	DIF_OP_STW	62		/* stw	r1, [rd] */
195 #define	DIF_OP_STX	63		/* stx	r1, [rd] */
196 #define	DIF_OP_ULDSB	64		/* uldsb [r1], rd */
197 #define	DIF_OP_ULDSH	65		/* uldsh [r1], rd */
198 #define	DIF_OP_ULDSW	66		/* uldsw [r1], rd */
199 #define	DIF_OP_ULDUB	67		/* uldub [r1], rd */
200 #define	DIF_OP_ULDUH	68		/* ulduh [r1], rd */
201 #define	DIF_OP_ULDUW	69		/* ulduw [r1], rd */
202 #define	DIF_OP_ULDX	70		/* uldx  [r1], rd */
203 #define	DIF_OP_RLDSB	71		/* rldsb [r1], rd */
204 #define	DIF_OP_RLDSH	72		/* rldsh [r1], rd */
205 #define	DIF_OP_RLDSW	73		/* rldsw [r1], rd */
206 #define	DIF_OP_RLDUB	74		/* rldub [r1], rd */
207 #define	DIF_OP_RLDUH	75		/* rlduh [r1], rd */
208 #define	DIF_OP_RLDUW	76		/* rlduw [r1], rd */
209 #define	DIF_OP_RLDX	77		/* rldx  [r1], rd */
210 #define	DIF_OP_XLATE	78		/* xlate xlrindex, rd */
211 #define	DIF_OP_XLARG	79		/* xlarg xlrindex, rd */
212 
213 #define	DIF_INTOFF_MAX		0xffff	/* highest integer table offset */
214 #define	DIF_STROFF_MAX		0xffff	/* highest string table offset */
215 #define	DIF_REGISTER_MAX	0xff	/* highest register number */
216 #define	DIF_VARIABLE_MAX	0xffff	/* highest variable identifier */
217 #define	DIF_SUBROUTINE_MAX	0xffff	/* highest subroutine code */
218 
219 #define	DIF_VAR_ARRAY_MIN	0x0000	/* lowest numbered array variable */
220 #define	DIF_VAR_ARRAY_UBASE	0x0080	/* lowest user-defined array */
221 #define	DIF_VAR_ARRAY_MAX	0x00ff	/* highest numbered array variable */
222 
223 #define	DIF_VAR_OTHER_MIN	0x0100	/* lowest numbered scalar or assc */
224 #define	DIF_VAR_OTHER_UBASE	0x0500	/* lowest user-defined scalar or assc */
225 #define	DIF_VAR_OTHER_MAX	0xffff	/* highest numbered scalar or assc */
226 
227 #define	DIF_VAR_ARGS		0x0000	/* arguments array */
228 #define	DIF_VAR_REGS		0x0001	/* registers array */
229 #define	DIF_VAR_UREGS		0x0002	/* user registers array */
230 #define	DIF_VAR_CURTHREAD	0x0100	/* thread pointer */
231 #define	DIF_VAR_TIMESTAMP	0x0101	/* timestamp */
232 #define	DIF_VAR_VTIMESTAMP	0x0102	/* virtual timestamp */
233 #define	DIF_VAR_IPL		0x0103	/* interrupt priority level */
234 #define	DIF_VAR_EPID		0x0104	/* enabled probe ID */
235 #define	DIF_VAR_ID		0x0105	/* probe ID */
236 #define	DIF_VAR_ARG0		0x0106	/* first argument */
237 #define	DIF_VAR_ARG1		0x0107	/* second argument */
238 #define	DIF_VAR_ARG2		0x0108	/* third argument */
239 #define	DIF_VAR_ARG3		0x0109	/* fourth argument */
240 #define	DIF_VAR_ARG4		0x010a	/* fifth argument */
241 #define	DIF_VAR_ARG5		0x010b	/* sixth argument */
242 #define	DIF_VAR_ARG6		0x010c	/* seventh argument */
243 #define	DIF_VAR_ARG7		0x010d	/* eighth argument */
244 #define	DIF_VAR_ARG8		0x010e	/* ninth argument */
245 #define	DIF_VAR_ARG9		0x010f	/* tenth argument */
246 #define	DIF_VAR_STACKDEPTH	0x0110	/* stack depth */
247 #define	DIF_VAR_CALLER		0x0111	/* caller */
248 #define	DIF_VAR_PROBEPROV	0x0112	/* probe provider */
249 #define	DIF_VAR_PROBEMOD	0x0113	/* probe module */
250 #define	DIF_VAR_PROBEFUNC	0x0114	/* probe function */
251 #define	DIF_VAR_PROBENAME	0x0115	/* probe name */
252 #define	DIF_VAR_PID		0x0116	/* process ID */
253 #define	DIF_VAR_TID		0x0117	/* (per-process) thread ID */
254 #define	DIF_VAR_EXECNAME	0x0118	/* name of executable */
255 #define	DIF_VAR_ZONENAME	0x0119	/* zone name associated with process */
256 #define	DIF_VAR_WALLTIMESTAMP	0x011a	/* wall-clock timestamp */
257 #define	DIF_VAR_USTACKDEPTH	0x011b	/* user-land stack depth */
258 #define	DIF_VAR_UCALLER		0x011c	/* user-level caller */
259 #define	DIF_VAR_PPID		0x011d	/* parent process ID */
260 #define	DIF_VAR_UID		0x011e	/* process user ID */
261 #define	DIF_VAR_GID		0x011f	/* process group ID */
262 #define	DIF_VAR_ERRNO		0x0120	/* thread errno */
263 #define	DIF_VAR_EXECARGS	0x0121	/* process arguments */
264 #define	DIF_VAR_JID		0x0122	/* process jail id */
265 #define	DIF_VAR_JAILNAME	0x0123	/* process jail name */
266 
267 #ifndef illumos
268 #define	DIF_VAR_CPU		0x0200
269 #endif
270 
271 #define	DIF_SUBR_RAND			0
272 #define	DIF_SUBR_MUTEX_OWNED		1
273 #define	DIF_SUBR_MUTEX_OWNER		2
274 #define	DIF_SUBR_MUTEX_TYPE_ADAPTIVE	3
275 #define	DIF_SUBR_MUTEX_TYPE_SPIN	4
276 #define	DIF_SUBR_RW_READ_HELD		5
277 #define	DIF_SUBR_RW_WRITE_HELD		6
278 #define	DIF_SUBR_RW_ISWRITER		7
279 #define	DIF_SUBR_COPYIN			8
280 #define	DIF_SUBR_COPYINSTR		9
281 #define	DIF_SUBR_SPECULATION		10
282 #define	DIF_SUBR_PROGENYOF		11
283 #define	DIF_SUBR_STRLEN			12
284 #define	DIF_SUBR_COPYOUT		13
285 #define	DIF_SUBR_COPYOUTSTR		14
286 #define	DIF_SUBR_ALLOCA			15
287 #define	DIF_SUBR_BCOPY			16
288 #define	DIF_SUBR_COPYINTO		17
289 #define	DIF_SUBR_MSGDSIZE		18
290 #define	DIF_SUBR_MSGSIZE		19
291 #define	DIF_SUBR_GETMAJOR		20
292 #define	DIF_SUBR_GETMINOR		21
293 #define	DIF_SUBR_DDI_PATHNAME		22
294 #define	DIF_SUBR_STRJOIN		23
295 #define	DIF_SUBR_LLTOSTR		24
296 #define	DIF_SUBR_BASENAME		25
297 #define	DIF_SUBR_DIRNAME		26
298 #define	DIF_SUBR_CLEANPATH		27
299 #define	DIF_SUBR_STRCHR			28
300 #define	DIF_SUBR_STRRCHR		29
301 #define	DIF_SUBR_STRSTR			30
302 #define	DIF_SUBR_STRTOK			31
303 #define	DIF_SUBR_SUBSTR			32
304 #define	DIF_SUBR_INDEX			33
305 #define	DIF_SUBR_RINDEX			34
306 #define	DIF_SUBR_HTONS			35
307 #define	DIF_SUBR_HTONL			36
308 #define	DIF_SUBR_HTONLL			37
309 #define	DIF_SUBR_NTOHS			38
310 #define	DIF_SUBR_NTOHL			39
311 #define	DIF_SUBR_NTOHLL			40
312 #define	DIF_SUBR_INET_NTOP		41
313 #define	DIF_SUBR_INET_NTOA		42
314 #define	DIF_SUBR_INET_NTOA6		43
315 #define	DIF_SUBR_TOUPPER		44
316 #define	DIF_SUBR_TOLOWER		45
317 #define	DIF_SUBR_MEMREF			46
318 #define	DIF_SUBR_SX_SHARED_HELD		47
319 #define	DIF_SUBR_SX_EXCLUSIVE_HELD	48
320 #define	DIF_SUBR_SX_ISEXCLUSIVE		49
321 #define	DIF_SUBR_MEMSTR			50
322 #define	DIF_SUBR_GETF			51
323 #define	DIF_SUBR_JSON			52
324 #define	DIF_SUBR_STRTOLL		53
325 #define	DIF_SUBR_MAX			53	/* max subroutine value */
326 
327 typedef uint32_t dif_instr_t;
328 
329 #define	DIF_INSTR_OP(i)			(((i) >> 24) & 0xff)
330 #define	DIF_INSTR_R1(i)			(((i) >> 16) & 0xff)
331 #define	DIF_INSTR_R2(i)			(((i) >>  8) & 0xff)
332 #define	DIF_INSTR_RD(i)			((i) & 0xff)
333 #define	DIF_INSTR_RS(i)			((i) & 0xff)
334 #define	DIF_INSTR_LABEL(i)		((i) & 0xffffff)
335 #define	DIF_INSTR_VAR(i)		(((i) >>  8) & 0xffff)
336 #define	DIF_INSTR_INTEGER(i)		(((i) >>  8) & 0xffff)
337 #define	DIF_INSTR_STRING(i)		(((i) >>  8) & 0xffff)
338 #define	DIF_INSTR_SUBR(i)		(((i) >>  8) & 0xffff)
339 #define	DIF_INSTR_TYPE(i)		(((i) >> 16) & 0xff)
340 #define	DIF_INSTR_XLREF(i)		(((i) >>  8) & 0xffff)
341 
342 #define	DIF_INSTR_FMT(op, r1, r2, d) \
343 	(((op) << 24) | ((r1) << 16) | ((r2) << 8) | (d))
344 
345 #define	DIF_INSTR_NOT(r1, d)		(DIF_INSTR_FMT(DIF_OP_NOT, r1, 0, d))
346 #define	DIF_INSTR_MOV(r1, d)		(DIF_INSTR_FMT(DIF_OP_MOV, r1, 0, d))
347 #define	DIF_INSTR_CMP(op, r1, r2)	(DIF_INSTR_FMT(op, r1, r2, 0))
348 #define	DIF_INSTR_TST(r1)		(DIF_INSTR_FMT(DIF_OP_TST, r1, 0, 0))
349 #define	DIF_INSTR_BRANCH(op, label)	(((op) << 24) | (label))
350 #define	DIF_INSTR_LOAD(op, r1, d)	(DIF_INSTR_FMT(op, r1, 0, d))
351 #define	DIF_INSTR_STORE(op, r1, d)	(DIF_INSTR_FMT(op, r1, 0, d))
352 #define	DIF_INSTR_SETX(i, d)		((DIF_OP_SETX << 24) | ((i) << 8) | (d))
353 #define	DIF_INSTR_SETS(s, d)		((DIF_OP_SETS << 24) | ((s) << 8) | (d))
354 #define	DIF_INSTR_RET(d)		(DIF_INSTR_FMT(DIF_OP_RET, 0, 0, d))
355 #define	DIF_INSTR_NOP			(DIF_OP_NOP << 24)
356 #define	DIF_INSTR_LDA(op, v, r, d)	(DIF_INSTR_FMT(op, v, r, d))
357 #define	DIF_INSTR_LDV(op, v, d)		(((op) << 24) | ((v) << 8) | (d))
358 #define	DIF_INSTR_STV(op, v, rs)	(((op) << 24) | ((v) << 8) | (rs))
359 #define	DIF_INSTR_CALL(s, d)		((DIF_OP_CALL << 24) | ((s) << 8) | (d))
360 #define	DIF_INSTR_PUSHTS(op, t, r2, rs)	(DIF_INSTR_FMT(op, t, r2, rs))
361 #define	DIF_INSTR_POPTS			(DIF_OP_POPTS << 24)
362 #define	DIF_INSTR_FLUSHTS		(DIF_OP_FLUSHTS << 24)
363 #define	DIF_INSTR_ALLOCS(r1, d)		(DIF_INSTR_FMT(DIF_OP_ALLOCS, r1, 0, d))
364 #define	DIF_INSTR_COPYS(r1, r2, d)	(DIF_INSTR_FMT(DIF_OP_COPYS, r1, r2, d))
365 #define	DIF_INSTR_XLATE(op, r, d)	(((op) << 24) | ((r) << 8) | (d))
366 
367 #define	DIF_REG_R0	0		/* %r0 is always set to zero */
368 
369 /*
370  * A DTrace Intermediate Format Type (DIF Type) is used to represent the types
371  * of variables, function and associative array arguments, and the return type
372  * for each DIF object (shown below).  It contains a description of the type,
373  * its size in bytes, and a module identifier.
374  */
375 typedef struct dtrace_diftype {
376 	uint8_t dtdt_kind;		/* type kind (see below) */
377 	uint8_t dtdt_ckind;		/* type kind in CTF */
378 	uint8_t dtdt_flags;		/* type flags (see below) */
379 	uint8_t dtdt_pad;		/* reserved for future use */
380 	uint32_t dtdt_size;		/* type size in bytes (unless string) */
381 } dtrace_diftype_t;
382 
383 #define	DIF_TYPE_CTF		0	/* type is a CTF type */
384 #define	DIF_TYPE_STRING		1	/* type is a D string */
385 
386 #define	DIF_TF_BYREF		0x1	/* type is passed by reference */
387 #define	DIF_TF_BYUREF		0x2	/* user type is passed by reference */
388 
389 /*
390  * A DTrace Intermediate Format variable record is used to describe each of the
391  * variables referenced by a given DIF object.  It contains an integer variable
392  * identifier along with variable scope and properties, as shown below.  The
393  * size of this structure must be sizeof (int) aligned.
394  */
395 typedef struct dtrace_difv {
396 	uint32_t dtdv_name;		/* variable name index in dtdo_strtab */
397 	uint32_t dtdv_id;		/* variable reference identifier */
398 	uint8_t dtdv_kind;		/* variable kind (see below) */
399 	uint8_t dtdv_scope;		/* variable scope (see below) */
400 	uint16_t dtdv_flags;		/* variable flags (see below) */
401 	dtrace_diftype_t dtdv_type;	/* variable type (see above) */
402 } dtrace_difv_t;
403 
404 #define	DIFV_KIND_ARRAY		0	/* variable is an array of quantities */
405 #define	DIFV_KIND_SCALAR	1	/* variable is a scalar quantity */
406 
407 #define	DIFV_SCOPE_GLOBAL	0	/* variable has global scope */
408 #define	DIFV_SCOPE_THREAD	1	/* variable has thread scope */
409 #define	DIFV_SCOPE_LOCAL	2	/* variable has local scope */
410 
411 #define	DIFV_F_REF		0x1	/* variable is referenced by DIFO */
412 #define	DIFV_F_MOD		0x2	/* variable is written by DIFO */
413 
414 /*
415  * DTrace Actions
416  *
417  * The upper byte determines the class of the action; the low bytes determines
418  * the specific action within that class.  The classes of actions are as
419  * follows:
420  *
421  *   [ no class ]                  <= May record process- or kernel-related data
422  *   DTRACEACT_PROC                <= Only records process-related data
423  *   DTRACEACT_PROC_DESTRUCTIVE    <= Potentially destructive to processes
424  *   DTRACEACT_KERNEL              <= Only records kernel-related data
425  *   DTRACEACT_KERNEL_DESTRUCTIVE  <= Potentially destructive to the kernel
426  *   DTRACEACT_SPECULATIVE         <= Speculation-related action
427  *   DTRACEACT_AGGREGATION         <= Aggregating action
428  */
429 #define	DTRACEACT_NONE			0	/* no action */
430 #define	DTRACEACT_DIFEXPR		1	/* action is DIF expression */
431 #define	DTRACEACT_EXIT			2	/* exit() action */
432 #define	DTRACEACT_PRINTF		3	/* printf() action */
433 #define	DTRACEACT_PRINTA		4	/* printa() action */
434 #define	DTRACEACT_LIBACT		5	/* library-controlled action */
435 #define	DTRACEACT_TRACEMEM		6	/* tracemem() action */
436 #define	DTRACEACT_TRACEMEM_DYNSIZE	7	/* dynamic tracemem() size */
437 #define	DTRACEACT_PRINTM		8	/* printm() action (BSD) */
438 
439 #define	DTRACEACT_PROC			0x0100
440 #define	DTRACEACT_USTACK		(DTRACEACT_PROC + 1)
441 #define	DTRACEACT_JSTACK		(DTRACEACT_PROC + 2)
442 #define	DTRACEACT_USYM			(DTRACEACT_PROC + 3)
443 #define	DTRACEACT_UMOD			(DTRACEACT_PROC + 4)
444 #define	DTRACEACT_UADDR			(DTRACEACT_PROC + 5)
445 
446 #define	DTRACEACT_PROC_DESTRUCTIVE	0x0200
447 #define	DTRACEACT_STOP			(DTRACEACT_PROC_DESTRUCTIVE + 1)
448 #define	DTRACEACT_RAISE			(DTRACEACT_PROC_DESTRUCTIVE + 2)
449 #define	DTRACEACT_SYSTEM		(DTRACEACT_PROC_DESTRUCTIVE + 3)
450 #define	DTRACEACT_FREOPEN		(DTRACEACT_PROC_DESTRUCTIVE + 4)
451 
452 #define	DTRACEACT_PROC_CONTROL		0x0300
453 
454 #define	DTRACEACT_KERNEL		0x0400
455 #define	DTRACEACT_STACK			(DTRACEACT_KERNEL + 1)
456 #define	DTRACEACT_SYM			(DTRACEACT_KERNEL + 2)
457 #define	DTRACEACT_MOD			(DTRACEACT_KERNEL + 3)
458 
459 #define	DTRACEACT_KERNEL_DESTRUCTIVE	0x0500
460 #define	DTRACEACT_BREAKPOINT		(DTRACEACT_KERNEL_DESTRUCTIVE + 1)
461 #define	DTRACEACT_PANIC			(DTRACEACT_KERNEL_DESTRUCTIVE + 2)
462 #define	DTRACEACT_CHILL			(DTRACEACT_KERNEL_DESTRUCTIVE + 3)
463 
464 #define	DTRACEACT_SPECULATIVE		0x0600
465 #define	DTRACEACT_SPECULATE		(DTRACEACT_SPECULATIVE + 1)
466 #define	DTRACEACT_COMMIT		(DTRACEACT_SPECULATIVE + 2)
467 #define	DTRACEACT_DISCARD		(DTRACEACT_SPECULATIVE + 3)
468 
469 #define	DTRACEACT_CLASS(x)		((x) & 0xff00)
470 
471 #define	DTRACEACT_ISDESTRUCTIVE(x)	\
472 	(DTRACEACT_CLASS(x) == DTRACEACT_PROC_DESTRUCTIVE || \
473 	DTRACEACT_CLASS(x) == DTRACEACT_KERNEL_DESTRUCTIVE)
474 
475 #define	DTRACEACT_ISSPECULATIVE(x)	\
476 	(DTRACEACT_CLASS(x) == DTRACEACT_SPECULATIVE)
477 
478 #define	DTRACEACT_ISPRINTFLIKE(x)	\
479 	((x) == DTRACEACT_PRINTF || (x) == DTRACEACT_PRINTA || \
480 	(x) == DTRACEACT_SYSTEM || (x) == DTRACEACT_FREOPEN)
481 
482 /*
483  * DTrace Aggregating Actions
484  *
485  * These are functions f(x) for which the following is true:
486  *
487  *    f(f(x_0) U f(x_1) U ... U f(x_n)) = f(x_0 U x_1 U ... U x_n)
488  *
489  * where x_n is a set of arbitrary data.  Aggregating actions are in their own
490  * DTrace action class, DTTRACEACT_AGGREGATION.  The macros provided here allow
491  * for easier processing of the aggregation argument and data payload for a few
492  * aggregating actions (notably:  quantize(), lquantize(), and ustack()).
493  */
494 #define	DTRACEACT_AGGREGATION		0x0700
495 #define	DTRACEAGG_COUNT			(DTRACEACT_AGGREGATION + 1)
496 #define	DTRACEAGG_MIN			(DTRACEACT_AGGREGATION + 2)
497 #define	DTRACEAGG_MAX			(DTRACEACT_AGGREGATION + 3)
498 #define	DTRACEAGG_AVG			(DTRACEACT_AGGREGATION + 4)
499 #define	DTRACEAGG_SUM			(DTRACEACT_AGGREGATION + 5)
500 #define	DTRACEAGG_STDDEV		(DTRACEACT_AGGREGATION + 6)
501 #define	DTRACEAGG_QUANTIZE		(DTRACEACT_AGGREGATION + 7)
502 #define	DTRACEAGG_LQUANTIZE		(DTRACEACT_AGGREGATION + 8)
503 #define	DTRACEAGG_LLQUANTIZE		(DTRACEACT_AGGREGATION + 9)
504 
505 #define	DTRACEACT_ISAGG(x)		\
506 	(DTRACEACT_CLASS(x) == DTRACEACT_AGGREGATION)
507 
508 #define	DTRACE_QUANTIZE_NBUCKETS	\
509 	(((sizeof (uint64_t) * NBBY) - 1) * 2 + 1)
510 
511 #define	DTRACE_QUANTIZE_ZEROBUCKET	((sizeof (uint64_t) * NBBY) - 1)
512 
513 #define	DTRACE_QUANTIZE_BUCKETVAL(buck)					\
514 	(int64_t)((buck) < DTRACE_QUANTIZE_ZEROBUCKET ?			\
515 	-(1LL << (DTRACE_QUANTIZE_ZEROBUCKET - 1 - (buck))) :		\
516 	(buck) == DTRACE_QUANTIZE_ZEROBUCKET ? 0 :			\
517 	1LL << ((buck) - DTRACE_QUANTIZE_ZEROBUCKET - 1))
518 
519 #define	DTRACE_LQUANTIZE_STEPSHIFT		48
520 #define	DTRACE_LQUANTIZE_STEPMASK		((uint64_t)UINT16_MAX << 48)
521 #define	DTRACE_LQUANTIZE_LEVELSHIFT		32
522 #define	DTRACE_LQUANTIZE_LEVELMASK		((uint64_t)UINT16_MAX << 32)
523 #define	DTRACE_LQUANTIZE_BASESHIFT		0
524 #define	DTRACE_LQUANTIZE_BASEMASK		UINT32_MAX
525 
526 #define	DTRACE_LQUANTIZE_STEP(x)		\
527 	(uint16_t)(((x) & DTRACE_LQUANTIZE_STEPMASK) >> \
528 	DTRACE_LQUANTIZE_STEPSHIFT)
529 
530 #define	DTRACE_LQUANTIZE_LEVELS(x)		\
531 	(uint16_t)(((x) & DTRACE_LQUANTIZE_LEVELMASK) >> \
532 	DTRACE_LQUANTIZE_LEVELSHIFT)
533 
534 #define	DTRACE_LQUANTIZE_BASE(x)		\
535 	(int32_t)(((x) & DTRACE_LQUANTIZE_BASEMASK) >> \
536 	DTRACE_LQUANTIZE_BASESHIFT)
537 
538 #define	DTRACE_LLQUANTIZE_FACTORSHIFT		48
539 #define	DTRACE_LLQUANTIZE_FACTORMASK		((uint64_t)UINT16_MAX << 48)
540 #define	DTRACE_LLQUANTIZE_LOWSHIFT		32
541 #define	DTRACE_LLQUANTIZE_LOWMASK		((uint64_t)UINT16_MAX << 32)
542 #define	DTRACE_LLQUANTIZE_HIGHSHIFT		16
543 #define	DTRACE_LLQUANTIZE_HIGHMASK		((uint64_t)UINT16_MAX << 16)
544 #define	DTRACE_LLQUANTIZE_NSTEPSHIFT		0
545 #define	DTRACE_LLQUANTIZE_NSTEPMASK		UINT16_MAX
546 
547 #define	DTRACE_LLQUANTIZE_FACTOR(x)		\
548 	(uint16_t)(((x) & DTRACE_LLQUANTIZE_FACTORMASK) >> \
549 	DTRACE_LLQUANTIZE_FACTORSHIFT)
550 
551 #define	DTRACE_LLQUANTIZE_LOW(x)		\
552 	(uint16_t)(((x) & DTRACE_LLQUANTIZE_LOWMASK) >> \
553 	DTRACE_LLQUANTIZE_LOWSHIFT)
554 
555 #define	DTRACE_LLQUANTIZE_HIGH(x)		\
556 	(uint16_t)(((x) & DTRACE_LLQUANTIZE_HIGHMASK) >> \
557 	DTRACE_LLQUANTIZE_HIGHSHIFT)
558 
559 #define	DTRACE_LLQUANTIZE_NSTEP(x)		\
560 	(uint16_t)(((x) & DTRACE_LLQUANTIZE_NSTEPMASK) >> \
561 	DTRACE_LLQUANTIZE_NSTEPSHIFT)
562 
563 #define	DTRACE_USTACK_NFRAMES(x)	(uint32_t)((x) & UINT32_MAX)
564 #define	DTRACE_USTACK_STRSIZE(x)	(uint32_t)((x) >> 32)
565 #define	DTRACE_USTACK_ARG(x, y)		\
566 	((((uint64_t)(y)) << 32) | ((x) & UINT32_MAX))
567 
568 #ifndef _LP64
569 #if BYTE_ORDER == _BIG_ENDIAN
570 #define	DTRACE_PTR(type, name)	uint32_t name##pad; type *name
571 #else
572 #define	DTRACE_PTR(type, name)	type *name; uint32_t name##pad
573 #endif
574 #else
575 #define	DTRACE_PTR(type, name)	type *name
576 #endif
577 
578 /*
579  * DTrace Object Format (DOF)
580  *
581  * DTrace programs can be persistently encoded in the DOF format so that they
582  * may be embedded in other programs (for example, in an ELF file) or in the
583  * dtrace driver configuration file for use in anonymous tracing.  The DOF
584  * format is versioned and extensible so that it can be revised and so that
585  * internal data structures can be modified or extended compatibly.  All DOF
586  * structures use fixed-size types, so the 32-bit and 64-bit representations
587  * are identical and consumers can use either data model transparently.
588  *
589  * The file layout is structured as follows:
590  *
591  * +---------------+-------------------+----- ... ----+---- ... ------+
592  * |   dof_hdr_t   |  dof_sec_t[ ... ] |   loadable   | non-loadable  |
593  * | (file header) | (section headers) | section data | section data  |
594  * +---------------+-------------------+----- ... ----+---- ... ------+
595  * |<------------ dof_hdr.dofh_loadsz --------------->|               |
596  * |<------------ dof_hdr.dofh_filesz ------------------------------->|
597  *
598  * The file header stores meta-data including a magic number, data model for
599  * the instrumentation, data encoding, and properties of the DIF code within.
600  * The header describes its own size and the size of the section headers.  By
601  * convention, an array of section headers follows the file header, and then
602  * the data for all loadable sections and unloadable sections.  This permits
603  * consumer code to easily download the headers and all loadable data into the
604  * DTrace driver in one contiguous chunk, omitting other extraneous sections.
605  *
606  * The section headers describe the size, offset, alignment, and section type
607  * for each section.  Sections are described using a set of #defines that tell
608  * the consumer what kind of data is expected.  Sections can contain links to
609  * other sections by storing a dof_secidx_t, an index into the section header
610  * array, inside of the section data structures.  The section header includes
611  * an entry size so that sections with data arrays can grow their structures.
612  *
613  * The DOF data itself can contain many snippets of DIF (i.e. >1 DIFOs), which
614  * are represented themselves as a collection of related DOF sections.  This
615  * permits us to change the set of sections associated with a DIFO over time,
616  * and also permits us to encode DIFOs that contain different sets of sections.
617  * When a DOF section wants to refer to a DIFO, it stores the dof_secidx_t of a
618  * section of type DOF_SECT_DIFOHDR.  This section's data is then an array of
619  * dof_secidx_t's which in turn denote the sections associated with this DIFO.
620  *
621  * This loose coupling of the file structure (header and sections) to the
622  * structure of the DTrace program itself (ECB descriptions, action
623  * descriptions, and DIFOs) permits activities such as relocation processing
624  * to occur in a single pass without having to understand D program structure.
625  *
626  * Finally, strings are always stored in ELF-style string tables along with a
627  * string table section index and string table offset.  Therefore strings in
628  * DOF are always arbitrary-length and not bound to the current implementation.
629  */
630 
631 #define	DOF_ID_SIZE	16	/* total size of dofh_ident[] in bytes */
632 
633 typedef struct dof_hdr {
634 	uint8_t dofh_ident[DOF_ID_SIZE]; /* identification bytes (see below) */
635 	uint32_t dofh_flags;		/* file attribute flags (if any) */
636 	uint32_t dofh_hdrsize;		/* size of file header in bytes */
637 	uint32_t dofh_secsize;		/* size of section header in bytes */
638 	uint32_t dofh_secnum;		/* number of section headers */
639 	uint64_t dofh_secoff;		/* file offset of section headers */
640 	uint64_t dofh_loadsz;		/* file size of loadable portion */
641 	uint64_t dofh_filesz;		/* file size of entire DOF file */
642 	uint64_t dofh_pad;		/* reserved for future use */
643 } dof_hdr_t;
644 
645 #define	DOF_ID_MAG0	0	/* first byte of magic number */
646 #define	DOF_ID_MAG1	1	/* second byte of magic number */
647 #define	DOF_ID_MAG2	2	/* third byte of magic number */
648 #define	DOF_ID_MAG3	3	/* fourth byte of magic number */
649 #define	DOF_ID_MODEL	4	/* DOF data model (see below) */
650 #define	DOF_ID_ENCODING	5	/* DOF data encoding (see below) */
651 #define	DOF_ID_VERSION	6	/* DOF file format major version (see below) */
652 #define	DOF_ID_DIFVERS	7	/* DIF instruction set version */
653 #define	DOF_ID_DIFIREG	8	/* DIF integer registers used by compiler */
654 #define	DOF_ID_DIFTREG	9	/* DIF tuple registers used by compiler */
655 #define	DOF_ID_PAD	10	/* start of padding bytes (all zeroes) */
656 
657 #define	DOF_MAG_MAG0	0x7F	/* DOF_ID_MAG[0-3] */
658 #define	DOF_MAG_MAG1	'D'
659 #define	DOF_MAG_MAG2	'O'
660 #define	DOF_MAG_MAG3	'F'
661 
662 #define	DOF_MAG_STRING	"\177DOF"
663 #define	DOF_MAG_STRLEN	4
664 
665 #define	DOF_MODEL_NONE	0	/* DOF_ID_MODEL */
666 #define	DOF_MODEL_ILP32	1
667 #define	DOF_MODEL_LP64	2
668 
669 #ifdef _LP64
670 #define	DOF_MODEL_NATIVE	DOF_MODEL_LP64
671 #else
672 #define	DOF_MODEL_NATIVE	DOF_MODEL_ILP32
673 #endif
674 
675 #define	DOF_ENCODE_NONE	0	/* DOF_ID_ENCODING */
676 #define	DOF_ENCODE_LSB	1
677 #define	DOF_ENCODE_MSB	2
678 
679 #if BYTE_ORDER == _BIG_ENDIAN
680 #define	DOF_ENCODE_NATIVE	DOF_ENCODE_MSB
681 #else
682 #define	DOF_ENCODE_NATIVE	DOF_ENCODE_LSB
683 #endif
684 
685 #define	DOF_VERSION_1	1	/* DOF version 1: Solaris 10 FCS */
686 #define	DOF_VERSION_2	2	/* DOF version 2: Solaris Express 6/06 */
687 #define	DOF_VERSION	DOF_VERSION_2	/* Latest DOF version */
688 
689 #define	DOF_FL_VALID	0	/* mask of all valid dofh_flags bits */
690 
691 typedef uint32_t dof_secidx_t;	/* section header table index type */
692 typedef uint32_t dof_stridx_t;	/* string table index type */
693 
694 #define	DOF_SECIDX_NONE	(-1U)	/* null value for section indices */
695 #define	DOF_STRIDX_NONE	(-1U)	/* null value for string indices */
696 
697 typedef struct dof_sec {
698 	uint32_t dofs_type;	/* section type (see below) */
699 	uint32_t dofs_align;	/* section data memory alignment */
700 	uint32_t dofs_flags;	/* section flags (if any) */
701 	uint32_t dofs_entsize;	/* size of section entry (if table) */
702 	uint64_t dofs_offset;	/* offset of section data within file */
703 	uint64_t dofs_size;	/* size of section data in bytes */
704 } dof_sec_t;
705 
706 #define	DOF_SECT_NONE		0	/* null section */
707 #define	DOF_SECT_COMMENTS	1	/* compiler comments */
708 #define	DOF_SECT_SOURCE		2	/* D program source code */
709 #define	DOF_SECT_ECBDESC	3	/* dof_ecbdesc_t */
710 #define	DOF_SECT_PROBEDESC	4	/* dof_probedesc_t */
711 #define	DOF_SECT_ACTDESC	5	/* dof_actdesc_t array */
712 #define	DOF_SECT_DIFOHDR	6	/* dof_difohdr_t (variable length) */
713 #define	DOF_SECT_DIF		7	/* uint32_t array of byte code */
714 #define	DOF_SECT_STRTAB		8	/* string table */
715 #define	DOF_SECT_VARTAB		9	/* dtrace_difv_t array */
716 #define	DOF_SECT_RELTAB		10	/* dof_relodesc_t array */
717 #define	DOF_SECT_TYPTAB		11	/* dtrace_diftype_t array */
718 #define	DOF_SECT_URELHDR	12	/* dof_relohdr_t (user relocations) */
719 #define	DOF_SECT_KRELHDR	13	/* dof_relohdr_t (kernel relocations) */
720 #define	DOF_SECT_OPTDESC	14	/* dof_optdesc_t array */
721 #define	DOF_SECT_PROVIDER	15	/* dof_provider_t */
722 #define	DOF_SECT_PROBES		16	/* dof_probe_t array */
723 #define	DOF_SECT_PRARGS		17	/* uint8_t array (probe arg mappings) */
724 #define	DOF_SECT_PROFFS		18	/* uint32_t array (probe arg offsets) */
725 #define	DOF_SECT_INTTAB		19	/* uint64_t array */
726 #define	DOF_SECT_UTSNAME	20	/* struct utsname */
727 #define	DOF_SECT_XLTAB		21	/* dof_xlref_t array */
728 #define	DOF_SECT_XLMEMBERS	22	/* dof_xlmember_t array */
729 #define	DOF_SECT_XLIMPORT	23	/* dof_xlator_t */
730 #define	DOF_SECT_XLEXPORT	24	/* dof_xlator_t */
731 #define	DOF_SECT_PREXPORT	25	/* dof_secidx_t array (exported objs) */
732 #define	DOF_SECT_PRENOFFS	26	/* uint32_t array (enabled offsets) */
733 
734 #define	DOF_SECF_LOAD		1	/* section should be loaded */
735 
736 #define	DOF_SEC_ISLOADABLE(x)						\
737 	(((x) == DOF_SECT_ECBDESC) || ((x) == DOF_SECT_PROBEDESC) ||	\
738 	((x) == DOF_SECT_ACTDESC) || ((x) == DOF_SECT_DIFOHDR) ||	\
739 	((x) == DOF_SECT_DIF) || ((x) == DOF_SECT_STRTAB) ||		\
740 	((x) == DOF_SECT_VARTAB) || ((x) == DOF_SECT_RELTAB) ||		\
741 	((x) == DOF_SECT_TYPTAB) || ((x) == DOF_SECT_URELHDR) ||	\
742 	((x) == DOF_SECT_KRELHDR) || ((x) == DOF_SECT_OPTDESC) ||	\
743 	((x) == DOF_SECT_PROVIDER) || ((x) == DOF_SECT_PROBES) ||	\
744 	((x) == DOF_SECT_PRARGS) || ((x) == DOF_SECT_PROFFS) ||		\
745 	((x) == DOF_SECT_INTTAB) || ((x) == DOF_SECT_XLTAB) ||		\
746 	((x) == DOF_SECT_XLMEMBERS) || ((x) == DOF_SECT_XLIMPORT) ||	\
747 	((x) == DOF_SECT_XLEXPORT) ||  ((x) == DOF_SECT_PREXPORT) || 	\
748 	((x) == DOF_SECT_PRENOFFS))
749 
750 typedef struct dof_ecbdesc {
751 	dof_secidx_t dofe_probes;	/* link to DOF_SECT_PROBEDESC */
752 	dof_secidx_t dofe_pred;		/* link to DOF_SECT_DIFOHDR */
753 	dof_secidx_t dofe_actions;	/* link to DOF_SECT_ACTDESC */
754 	uint32_t dofe_pad;		/* reserved for future use */
755 	uint64_t dofe_uarg;		/* user-supplied library argument */
756 } dof_ecbdesc_t;
757 
758 typedef struct dof_probedesc {
759 	dof_secidx_t dofp_strtab;	/* link to DOF_SECT_STRTAB section */
760 	dof_stridx_t dofp_provider;	/* provider string */
761 	dof_stridx_t dofp_mod;		/* module string */
762 	dof_stridx_t dofp_func;		/* function string */
763 	dof_stridx_t dofp_name;		/* name string */
764 	uint32_t dofp_id;		/* probe identifier (or zero) */
765 } dof_probedesc_t;
766 
767 typedef struct dof_actdesc {
768 	dof_secidx_t dofa_difo;		/* link to DOF_SECT_DIFOHDR */
769 	dof_secidx_t dofa_strtab;	/* link to DOF_SECT_STRTAB section */
770 	uint32_t dofa_kind;		/* action kind (DTRACEACT_* constant) */
771 	uint32_t dofa_ntuple;		/* number of subsequent tuple actions */
772 	uint64_t dofa_arg;		/* kind-specific argument */
773 	uint64_t dofa_uarg;		/* user-supplied argument */
774 } dof_actdesc_t;
775 
776 typedef struct dof_difohdr {
777 	dtrace_diftype_t dofd_rtype;	/* return type for this fragment */
778 	dof_secidx_t dofd_links[1];	/* variable length array of indices */
779 } dof_difohdr_t;
780 
781 typedef struct dof_relohdr {
782 	dof_secidx_t dofr_strtab;	/* link to DOF_SECT_STRTAB for names */
783 	dof_secidx_t dofr_relsec;	/* link to DOF_SECT_RELTAB for relos */
784 	dof_secidx_t dofr_tgtsec;	/* link to section we are relocating */
785 } dof_relohdr_t;
786 
787 typedef struct dof_relodesc {
788 	dof_stridx_t dofr_name;		/* string name of relocation symbol */
789 	uint32_t dofr_type;		/* relo type (DOF_RELO_* constant) */
790 	uint64_t dofr_offset;		/* byte offset for relocation */
791 	uint64_t dofr_data;		/* additional type-specific data */
792 } dof_relodesc_t;
793 
794 #define	DOF_RELO_NONE	0		/* empty relocation entry */
795 #define	DOF_RELO_SETX	1		/* relocate setx value */
796 #define	DOF_RELO_DOFREL	2		/* relocate DOF-relative value */
797 
798 typedef struct dof_optdesc {
799 	uint32_t dofo_option;		/* option identifier */
800 	dof_secidx_t dofo_strtab;	/* string table, if string option */
801 	uint64_t dofo_value;		/* option value or string index */
802 } dof_optdesc_t;
803 
804 typedef uint32_t dof_attr_t;		/* encoded stability attributes */
805 
806 #define	DOF_ATTR(n, d, c)	(((n) << 24) | ((d) << 16) | ((c) << 8))
807 #define	DOF_ATTR_NAME(a)	(((a) >> 24) & 0xff)
808 #define	DOF_ATTR_DATA(a)	(((a) >> 16) & 0xff)
809 #define	DOF_ATTR_CLASS(a)	(((a) >>  8) & 0xff)
810 
811 typedef struct dof_provider {
812 	dof_secidx_t dofpv_strtab;	/* link to DOF_SECT_STRTAB section */
813 	dof_secidx_t dofpv_probes;	/* link to DOF_SECT_PROBES section */
814 	dof_secidx_t dofpv_prargs;	/* link to DOF_SECT_PRARGS section */
815 	dof_secidx_t dofpv_proffs;	/* link to DOF_SECT_PROFFS section */
816 	dof_stridx_t dofpv_name;	/* provider name string */
817 	dof_attr_t dofpv_provattr;	/* provider attributes */
818 	dof_attr_t dofpv_modattr;	/* module attributes */
819 	dof_attr_t dofpv_funcattr;	/* function attributes */
820 	dof_attr_t dofpv_nameattr;	/* name attributes */
821 	dof_attr_t dofpv_argsattr;	/* args attributes */
822 	dof_secidx_t dofpv_prenoffs;	/* link to DOF_SECT_PRENOFFS section */
823 } dof_provider_t;
824 
825 typedef struct dof_probe {
826 	uint64_t dofpr_addr;		/* probe base address or offset */
827 	dof_stridx_t dofpr_func;	/* probe function string */
828 	dof_stridx_t dofpr_name;	/* probe name string */
829 	dof_stridx_t dofpr_nargv;	/* native argument type strings */
830 	dof_stridx_t dofpr_xargv;	/* translated argument type strings */
831 	uint32_t dofpr_argidx;		/* index of first argument mapping */
832 	uint32_t dofpr_offidx;		/* index of first offset entry */
833 	uint8_t dofpr_nargc;		/* native argument count */
834 	uint8_t dofpr_xargc;		/* translated argument count */
835 	uint16_t dofpr_noffs;		/* number of offset entries for probe */
836 	uint32_t dofpr_enoffidx;	/* index of first is-enabled offset */
837 	uint16_t dofpr_nenoffs;		/* number of is-enabled offsets */
838 	uint16_t dofpr_pad1;		/* reserved for future use */
839 	uint32_t dofpr_pad2;		/* reserved for future use */
840 } dof_probe_t;
841 
842 typedef struct dof_xlator {
843 	dof_secidx_t dofxl_members;	/* link to DOF_SECT_XLMEMBERS section */
844 	dof_secidx_t dofxl_strtab;	/* link to DOF_SECT_STRTAB section */
845 	dof_stridx_t dofxl_argv;	/* input parameter type strings */
846 	uint32_t dofxl_argc;		/* input parameter list length */
847 	dof_stridx_t dofxl_type;	/* output type string name */
848 	dof_attr_t dofxl_attr;		/* output stability attributes */
849 } dof_xlator_t;
850 
851 typedef struct dof_xlmember {
852 	dof_secidx_t dofxm_difo;	/* member link to DOF_SECT_DIFOHDR */
853 	dof_stridx_t dofxm_name;	/* member name */
854 	dtrace_diftype_t dofxm_type;	/* member type */
855 } dof_xlmember_t;
856 
857 typedef struct dof_xlref {
858 	dof_secidx_t dofxr_xlator;	/* link to DOF_SECT_XLATORS section */
859 	uint32_t dofxr_member;		/* index of referenced dof_xlmember */
860 	uint32_t dofxr_argn;		/* index of argument for DIF_OP_XLARG */
861 } dof_xlref_t;
862 
863 /*
864  * DTrace Intermediate Format Object (DIFO)
865  *
866  * A DIFO is used to store the compiled DIF for a D expression, its return
867  * type, and its string and variable tables.  The string table is a single
868  * buffer of character data into which sets instructions and variable
869  * references can reference strings using a byte offset.  The variable table
870  * is an array of dtrace_difv_t structures that describe the name and type of
871  * each variable and the id used in the DIF code.  This structure is described
872  * above in the DIF section of this header file.  The DIFO is used at both
873  * user-level (in the library) and in the kernel, but the structure is never
874  * passed between the two: the DOF structures form the only interface.  As a
875  * result, the definition can change depending on the presence of _KERNEL.
876  */
877 typedef struct dtrace_difo {
878 	dif_instr_t *dtdo_buf;		/* instruction buffer */
879 	uint64_t *dtdo_inttab;		/* integer table (optional) */
880 	char *dtdo_strtab;		/* string table (optional) */
881 	dtrace_difv_t *dtdo_vartab;	/* variable table (optional) */
882 	uint_t dtdo_len;		/* length of instruction buffer */
883 	uint_t dtdo_intlen;		/* length of integer table */
884 	uint_t dtdo_strlen;		/* length of string table */
885 	uint_t dtdo_varlen;		/* length of variable table */
886 	dtrace_diftype_t dtdo_rtype;	/* return type */
887 	uint_t dtdo_refcnt;		/* owner reference count */
888 	uint_t dtdo_destructive;	/* invokes destructive subroutines */
889 #ifndef _KERNEL
890 	dof_relodesc_t *dtdo_kreltab;	/* kernel relocations */
891 	dof_relodesc_t *dtdo_ureltab;	/* user relocations */
892 	struct dt_node **dtdo_xlmtab;	/* translator references */
893 	uint_t dtdo_krelen;		/* length of krelo table */
894 	uint_t dtdo_urelen;		/* length of urelo table */
895 	uint_t dtdo_xlmlen;		/* length of translator table */
896 #endif
897 } dtrace_difo_t;
898 
899 /*
900  * DTrace Enabling Description Structures
901  *
902  * When DTrace is tracking the description of a DTrace enabling entity (probe,
903  * predicate, action, ECB, record, etc.), it does so in a description
904  * structure.  These structures all end in "desc", and are used at both
905  * user-level and in the kernel -- but (with the exception of
906  * dtrace_probedesc_t) they are never passed between them.  Typically,
907  * user-level will use the description structures when assembling an enabling.
908  * It will then distill those description structures into a DOF object (see
909  * above), and send it into the kernel.  The kernel will again use the
910  * description structures to create a description of the enabling as it reads
911  * the DOF.  When the description is complete, the enabling will be actually
912  * created -- turning it into the structures that represent the enabling
913  * instead of merely describing it.  Not surprisingly, the description
914  * structures bear a strong resemblance to the DOF structures that act as their
915  * conduit.
916  */
917 struct dtrace_predicate;
918 
919 typedef struct dtrace_probedesc {
920 	dtrace_id_t dtpd_id;			/* probe identifier */
921 	char dtpd_provider[DTRACE_PROVNAMELEN]; /* probe provider name */
922 	char dtpd_mod[DTRACE_MODNAMELEN];	/* probe module name */
923 	char dtpd_func[DTRACE_FUNCNAMELEN];	/* probe function name */
924 	char dtpd_name[DTRACE_NAMELEN];		/* probe name */
925 } dtrace_probedesc_t;
926 
927 typedef struct dtrace_repldesc {
928 	dtrace_probedesc_t dtrpd_match;		/* probe descr. to match */
929 	dtrace_probedesc_t dtrpd_create;	/* probe descr. to create */
930 } dtrace_repldesc_t;
931 
932 typedef struct dtrace_preddesc {
933 	dtrace_difo_t *dtpdd_difo;		/* pointer to DIF object */
934 	struct dtrace_predicate *dtpdd_predicate; /* pointer to predicate */
935 } dtrace_preddesc_t;
936 
937 typedef struct dtrace_actdesc {
938 	dtrace_difo_t *dtad_difo;		/* pointer to DIF object */
939 	struct dtrace_actdesc *dtad_next;	/* next action */
940 	dtrace_actkind_t dtad_kind;		/* kind of action */
941 	uint32_t dtad_ntuple;			/* number in tuple */
942 	uint64_t dtad_arg;			/* action argument */
943 	uint64_t dtad_uarg;			/* user argument */
944 	int dtad_refcnt;			/* reference count */
945 } dtrace_actdesc_t;
946 
947 typedef struct dtrace_ecbdesc {
948 	dtrace_actdesc_t *dted_action;		/* action description(s) */
949 	dtrace_preddesc_t dted_pred;		/* predicate description */
950 	dtrace_probedesc_t dted_probe;		/* probe description */
951 	uint64_t dted_uarg;			/* library argument */
952 	int dted_refcnt;			/* reference count */
953 } dtrace_ecbdesc_t;
954 
955 /*
956  * DTrace Metadata Description Structures
957  *
958  * DTrace separates the trace data stream from the metadata stream.  The only
959  * metadata tokens placed in the data stream are the dtrace_rechdr_t (EPID +
960  * timestamp) or (in the case of aggregations) aggregation identifiers.  To
961  * determine the structure of the data, DTrace consumers pass the token to the
962  * kernel, and receive in return a corresponding description of the enabled
963  * probe (via the dtrace_eprobedesc structure) or the aggregation (via the
964  * dtrace_aggdesc structure).  Both of these structures are expressed in terms
965  * of record descriptions (via the dtrace_recdesc structure) that describe the
966  * exact structure of the data.  Some record descriptions may also contain a
967  * format identifier; this additional bit of metadata can be retrieved from the
968  * kernel, for which a format description is returned via the dtrace_fmtdesc
969  * structure.  Note that all four of these structures must be bitness-neutral
970  * to allow for a 32-bit DTrace consumer on a 64-bit kernel.
971  */
972 typedef struct dtrace_recdesc {
973 	dtrace_actkind_t dtrd_action;		/* kind of action */
974 	uint32_t dtrd_size;			/* size of record */
975 	uint32_t dtrd_offset;			/* offset in ECB's data */
976 	uint16_t dtrd_alignment;		/* required alignment */
977 	uint16_t dtrd_format;			/* format, if any */
978 	uint64_t dtrd_arg;			/* action argument */
979 	uint64_t dtrd_uarg;			/* user argument */
980 } dtrace_recdesc_t;
981 
982 typedef struct dtrace_eprobedesc {
983 	dtrace_epid_t dtepd_epid;		/* enabled probe ID */
984 	dtrace_id_t dtepd_probeid;		/* probe ID */
985 	uint64_t dtepd_uarg;			/* library argument */
986 	uint32_t dtepd_size;			/* total size */
987 	int dtepd_nrecs;			/* number of records */
988 	dtrace_recdesc_t dtepd_rec[1];		/* records themselves */
989 } dtrace_eprobedesc_t;
990 
991 typedef struct dtrace_aggdesc {
992 	DTRACE_PTR(char, dtagd_name);		/* not filled in by kernel */
993 	dtrace_aggvarid_t dtagd_varid;		/* not filled in by kernel */
994 	int dtagd_flags;			/* not filled in by kernel */
995 	dtrace_aggid_t dtagd_id;		/* aggregation ID */
996 	dtrace_epid_t dtagd_epid;		/* enabled probe ID */
997 	uint32_t dtagd_size;			/* size in bytes */
998 	int dtagd_nrecs;			/* number of records */
999 	uint32_t dtagd_pad;			/* explicit padding */
1000 	dtrace_recdesc_t dtagd_rec[1];		/* record descriptions */
1001 } dtrace_aggdesc_t;
1002 
1003 typedef struct dtrace_fmtdesc {
1004 	DTRACE_PTR(char, dtfd_string);		/* format string */
1005 	int dtfd_length;			/* length of format string */
1006 	uint16_t dtfd_format;			/* format identifier */
1007 } dtrace_fmtdesc_t;
1008 
1009 #define	DTRACE_SIZEOF_EPROBEDESC(desc)				\
1010 	(sizeof (dtrace_eprobedesc_t) + ((desc)->dtepd_nrecs ?	\
1011 	(((desc)->dtepd_nrecs - 1) * sizeof (dtrace_recdesc_t)) : 0))
1012 
1013 #define	DTRACE_SIZEOF_AGGDESC(desc)				\
1014 	(sizeof (dtrace_aggdesc_t) + ((desc)->dtagd_nrecs ?	\
1015 	(((desc)->dtagd_nrecs - 1) * sizeof (dtrace_recdesc_t)) : 0))
1016 
1017 /*
1018  * DTrace Option Interface
1019  *
1020  * Run-time DTrace options are set and retrieved via DOF_SECT_OPTDESC sections
1021  * in a DOF image.  The dof_optdesc structure contains an option identifier and
1022  * an option value.  The valid option identifiers are found below; the mapping
1023  * between option identifiers and option identifying strings is maintained at
1024  * user-level.  Note that the value of DTRACEOPT_UNSET is such that all of the
1025  * following are potentially valid option values:  all positive integers, zero
1026  * and negative one.  Some options (notably "bufpolicy" and "bufresize") take
1027  * predefined tokens as their values; these are defined with
1028  * DTRACEOPT_{option}_{token}.
1029  */
1030 #define	DTRACEOPT_BUFSIZE	0	/* buffer size */
1031 #define	DTRACEOPT_BUFPOLICY	1	/* buffer policy */
1032 #define	DTRACEOPT_DYNVARSIZE	2	/* dynamic variable size */
1033 #define	DTRACEOPT_AGGSIZE	3	/* aggregation size */
1034 #define	DTRACEOPT_SPECSIZE	4	/* speculation size */
1035 #define	DTRACEOPT_NSPEC		5	/* number of speculations */
1036 #define	DTRACEOPT_STRSIZE	6	/* string size */
1037 #define	DTRACEOPT_CLEANRATE	7	/* dynvar cleaning rate */
1038 #define	DTRACEOPT_CPU		8	/* CPU to trace */
1039 #define	DTRACEOPT_BUFRESIZE	9	/* buffer resizing policy */
1040 #define	DTRACEOPT_GRABANON	10	/* grab anonymous state, if any */
1041 #define	DTRACEOPT_FLOWINDENT	11	/* indent function entry/return */
1042 #define	DTRACEOPT_QUIET		12	/* only output explicitly traced data */
1043 #define	DTRACEOPT_STACKFRAMES	13	/* number of stack frames */
1044 #define	DTRACEOPT_USTACKFRAMES	14	/* number of user stack frames */
1045 #define	DTRACEOPT_AGGRATE	15	/* aggregation snapshot rate */
1046 #define	DTRACEOPT_SWITCHRATE	16	/* buffer switching rate */
1047 #define	DTRACEOPT_STATUSRATE	17	/* status rate */
1048 #define	DTRACEOPT_DESTRUCTIVE	18	/* destructive actions allowed */
1049 #define	DTRACEOPT_STACKINDENT	19	/* output indent for stack traces */
1050 #define	DTRACEOPT_RAWBYTES	20	/* always print bytes in raw form */
1051 #define	DTRACEOPT_JSTACKFRAMES	21	/* number of jstack() frames */
1052 #define	DTRACEOPT_JSTACKSTRSIZE	22	/* size of jstack() string table */
1053 #define	DTRACEOPT_AGGSORTKEY	23	/* sort aggregations by key */
1054 #define	DTRACEOPT_AGGSORTREV	24	/* reverse-sort aggregations */
1055 #define	DTRACEOPT_AGGSORTPOS	25	/* agg. position to sort on */
1056 #define	DTRACEOPT_AGGSORTKEYPOS	26	/* agg. key position to sort on */
1057 #define	DTRACEOPT_TEMPORAL	27	/* temporally ordered output */
1058 #define	DTRACEOPT_AGGHIST	28	/* histogram aggregation output */
1059 #define	DTRACEOPT_AGGPACK	29	/* packed aggregation output */
1060 #define	DTRACEOPT_AGGZOOM	30	/* zoomed aggregation scaling */
1061 #define	DTRACEOPT_ZONE		31	/* zone in which to enable probes */
1062 #define	DTRACEOPT_MAX		32	/* number of options */
1063 
1064 #define	DTRACEOPT_UNSET		(dtrace_optval_t)-2	/* unset option */
1065 
1066 #define	DTRACEOPT_BUFPOLICY_RING	0	/* ring buffer */
1067 #define	DTRACEOPT_BUFPOLICY_FILL	1	/* fill buffer, then stop */
1068 #define	DTRACEOPT_BUFPOLICY_SWITCH	2	/* switch buffers */
1069 
1070 #define	DTRACEOPT_BUFRESIZE_AUTO	0	/* automatic resizing */
1071 #define	DTRACEOPT_BUFRESIZE_MANUAL	1	/* manual resizing */
1072 
1073 /*
1074  * DTrace Buffer Interface
1075  *
1076  * In order to get a snapshot of the principal or aggregation buffer,
1077  * user-level passes a buffer description to the kernel with the dtrace_bufdesc
1078  * structure.  This describes which CPU user-level is interested in, and
1079  * where user-level wishes the kernel to snapshot the buffer to (the
1080  * dtbd_data field).  The kernel uses the same structure to pass back some
1081  * information regarding the buffer:  the size of data actually copied out, the
1082  * number of drops, the number of errors, the offset of the oldest record,
1083  * and the time of the snapshot.
1084  *
1085  * If the buffer policy is a "switch" policy, taking a snapshot of the
1086  * principal buffer has the additional effect of switching the active and
1087  * inactive buffers.  Taking a snapshot of the aggregation buffer _always_ has
1088  * the additional effect of switching the active and inactive buffers.
1089  */
1090 typedef struct dtrace_bufdesc {
1091 	uint64_t dtbd_size;			/* size of buffer */
1092 	uint32_t dtbd_cpu;			/* CPU or DTRACE_CPUALL */
1093 	uint32_t dtbd_errors;			/* number of errors */
1094 	uint64_t dtbd_drops;			/* number of drops */
1095 	DTRACE_PTR(char, dtbd_data);		/* data */
1096 	uint64_t dtbd_oldest;			/* offset of oldest record */
1097 	uint64_t dtbd_timestamp;		/* hrtime of snapshot */
1098 } dtrace_bufdesc_t;
1099 
1100 /*
1101  * Each record in the buffer (dtbd_data) begins with a header that includes
1102  * the epid and a timestamp.  The timestamp is split into two 4-byte parts
1103  * so that we do not require 8-byte alignment.
1104  */
1105 typedef struct dtrace_rechdr {
1106 	dtrace_epid_t dtrh_epid;		/* enabled probe id */
1107 	uint32_t dtrh_timestamp_hi;		/* high bits of hrtime_t */
1108 	uint32_t dtrh_timestamp_lo;		/* low bits of hrtime_t */
1109 } dtrace_rechdr_t;
1110 
1111 #define	DTRACE_RECORD_LOAD_TIMESTAMP(dtrh)			\
1112 	((dtrh)->dtrh_timestamp_lo +				\
1113 	((uint64_t)(dtrh)->dtrh_timestamp_hi << 32))
1114 
1115 #define	DTRACE_RECORD_STORE_TIMESTAMP(dtrh, hrtime) {		\
1116 	(dtrh)->dtrh_timestamp_lo = (uint32_t)hrtime;		\
1117 	(dtrh)->dtrh_timestamp_hi = hrtime >> 32;		\
1118 }
1119 
1120 /*
1121  * DTrace Status
1122  *
1123  * The status of DTrace is relayed via the dtrace_status structure.  This
1124  * structure contains members to count drops other than the capacity drops
1125  * available via the buffer interface (see above).  This consists of dynamic
1126  * drops (including capacity dynamic drops, rinsing drops and dirty drops), and
1127  * speculative drops (including capacity speculative drops, drops due to busy
1128  * speculative buffers and drops due to unavailable speculative buffers).
1129  * Additionally, the status structure contains a field to indicate the number
1130  * of "fill"-policy buffers have been filled and a boolean field to indicate
1131  * that exit() has been called.  If the dtst_exiting field is non-zero, no
1132  * further data will be generated until tracing is stopped (at which time any
1133  * enablings of the END action will be processed); if user-level sees that
1134  * this field is non-zero, tracing should be stopped as soon as possible.
1135  */
1136 typedef struct dtrace_status {
1137 	uint64_t dtst_dyndrops;			/* dynamic drops */
1138 	uint64_t dtst_dyndrops_rinsing;		/* dyn drops due to rinsing */
1139 	uint64_t dtst_dyndrops_dirty;		/* dyn drops due to dirty */
1140 	uint64_t dtst_specdrops;		/* speculative drops */
1141 	uint64_t dtst_specdrops_busy;		/* spec drops due to busy */
1142 	uint64_t dtst_specdrops_unavail;	/* spec drops due to unavail */
1143 	uint64_t dtst_errors;			/* total errors */
1144 	uint64_t dtst_filled;			/* number of filled bufs */
1145 	uint64_t dtst_stkstroverflows;		/* stack string tab overflows */
1146 	uint64_t dtst_dblerrors;		/* errors in ERROR probes */
1147 	char dtst_killed;			/* non-zero if killed */
1148 	char dtst_exiting;			/* non-zero if exit() called */
1149 	char dtst_pad[6];			/* pad out to 64-bit align */
1150 } dtrace_status_t;
1151 
1152 /*
1153  * DTrace Configuration
1154  *
1155  * User-level may need to understand some elements of the kernel DTrace
1156  * configuration in order to generate correct DIF.  This information is
1157  * conveyed via the dtrace_conf structure.
1158  */
1159 typedef struct dtrace_conf {
1160 	uint_t dtc_difversion;			/* supported DIF version */
1161 	uint_t dtc_difintregs;			/* # of DIF integer registers */
1162 	uint_t dtc_diftupregs;			/* # of DIF tuple registers */
1163 	uint_t dtc_ctfmodel;			/* CTF data model */
1164 	uint_t dtc_pad[8];			/* reserved for future use */
1165 } dtrace_conf_t;
1166 
1167 /*
1168  * DTrace Faults
1169  *
1170  * The constants below DTRACEFLT_LIBRARY indicate probe processing faults;
1171  * constants at or above DTRACEFLT_LIBRARY indicate faults in probe
1172  * postprocessing at user-level.  Probe processing faults induce an ERROR
1173  * probe and are replicated in unistd.d to allow users' ERROR probes to decode
1174  * the error condition using thse symbolic labels.
1175  */
1176 #define	DTRACEFLT_UNKNOWN		0	/* Unknown fault */
1177 #define	DTRACEFLT_BADADDR		1	/* Bad address */
1178 #define	DTRACEFLT_BADALIGN		2	/* Bad alignment */
1179 #define	DTRACEFLT_ILLOP			3	/* Illegal operation */
1180 #define	DTRACEFLT_DIVZERO		4	/* Divide-by-zero */
1181 #define	DTRACEFLT_NOSCRATCH		5	/* Out of scratch space */
1182 #define	DTRACEFLT_KPRIV			6	/* Illegal kernel access */
1183 #define	DTRACEFLT_UPRIV			7	/* Illegal user access */
1184 #define	DTRACEFLT_TUPOFLOW		8	/* Tuple stack overflow */
1185 #define	DTRACEFLT_BADSTACK		9	/* Bad stack */
1186 
1187 #define	DTRACEFLT_LIBRARY		1000	/* Library-level fault */
1188 
1189 /*
1190  * DTrace Argument Types
1191  *
1192  * Because it would waste both space and time, argument types do not reside
1193  * with the probe.  In order to determine argument types for args[X]
1194  * variables, the D compiler queries for argument types on a probe-by-probe
1195  * basis.  (This optimizes for the common case that arguments are either not
1196  * used or used in an untyped fashion.)  Typed arguments are specified with a
1197  * string of the type name in the dtragd_native member of the argument
1198  * description structure.  Typed arguments may be further translated to types
1199  * of greater stability; the provider indicates such a translated argument by
1200  * filling in the dtargd_xlate member with the string of the translated type.
1201  * Finally, the provider may indicate which argument value a given argument
1202  * maps to by setting the dtargd_mapping member -- allowing a single argument
1203  * to map to multiple args[X] variables.
1204  */
1205 typedef struct dtrace_argdesc {
1206 	dtrace_id_t dtargd_id;			/* probe identifier */
1207 	int dtargd_ndx;				/* arg number (-1 iff none) */
1208 	int dtargd_mapping;			/* value mapping */
1209 	char dtargd_native[DTRACE_ARGTYPELEN];	/* native type name */
1210 	char dtargd_xlate[DTRACE_ARGTYPELEN];	/* translated type name */
1211 } dtrace_argdesc_t;
1212 
1213 /*
1214  * DTrace Stability Attributes
1215  *
1216  * Each DTrace provider advertises the name and data stability of each of its
1217  * probe description components, as well as its architectural dependencies.
1218  * The D compiler can query the provider attributes (dtrace_pattr_t below) in
1219  * order to compute the properties of an input program and report them.
1220  */
1221 typedef uint8_t dtrace_stability_t;	/* stability code (see attributes(5)) */
1222 typedef uint8_t dtrace_class_t;		/* architectural dependency class */
1223 
1224 #define	DTRACE_STABILITY_INTERNAL	0	/* private to DTrace itself */
1225 #define	DTRACE_STABILITY_PRIVATE	1	/* private to Sun (see docs) */
1226 #define	DTRACE_STABILITY_OBSOLETE	2	/* scheduled for removal */
1227 #define	DTRACE_STABILITY_EXTERNAL	3	/* not controlled by Sun */
1228 #define	DTRACE_STABILITY_UNSTABLE	4	/* new or rapidly changing */
1229 #define	DTRACE_STABILITY_EVOLVING	5	/* less rapidly changing */
1230 #define	DTRACE_STABILITY_STABLE		6	/* mature interface from Sun */
1231 #define	DTRACE_STABILITY_STANDARD	7	/* industry standard */
1232 #define	DTRACE_STABILITY_MAX		7	/* maximum valid stability */
1233 
1234 #define	DTRACE_CLASS_UNKNOWN	0	/* unknown architectural dependency */
1235 #define	DTRACE_CLASS_CPU	1	/* CPU-module-specific */
1236 #define	DTRACE_CLASS_PLATFORM	2	/* platform-specific (uname -i) */
1237 #define	DTRACE_CLASS_GROUP	3	/* hardware-group-specific (uname -m) */
1238 #define	DTRACE_CLASS_ISA	4	/* ISA-specific (uname -p) */
1239 #define	DTRACE_CLASS_COMMON	5	/* common to all systems */
1240 #define	DTRACE_CLASS_MAX	5	/* maximum valid class */
1241 
1242 #define	DTRACE_PRIV_NONE	0x0000
1243 #define	DTRACE_PRIV_KERNEL	0x0001
1244 #define	DTRACE_PRIV_USER	0x0002
1245 #define	DTRACE_PRIV_PROC	0x0004
1246 #define	DTRACE_PRIV_OWNER	0x0008
1247 #define	DTRACE_PRIV_ZONEOWNER	0x0010
1248 
1249 #define	DTRACE_PRIV_ALL	\
1250 	(DTRACE_PRIV_KERNEL | DTRACE_PRIV_USER | \
1251 	DTRACE_PRIV_PROC | DTRACE_PRIV_OWNER | DTRACE_PRIV_ZONEOWNER)
1252 
1253 typedef struct dtrace_ppriv {
1254 	uint32_t dtpp_flags;			/* privilege flags */
1255 	uid_t dtpp_uid;				/* user ID */
1256 	zoneid_t dtpp_zoneid;			/* zone ID */
1257 } dtrace_ppriv_t;
1258 
1259 typedef struct dtrace_attribute {
1260 	dtrace_stability_t dtat_name;		/* entity name stability */
1261 	dtrace_stability_t dtat_data;		/* entity data stability */
1262 	dtrace_class_t dtat_class;		/* entity data dependency */
1263 } dtrace_attribute_t;
1264 
1265 typedef struct dtrace_pattr {
1266 	dtrace_attribute_t dtpa_provider;	/* provider attributes */
1267 	dtrace_attribute_t dtpa_mod;		/* module attributes */
1268 	dtrace_attribute_t dtpa_func;		/* function attributes */
1269 	dtrace_attribute_t dtpa_name;		/* name attributes */
1270 	dtrace_attribute_t dtpa_args;		/* args[] attributes */
1271 } dtrace_pattr_t;
1272 
1273 typedef struct dtrace_providerdesc {
1274 	char dtvd_name[DTRACE_PROVNAMELEN];	/* provider name */
1275 	dtrace_pattr_t dtvd_attr;		/* stability attributes */
1276 	dtrace_ppriv_t dtvd_priv;		/* privileges required */
1277 } dtrace_providerdesc_t;
1278 
1279 /*
1280  * DTrace Pseudodevice Interface
1281  *
1282  * DTrace is controlled through ioctl(2)'s to the in-kernel dtrace:dtrace
1283  * pseudodevice driver.  These ioctls comprise the user-kernel interface to
1284  * DTrace.
1285  */
1286 #ifdef illumos
1287 #define	DTRACEIOC		(('d' << 24) | ('t' << 16) | ('r' << 8))
1288 #define	DTRACEIOC_PROVIDER	(DTRACEIOC | 1)		/* provider query */
1289 #define	DTRACEIOC_PROBES	(DTRACEIOC | 2)		/* probe query */
1290 #define	DTRACEIOC_BUFSNAP	(DTRACEIOC | 4)		/* snapshot buffer */
1291 #define	DTRACEIOC_PROBEMATCH	(DTRACEIOC | 5)		/* match probes */
1292 #define	DTRACEIOC_ENABLE	(DTRACEIOC | 6)		/* enable probes */
1293 #define	DTRACEIOC_AGGSNAP	(DTRACEIOC | 7)		/* snapshot agg. */
1294 #define	DTRACEIOC_EPROBE	(DTRACEIOC | 8)		/* get eprobe desc. */
1295 #define	DTRACEIOC_PROBEARG	(DTRACEIOC | 9)		/* get probe arg */
1296 #define	DTRACEIOC_CONF		(DTRACEIOC | 10)	/* get config. */
1297 #define	DTRACEIOC_STATUS	(DTRACEIOC | 11)	/* get status */
1298 #define	DTRACEIOC_GO		(DTRACEIOC | 12)	/* start tracing */
1299 #define	DTRACEIOC_STOP		(DTRACEIOC | 13)	/* stop tracing */
1300 #define	DTRACEIOC_AGGDESC	(DTRACEIOC | 15)	/* get agg. desc. */
1301 #define	DTRACEIOC_FORMAT	(DTRACEIOC | 16)	/* get format str */
1302 #define	DTRACEIOC_DOFGET	(DTRACEIOC | 17)	/* get DOF */
1303 #define	DTRACEIOC_REPLICATE	(DTRACEIOC | 18)	/* replicate enab */
1304 #else
1305 #define	DTRACEIOC_PROVIDER	_IOWR('x',1,dtrace_providerdesc_t)
1306 							/* provider query */
1307 #define	DTRACEIOC_PROBES	_IOWR('x',2,dtrace_probedesc_t)
1308 							/* probe query */
1309 #define	DTRACEIOC_BUFSNAP	_IOW('x',4,dtrace_bufdesc_t *)
1310 							/* snapshot buffer */
1311 #define	DTRACEIOC_PROBEMATCH	_IOWR('x',5,dtrace_probedesc_t)
1312 							/* match probes */
1313 typedef struct {
1314 	void	*dof;		/* DOF userland address written to driver. */
1315 	int	n_matched;	/* # matches returned by driver. */
1316 } dtrace_enable_io_t;
1317 #define	DTRACEIOC_ENABLE	_IOWR('x',6,dtrace_enable_io_t)
1318 							/* enable probes */
1319 #define	DTRACEIOC_AGGSNAP	_IOW('x',7,dtrace_bufdesc_t *)
1320 							/* snapshot agg. */
1321 #define	DTRACEIOC_EPROBE	_IOW('x',8,dtrace_eprobedesc_t)
1322 							/* get eprobe desc. */
1323 #define	DTRACEIOC_PROBEARG	_IOWR('x',9,dtrace_argdesc_t)
1324 							/* get probe arg */
1325 #define	DTRACEIOC_CONF		_IOR('x',10,dtrace_conf_t)
1326 							/* get config. */
1327 #define	DTRACEIOC_STATUS	_IOR('x',11,dtrace_status_t)
1328 							/* get status */
1329 #define	DTRACEIOC_GO		_IOR('x',12,processorid_t)
1330 							/* start tracing */
1331 #define	DTRACEIOC_STOP		_IOWR('x',13,processorid_t)
1332 							/* stop tracing */
1333 #define	DTRACEIOC_AGGDESC	_IOW('x',15,dtrace_aggdesc_t *)
1334 							/* get agg. desc. */
1335 #define	DTRACEIOC_FORMAT	_IOWR('x',16,dtrace_fmtdesc_t)
1336 							/* get format str */
1337 #define	DTRACEIOC_DOFGET	_IOW('x',17,dof_hdr_t *)
1338 							/* get DOF */
1339 #define	DTRACEIOC_REPLICATE	_IOW('x',18,dtrace_repldesc_t)
1340 							/* replicate enab */
1341 #endif
1342 
1343 /*
1344  * DTrace Helpers
1345  *
1346  * In general, DTrace establishes probes in processes and takes actions on
1347  * processes without knowing their specific user-level structures.  Instead of
1348  * existing in the framework, process-specific knowledge is contained by the
1349  * enabling D program -- which can apply process-specific knowledge by making
1350  * appropriate use of DTrace primitives like copyin() and copyinstr() to
1351  * operate on user-level data.  However, there may exist some specific probes
1352  * of particular semantic relevance that the application developer may wish to
1353  * explicitly export.  For example, an application may wish to export a probe
1354  * at the point that it begins and ends certain well-defined transactions.  In
1355  * addition to providing probes, programs may wish to offer assistance for
1356  * certain actions.  For example, in highly dynamic environments (e.g., Java),
1357  * it may be difficult to obtain a stack trace in terms of meaningful symbol
1358  * names (the translation from instruction addresses to corresponding symbol
1359  * names may only be possible in situ); these environments may wish to define
1360  * a series of actions to be applied in situ to obtain a meaningful stack
1361  * trace.
1362  *
1363  * These two mechanisms -- user-level statically defined tracing and assisting
1364  * DTrace actions -- are provided via DTrace _helpers_.  Helpers are specified
1365  * via DOF, but unlike enabling DOF, helper DOF may contain definitions of
1366  * providers, probes and their arguments.  If a helper wishes to provide
1367  * action assistance, probe descriptions and corresponding DIF actions may be
1368  * specified in the helper DOF.  For such helper actions, however, the probe
1369  * description describes the specific helper:  all DTrace helpers have the
1370  * provider name "dtrace" and the module name "helper", and the name of the
1371  * helper is contained in the function name (for example, the ustack() helper
1372  * is named "ustack").  Any helper-specific name may be contained in the name
1373  * (for example, if a helper were to have a constructor, it might be named
1374  * "dtrace:helper:<helper>:init").  Helper actions are only called when the
1375  * action that they are helping is taken.  Helper actions may only return DIF
1376  * expressions, and may only call the following subroutines:
1377  *
1378  *    alloca()      <= Allocates memory out of the consumer's scratch space
1379  *    bcopy()       <= Copies memory to scratch space
1380  *    copyin()      <= Copies memory from user-level into consumer's scratch
1381  *    copyinto()    <= Copies memory into a specific location in scratch
1382  *    copyinstr()   <= Copies a string into a specific location in scratch
1383  *
1384  * Helper actions may only access the following built-in variables:
1385  *
1386  *    curthread     <= Current kthread_t pointer
1387  *    tid           <= Current thread identifier
1388  *    pid           <= Current process identifier
1389  *    ppid          <= Parent process identifier
1390  *    uid           <= Current user ID
1391  *    gid           <= Current group ID
1392  *    execname      <= Current executable name
1393  *    zonename      <= Current zone name
1394  *
1395  * Helper actions may not manipulate or allocate dynamic variables, but they
1396  * may have clause-local and statically-allocated global variables.  The
1397  * helper action variable state is specific to the helper action -- variables
1398  * used by the helper action may not be accessed outside of the helper
1399  * action, and the helper action may not access variables that like outside
1400  * of it.  Helper actions may not load from kernel memory at-large; they are
1401  * restricting to loading current user state (via copyin() and variants) and
1402  * scratch space.  As with probe enablings, helper actions are executed in
1403  * program order.  The result of the helper action is the result of the last
1404  * executing helper expression.
1405  *
1406  * Helpers -- composed of either providers/probes or probes/actions (or both)
1407  * -- are added by opening the "helper" minor node, and issuing an ioctl(2)
1408  * (DTRACEHIOC_ADDDOF) that specifies the dof_helper_t structure. This
1409  * encapsulates the name and base address of the user-level library or
1410  * executable publishing the helpers and probes as well as the DOF that
1411  * contains the definitions of those helpers and probes.
1412  *
1413  * The DTRACEHIOC_ADD and DTRACEHIOC_REMOVE are left in place for legacy
1414  * helpers and should no longer be used.  No other ioctls are valid on the
1415  * helper minor node.
1416  */
1417 #ifdef illumos
1418 #define	DTRACEHIOC		(('d' << 24) | ('t' << 16) | ('h' << 8))
1419 #define	DTRACEHIOC_ADD		(DTRACEHIOC | 1)	/* add helper */
1420 #define	DTRACEHIOC_REMOVE	(DTRACEHIOC | 2)	/* remove helper */
1421 #define	DTRACEHIOC_ADDDOF	(DTRACEHIOC | 3)	/* add helper DOF */
1422 #else
1423 #define	DTRACEHIOC_REMOVE	_IOW('z', 2, int)	/* remove helper */
1424 #define	DTRACEHIOC_ADDDOF	_IOWR('z', 3, dof_helper_t)/* add helper DOF */
1425 #endif
1426 
1427 typedef struct dof_helper {
1428 	char dofhp_mod[DTRACE_MODNAMELEN];	/* executable or library name */
1429 	uint64_t dofhp_addr;			/* base address of object */
1430 	uint64_t dofhp_dof;			/* address of helper DOF */
1431 #ifdef __FreeBSD__
1432 	pid_t dofhp_pid;			/* target process ID */
1433 	int dofhp_gen;
1434 #endif
1435 } dof_helper_t;
1436 
1437 #define	DTRACEMNR_DTRACE	"dtrace"	/* node for DTrace ops */
1438 #define	DTRACEMNR_HELPER	"helper"	/* node for helpers */
1439 #define	DTRACEMNRN_DTRACE	0		/* minor for DTrace ops */
1440 #define	DTRACEMNRN_HELPER	1		/* minor for helpers */
1441 #define	DTRACEMNRN_CLONE	2		/* first clone minor */
1442 
1443 #ifdef _KERNEL
1444 
1445 /*
1446  * DTrace Provider API
1447  *
1448  * The following functions are implemented by the DTrace framework and are
1449  * used to implement separate in-kernel DTrace providers.  Common functions
1450  * are provided in uts/common/os/dtrace.c.  ISA-dependent subroutines are
1451  * defined in uts/<isa>/dtrace/dtrace_asm.s or uts/<isa>/dtrace/dtrace_isa.c.
1452  *
1453  * The provider API has two halves:  the API that the providers consume from
1454  * DTrace, and the API that providers make available to DTrace.
1455  *
1456  * 1 Framework-to-Provider API
1457  *
1458  * 1.1  Overview
1459  *
1460  * The Framework-to-Provider API is represented by the dtrace_pops structure
1461  * that the provider passes to the framework when registering itself.  This
1462  * structure consists of the following members:
1463  *
1464  *   dtps_provide()          <-- Provide all probes, all modules
1465  *   dtps_provide_module()   <-- Provide all probes in specified module
1466  *   dtps_enable()           <-- Enable specified probe
1467  *   dtps_disable()          <-- Disable specified probe
1468  *   dtps_suspend()          <-- Suspend specified probe
1469  *   dtps_resume()           <-- Resume specified probe
1470  *   dtps_getargdesc()       <-- Get the argument description for args[X]
1471  *   dtps_getargval()        <-- Get the value for an argX or args[X] variable
1472  *   dtps_usermode()         <-- Find out if the probe was fired in user mode
1473  *   dtps_destroy()          <-- Destroy all state associated with this probe
1474  *
1475  * 1.2  void dtps_provide(void *arg, const dtrace_probedesc_t *spec)
1476  *
1477  * 1.2.1  Overview
1478  *
1479  *   Called to indicate that the provider should provide all probes.  If the
1480  *   specified description is non-NULL, dtps_provide() is being called because
1481  *   no probe matched a specified probe -- if the provider has the ability to
1482  *   create custom probes, it may wish to create a probe that matches the
1483  *   specified description.
1484  *
1485  * 1.2.2  Arguments and notes
1486  *
1487  *   The first argument is the cookie as passed to dtrace_register().  The
1488  *   second argument is a pointer to a probe description that the provider may
1489  *   wish to consider when creating custom probes.  The provider is expected to
1490  *   call back into the DTrace framework via dtrace_probe_create() to create
1491  *   any necessary probes.  dtps_provide() may be called even if the provider
1492  *   has made available all probes; the provider should check the return value
1493  *   of dtrace_probe_create() to handle this case.  Note that the provider need
1494  *   not implement both dtps_provide() and dtps_provide_module(); see
1495  *   "Arguments and Notes" for dtrace_register(), below.
1496  *
1497  * 1.2.3  Return value
1498  *
1499  *   None.
1500  *
1501  * 1.2.4  Caller's context
1502  *
1503  *   dtps_provide() is typically called from open() or ioctl() context, but may
1504  *   be called from other contexts as well.  The DTrace framework is locked in
1505  *   such a way that providers may not register or unregister.  This means that
1506  *   the provider may not call any DTrace API that affects its registration with
1507  *   the framework, including dtrace_register(), dtrace_unregister(),
1508  *   dtrace_invalidate(), and dtrace_condense().  However, the context is such
1509  *   that the provider may (and indeed, is expected to) call probe-related
1510  *   DTrace routines, including dtrace_probe_create(), dtrace_probe_lookup(),
1511  *   and dtrace_probe_arg().
1512  *
1513  * 1.3  void dtps_provide_module(void *arg, modctl_t *mp)
1514  *
1515  * 1.3.1  Overview
1516  *
1517  *   Called to indicate that the provider should provide all probes in the
1518  *   specified module.
1519  *
1520  * 1.3.2  Arguments and notes
1521  *
1522  *   The first argument is the cookie as passed to dtrace_register().  The
1523  *   second argument is a pointer to a modctl structure that indicates the
1524  *   module for which probes should be created.
1525  *
1526  * 1.3.3  Return value
1527  *
1528  *   None.
1529  *
1530  * 1.3.4  Caller's context
1531  *
1532  *   dtps_provide_module() may be called from open() or ioctl() context, but
1533  *   may also be called from a module loading context.  mod_lock is held, and
1534  *   the DTrace framework is locked in such a way that providers may not
1535  *   register or unregister.  This means that the provider may not call any
1536  *   DTrace API that affects its registration with the framework, including
1537  *   dtrace_register(), dtrace_unregister(), dtrace_invalidate(), and
1538  *   dtrace_condense().  However, the context is such that the provider may (and
1539  *   indeed, is expected to) call probe-related DTrace routines, including
1540  *   dtrace_probe_create(), dtrace_probe_lookup(), and dtrace_probe_arg().  Note
1541  *   that the provider need not implement both dtps_provide() and
1542  *   dtps_provide_module(); see "Arguments and Notes" for dtrace_register(),
1543  *   below.
1544  *
1545  * 1.4  void dtps_enable(void *arg, dtrace_id_t id, void *parg)
1546  *
1547  * 1.4.1  Overview
1548  *
1549  *   Called to enable the specified probe.
1550  *
1551  * 1.4.2  Arguments and notes
1552  *
1553  *   The first argument is the cookie as passed to dtrace_register().  The
1554  *   second argument is the identifier of the probe to be enabled.  The third
1555  *   argument is the probe argument as passed to dtrace_probe_create().
1556  *   dtps_enable() will be called when a probe transitions from not being
1557  *   enabled at all to having one or more ECB.  The number of ECBs associated
1558  *   with the probe may change without subsequent calls into the provider.
1559  *   When the number of ECBs drops to zero, the provider will be explicitly
1560  *   told to disable the probe via dtps_disable().  dtrace_probe() should never
1561  *   be called for a probe identifier that hasn't been explicitly enabled via
1562  *   dtps_enable().
1563  *
1564  * 1.4.3  Return value
1565  *
1566  *   None.
1567  *
1568  * 1.4.4  Caller's context
1569  *
1570  *   The DTrace framework is locked in such a way that it may not be called
1571  *   back into at all.  cpu_lock is held.  mod_lock is not held and may not
1572  *   be acquired.
1573  *
1574  * 1.5  void dtps_disable(void *arg, dtrace_id_t id, void *parg)
1575  *
1576  * 1.5.1  Overview
1577  *
1578  *   Called to disable the specified probe.
1579  *
1580  * 1.5.2  Arguments and notes
1581  *
1582  *   The first argument is the cookie as passed to dtrace_register().  The
1583  *   second argument is the identifier of the probe to be disabled.  The third
1584  *   argument is the probe argument as passed to dtrace_probe_create().
1585  *   dtps_disable() will be called when a probe transitions from being enabled
1586  *   to having zero ECBs.  dtrace_probe() should never be called for a probe
1587  *   identifier that has been explicitly enabled via dtps_disable().
1588  *
1589  * 1.5.3  Return value
1590  *
1591  *   None.
1592  *
1593  * 1.5.4  Caller's context
1594  *
1595  *   The DTrace framework is locked in such a way that it may not be called
1596  *   back into at all.  cpu_lock is held.  mod_lock is not held and may not
1597  *   be acquired.
1598  *
1599  * 1.6  void dtps_suspend(void *arg, dtrace_id_t id, void *parg)
1600  *
1601  * 1.6.1  Overview
1602  *
1603  *   Called to suspend the specified enabled probe.  This entry point is for
1604  *   providers that may need to suspend some or all of their probes when CPUs
1605  *   are being powered on or when the boot monitor is being entered for a
1606  *   prolonged period of time.
1607  *
1608  * 1.6.2  Arguments and notes
1609  *
1610  *   The first argument is the cookie as passed to dtrace_register().  The
1611  *   second argument is the identifier of the probe to be suspended.  The
1612  *   third argument is the probe argument as passed to dtrace_probe_create().
1613  *   dtps_suspend will only be called on an enabled probe.  Providers that
1614  *   provide a dtps_suspend entry point will want to take roughly the action
1615  *   that it takes for dtps_disable.
1616  *
1617  * 1.6.3  Return value
1618  *
1619  *   None.
1620  *
1621  * 1.6.4  Caller's context
1622  *
1623  *   Interrupts are disabled.  The DTrace framework is in a state such that the
1624  *   specified probe cannot be disabled or destroyed for the duration of
1625  *   dtps_suspend().  As interrupts are disabled, the provider is afforded
1626  *   little latitude; the provider is expected to do no more than a store to
1627  *   memory.
1628  *
1629  * 1.7  void dtps_resume(void *arg, dtrace_id_t id, void *parg)
1630  *
1631  * 1.7.1  Overview
1632  *
1633  *   Called to resume the specified enabled probe.  This entry point is for
1634  *   providers that may need to resume some or all of their probes after the
1635  *   completion of an event that induced a call to dtps_suspend().
1636  *
1637  * 1.7.2  Arguments and notes
1638  *
1639  *   The first argument is the cookie as passed to dtrace_register().  The
1640  *   second argument is the identifier of the probe to be resumed.  The
1641  *   third argument is the probe argument as passed to dtrace_probe_create().
1642  *   dtps_resume will only be called on an enabled probe.  Providers that
1643  *   provide a dtps_resume entry point will want to take roughly the action
1644  *   that it takes for dtps_enable.
1645  *
1646  * 1.7.3  Return value
1647  *
1648  *   None.
1649  *
1650  * 1.7.4  Caller's context
1651  *
1652  *   Interrupts are disabled.  The DTrace framework is in a state such that the
1653  *   specified probe cannot be disabled or destroyed for the duration of
1654  *   dtps_resume().  As interrupts are disabled, the provider is afforded
1655  *   little latitude; the provider is expected to do no more than a store to
1656  *   memory.
1657  *
1658  * 1.8  void dtps_getargdesc(void *arg, dtrace_id_t id, void *parg,
1659  *           dtrace_argdesc_t *desc)
1660  *
1661  * 1.8.1  Overview
1662  *
1663  *   Called to retrieve the argument description for an args[X] variable.
1664  *
1665  * 1.8.2  Arguments and notes
1666  *
1667  *   The first argument is the cookie as passed to dtrace_register(). The
1668  *   second argument is the identifier of the current probe. The third
1669  *   argument is the probe argument as passed to dtrace_probe_create(). The
1670  *   fourth argument is a pointer to the argument description.  This
1671  *   description is both an input and output parameter:  it contains the
1672  *   index of the desired argument in the dtargd_ndx field, and expects
1673  *   the other fields to be filled in upon return.  If there is no argument
1674  *   corresponding to the specified index, the dtargd_ndx field should be set
1675  *   to DTRACE_ARGNONE.
1676  *
1677  * 1.8.3  Return value
1678  *
1679  *   None.  The dtargd_ndx, dtargd_native, dtargd_xlate and dtargd_mapping
1680  *   members of the dtrace_argdesc_t structure are all output values.
1681  *
1682  * 1.8.4  Caller's context
1683  *
1684  *   dtps_getargdesc() is called from ioctl() context. mod_lock is held, and
1685  *   the DTrace framework is locked in such a way that providers may not
1686  *   register or unregister.  This means that the provider may not call any
1687  *   DTrace API that affects its registration with the framework, including
1688  *   dtrace_register(), dtrace_unregister(), dtrace_invalidate(), and
1689  *   dtrace_condense().
1690  *
1691  * 1.9  uint64_t dtps_getargval(void *arg, dtrace_id_t id, void *parg,
1692  *               int argno, int aframes)
1693  *
1694  * 1.9.1  Overview
1695  *
1696  *   Called to retrieve a value for an argX or args[X] variable.
1697  *
1698  * 1.9.2  Arguments and notes
1699  *
1700  *   The first argument is the cookie as passed to dtrace_register(). The
1701  *   second argument is the identifier of the current probe. The third
1702  *   argument is the probe argument as passed to dtrace_probe_create(). The
1703  *   fourth argument is the number of the argument (the X in the example in
1704  *   1.9.1). The fifth argument is the number of stack frames that were used
1705  *   to get from the actual place in the code that fired the probe to
1706  *   dtrace_probe() itself, the so-called artificial frames. This argument may
1707  *   be used to descend an appropriate number of frames to find the correct
1708  *   values. If this entry point is left NULL, the dtrace_getarg() built-in
1709  *   function is used.
1710  *
1711  * 1.9.3  Return value
1712  *
1713  *   The value of the argument.
1714  *
1715  * 1.9.4  Caller's context
1716  *
1717  *   This is called from within dtrace_probe() meaning that interrupts
1718  *   are disabled. No locks should be taken within this entry point.
1719  *
1720  * 1.10  int dtps_usermode(void *arg, dtrace_id_t id, void *parg)
1721  *
1722  * 1.10.1  Overview
1723  *
1724  *   Called to determine if the probe was fired in a user context.
1725  *
1726  * 1.10.2  Arguments and notes
1727  *
1728  *   The first argument is the cookie as passed to dtrace_register(). The
1729  *   second argument is the identifier of the current probe. The third
1730  *   argument is the probe argument as passed to dtrace_probe_create().  This
1731  *   entry point must not be left NULL for providers whose probes allow for
1732  *   mixed mode tracing, that is to say those probes that can fire during
1733  *   kernel- _or_ user-mode execution
1734  *
1735  * 1.10.3  Return value
1736  *
1737  *   A bitwise OR that encapsulates both the mode (either DTRACE_MODE_KERNEL
1738  *   or DTRACE_MODE_USER) and the policy when the privilege of the enabling
1739  *   is insufficient for that mode (a combination of DTRACE_MODE_NOPRIV_DROP,
1740  *   DTRACE_MODE_NOPRIV_RESTRICT, and DTRACE_MODE_LIMITEDPRIV_RESTRICT).  If
1741  *   DTRACE_MODE_NOPRIV_DROP bit is set, insufficient privilege will result
1742  *   in the probe firing being silently ignored for the enabling; if the
1743  *   DTRACE_NODE_NOPRIV_RESTRICT bit is set, insufficient privilege will not
1744  *   prevent probe processing for the enabling, but restrictions will be in
1745  *   place that induce a UPRIV fault upon attempt to examine probe arguments
1746  *   or current process state.  If the DTRACE_MODE_LIMITEDPRIV_RESTRICT bit
1747  *   is set, similar restrictions will be placed upon operation if the
1748  *   privilege is sufficient to process the enabling, but does not otherwise
1749  *   entitle the enabling to all zones.  The DTRACE_MODE_NOPRIV_DROP and
1750  *   DTRACE_MODE_NOPRIV_RESTRICT are mutually exclusive (and one of these
1751  *   two policies must be specified), but either may be combined (or not)
1752  *   with DTRACE_MODE_LIMITEDPRIV_RESTRICT.
1753  *
1754  * 1.10.4  Caller's context
1755  *
1756  *   This is called from within dtrace_probe() meaning that interrupts
1757  *   are disabled. No locks should be taken within this entry point.
1758  *
1759  * 1.11 void dtps_destroy(void *arg, dtrace_id_t id, void *parg)
1760  *
1761  * 1.11.1 Overview
1762  *
1763  *   Called to destroy the specified probe.
1764  *
1765  * 1.11.2 Arguments and notes
1766  *
1767  *   The first argument is the cookie as passed to dtrace_register().  The
1768  *   second argument is the identifier of the probe to be destroyed.  The third
1769  *   argument is the probe argument as passed to dtrace_probe_create().  The
1770  *   provider should free all state associated with the probe.  The framework
1771  *   guarantees that dtps_destroy() is only called for probes that have either
1772  *   been disabled via dtps_disable() or were never enabled via dtps_enable().
1773  *   Once dtps_disable() has been called for a probe, no further call will be
1774  *   made specifying the probe.
1775  *
1776  * 1.11.3 Return value
1777  *
1778  *   None.
1779  *
1780  * 1.11.4 Caller's context
1781  *
1782  *   The DTrace framework is locked in such a way that it may not be called
1783  *   back into at all.  mod_lock is held.  cpu_lock is not held, and may not be
1784  *   acquired.
1785  *
1786  *
1787  * 2 Provider-to-Framework API
1788  *
1789  * 2.1  Overview
1790  *
1791  * The Provider-to-Framework API provides the mechanism for the provider to
1792  * register itself with the DTrace framework, to create probes, to lookup
1793  * probes and (most importantly) to fire probes.  The Provider-to-Framework
1794  * consists of:
1795  *
1796  *   dtrace_register()       <-- Register a provider with the DTrace framework
1797  *   dtrace_unregister()     <-- Remove a provider's DTrace registration
1798  *   dtrace_invalidate()     <-- Invalidate the specified provider
1799  *   dtrace_condense()       <-- Remove a provider's unenabled probes
1800  *   dtrace_attached()       <-- Indicates whether or not DTrace has attached
1801  *   dtrace_probe_create()   <-- Create a DTrace probe
1802  *   dtrace_probe_lookup()   <-- Lookup a DTrace probe based on its name
1803  *   dtrace_probe_arg()      <-- Return the probe argument for a specific probe
1804  *   dtrace_probe()          <-- Fire the specified probe
1805  *
1806  * 2.2  int dtrace_register(const char *name, const dtrace_pattr_t *pap,
1807  *          uint32_t priv, cred_t *cr, const dtrace_pops_t *pops, void *arg,
1808  *          dtrace_provider_id_t *idp)
1809  *
1810  * 2.2.1  Overview
1811  *
1812  *   dtrace_register() registers the calling provider with the DTrace
1813  *   framework.  It should generally be called by DTrace providers in their
1814  *   attach(9E) entry point.
1815  *
1816  * 2.2.2  Arguments and Notes
1817  *
1818  *   The first argument is the name of the provider.  The second argument is a
1819  *   pointer to the stability attributes for the provider.  The third argument
1820  *   is the privilege flags for the provider, and must be some combination of:
1821  *
1822  *     DTRACE_PRIV_NONE     <= All users may enable probes from this provider
1823  *
1824  *     DTRACE_PRIV_PROC     <= Any user with privilege of PRIV_DTRACE_PROC may
1825  *                             enable probes from this provider
1826  *
1827  *     DTRACE_PRIV_USER     <= Any user with privilege of PRIV_DTRACE_USER may
1828  *                             enable probes from this provider
1829  *
1830  *     DTRACE_PRIV_KERNEL   <= Any user with privilege of PRIV_DTRACE_KERNEL
1831  *                             may enable probes from this provider
1832  *
1833  *     DTRACE_PRIV_OWNER    <= This flag places an additional constraint on
1834  *                             the privilege requirements above. These probes
1835  *                             require either (a) a user ID matching the user
1836  *                             ID of the cred passed in the fourth argument
1837  *                             or (b) the PRIV_PROC_OWNER privilege.
1838  *
1839  *     DTRACE_PRIV_ZONEOWNER<= This flag places an additional constraint on
1840  *                             the privilege requirements above. These probes
1841  *                             require either (a) a zone ID matching the zone
1842  *                             ID of the cred passed in the fourth argument
1843  *                             or (b) the PRIV_PROC_ZONE privilege.
1844  *
1845  *   Note that these flags designate the _visibility_ of the probes, not
1846  *   the conditions under which they may or may not fire.
1847  *
1848  *   The fourth argument is the credential that is associated with the
1849  *   provider.  This argument should be NULL if the privilege flags don't
1850  *   include DTRACE_PRIV_OWNER or DTRACE_PRIV_ZONEOWNER.  If non-NULL, the
1851  *   framework stashes the uid and zoneid represented by this credential
1852  *   for use at probe-time, in implicit predicates.  These limit visibility
1853  *   of the probes to users and/or zones which have sufficient privilege to
1854  *   access them.
1855  *
1856  *   The fifth argument is a DTrace provider operations vector, which provides
1857  *   the implementation for the Framework-to-Provider API.  (See Section 1,
1858  *   above.)  This must be non-NULL, and each member must be non-NULL.  The
1859  *   exceptions to this are (1) the dtps_provide() and dtps_provide_module()
1860  *   members (if the provider so desires, _one_ of these members may be left
1861  *   NULL -- denoting that the provider only implements the other) and (2)
1862  *   the dtps_suspend() and dtps_resume() members, which must either both be
1863  *   NULL or both be non-NULL.
1864  *
1865  *   The sixth argument is a cookie to be specified as the first argument for
1866  *   each function in the Framework-to-Provider API.  This argument may have
1867  *   any value.
1868  *
1869  *   The final argument is a pointer to dtrace_provider_id_t.  If
1870  *   dtrace_register() successfully completes, the provider identifier will be
1871  *   stored in the memory pointed to be this argument.  This argument must be
1872  *   non-NULL.
1873  *
1874  * 2.2.3  Return value
1875  *
1876  *   On success, dtrace_register() returns 0 and stores the new provider's
1877  *   identifier into the memory pointed to by the idp argument.  On failure,
1878  *   dtrace_register() returns an errno:
1879  *
1880  *     EINVAL   The arguments passed to dtrace_register() were somehow invalid.
1881  *              This may because a parameter that must be non-NULL was NULL,
1882  *              because the name was invalid (either empty or an illegal
1883  *              provider name) or because the attributes were invalid.
1884  *
1885  *   No other failure code is returned.
1886  *
1887  * 2.2.4  Caller's context
1888  *
1889  *   dtrace_register() may induce calls to dtrace_provide(); the provider must
1890  *   hold no locks across dtrace_register() that may also be acquired by
1891  *   dtrace_provide().  cpu_lock and mod_lock must not be held.
1892  *
1893  * 2.3  int dtrace_unregister(dtrace_provider_t id)
1894  *
1895  * 2.3.1  Overview
1896  *
1897  *   Unregisters the specified provider from the DTrace framework.  It should
1898  *   generally be called by DTrace providers in their detach(9E) entry point.
1899  *
1900  * 2.3.2  Arguments and Notes
1901  *
1902  *   The only argument is the provider identifier, as returned from a
1903  *   successful call to dtrace_register().  As a result of calling
1904  *   dtrace_unregister(), the DTrace framework will call back into the provider
1905  *   via the dtps_destroy() entry point.  Once dtrace_unregister() successfully
1906  *   completes, however, the DTrace framework will no longer make calls through
1907  *   the Framework-to-Provider API.
1908  *
1909  * 2.3.3  Return value
1910  *
1911  *   On success, dtrace_unregister returns 0.  On failure, dtrace_unregister()
1912  *   returns an errno:
1913  *
1914  *     EBUSY    There are currently processes that have the DTrace pseudodevice
1915  *              open, or there exists an anonymous enabling that hasn't yet
1916  *              been claimed.
1917  *
1918  *   No other failure code is returned.
1919  *
1920  * 2.3.4  Caller's context
1921  *
1922  *   Because a call to dtrace_unregister() may induce calls through the
1923  *   Framework-to-Provider API, the caller may not hold any lock across
1924  *   dtrace_register() that is also acquired in any of the Framework-to-
1925  *   Provider API functions.  Additionally, mod_lock may not be held.
1926  *
1927  * 2.4  void dtrace_invalidate(dtrace_provider_id_t id)
1928  *
1929  * 2.4.1  Overview
1930  *
1931  *   Invalidates the specified provider.  All subsequent probe lookups for the
1932  *   specified provider will fail, but its probes will not be removed.
1933  *
1934  * 2.4.2  Arguments and note
1935  *
1936  *   The only argument is the provider identifier, as returned from a
1937  *   successful call to dtrace_register().  In general, a provider's probes
1938  *   always remain valid; dtrace_invalidate() is a mechanism for invalidating
1939  *   an entire provider, regardless of whether or not probes are enabled or
1940  *   not.  Note that dtrace_invalidate() will _not_ prevent already enabled
1941  *   probes from firing -- it will merely prevent any new enablings of the
1942  *   provider's probes.
1943  *
1944  * 2.5 int dtrace_condense(dtrace_provider_id_t id)
1945  *
1946  * 2.5.1  Overview
1947  *
1948  *   Removes all the unenabled probes for the given provider. This function is
1949  *   not unlike dtrace_unregister(), except that it doesn't remove the
1950  *   provider just as many of its associated probes as it can.
1951  *
1952  * 2.5.2  Arguments and Notes
1953  *
1954  *   As with dtrace_unregister(), the sole argument is the provider identifier
1955  *   as returned from a successful call to dtrace_register().  As a result of
1956  *   calling dtrace_condense(), the DTrace framework will call back into the
1957  *   given provider's dtps_destroy() entry point for each of the provider's
1958  *   unenabled probes.
1959  *
1960  * 2.5.3  Return value
1961  *
1962  *   Currently, dtrace_condense() always returns 0.  However, consumers of this
1963  *   function should check the return value as appropriate; its behavior may
1964  *   change in the future.
1965  *
1966  * 2.5.4  Caller's context
1967  *
1968  *   As with dtrace_unregister(), the caller may not hold any lock across
1969  *   dtrace_condense() that is also acquired in the provider's entry points.
1970  *   Also, mod_lock may not be held.
1971  *
1972  * 2.6 int dtrace_attached()
1973  *
1974  * 2.6.1  Overview
1975  *
1976  *   Indicates whether or not DTrace has attached.
1977  *
1978  * 2.6.2  Arguments and Notes
1979  *
1980  *   For most providers, DTrace makes initial contact beyond registration.
1981  *   That is, once a provider has registered with DTrace, it waits to hear
1982  *   from DTrace to create probes.  However, some providers may wish to
1983  *   proactively create probes without first being told by DTrace to do so.
1984  *   If providers wish to do this, they must first call dtrace_attached() to
1985  *   determine if DTrace itself has attached.  If dtrace_attached() returns 0,
1986  *   the provider must not make any other Provider-to-Framework API call.
1987  *
1988  * 2.6.3  Return value
1989  *
1990  *   dtrace_attached() returns 1 if DTrace has attached, 0 otherwise.
1991  *
1992  * 2.7  int dtrace_probe_create(dtrace_provider_t id, const char *mod,
1993  *	    const char *func, const char *name, int aframes, void *arg)
1994  *
1995  * 2.7.1  Overview
1996  *
1997  *   Creates a probe with specified module name, function name, and name.
1998  *
1999  * 2.7.2  Arguments and Notes
2000  *
2001  *   The first argument is the provider identifier, as returned from a
2002  *   successful call to dtrace_register().  The second, third, and fourth
2003  *   arguments are the module name, function name, and probe name,
2004  *   respectively.  Of these, module name and function name may both be NULL
2005  *   (in which case the probe is considered to be unanchored), or they may both
2006  *   be non-NULL.  The name must be non-NULL, and must point to a non-empty
2007  *   string.
2008  *
2009  *   The fifth argument is the number of artificial stack frames that will be
2010  *   found on the stack when dtrace_probe() is called for the new probe.  These
2011  *   artificial frames will be automatically be pruned should the stack() or
2012  *   stackdepth() functions be called as part of one of the probe's ECBs.  If
2013  *   the parameter doesn't add an artificial frame, this parameter should be
2014  *   zero.
2015  *
2016  *   The final argument is a probe argument that will be passed back to the
2017  *   provider when a probe-specific operation is called.  (e.g., via
2018  *   dtps_enable(), dtps_disable(), etc.)
2019  *
2020  *   Note that it is up to the provider to be sure that the probe that it
2021  *   creates does not already exist -- if the provider is unsure of the probe's
2022  *   existence, it should assure its absence with dtrace_probe_lookup() before
2023  *   calling dtrace_probe_create().
2024  *
2025  * 2.7.3  Return value
2026  *
2027  *   dtrace_probe_create() always succeeds, and always returns the identifier
2028  *   of the newly-created probe.
2029  *
2030  * 2.7.4  Caller's context
2031  *
2032  *   While dtrace_probe_create() is generally expected to be called from
2033  *   dtps_provide() and/or dtps_provide_module(), it may be called from other
2034  *   non-DTrace contexts.  Neither cpu_lock nor mod_lock may be held.
2035  *
2036  * 2.8  dtrace_id_t dtrace_probe_lookup(dtrace_provider_t id, const char *mod,
2037  *	    const char *func, const char *name)
2038  *
2039  * 2.8.1  Overview
2040  *
2041  *   Looks up a probe based on provdider and one or more of module name,
2042  *   function name and probe name.
2043  *
2044  * 2.8.2  Arguments and Notes
2045  *
2046  *   The first argument is the provider identifier, as returned from a
2047  *   successful call to dtrace_register().  The second, third, and fourth
2048  *   arguments are the module name, function name, and probe name,
2049  *   respectively.  Any of these may be NULL; dtrace_probe_lookup() will return
2050  *   the identifier of the first probe that is provided by the specified
2051  *   provider and matches all of the non-NULL matching criteria.
2052  *   dtrace_probe_lookup() is generally used by a provider to be check the
2053  *   existence of a probe before creating it with dtrace_probe_create().
2054  *
2055  * 2.8.3  Return value
2056  *
2057  *   If the probe exists, returns its identifier.  If the probe does not exist,
2058  *   return DTRACE_IDNONE.
2059  *
2060  * 2.8.4  Caller's context
2061  *
2062  *   While dtrace_probe_lookup() is generally expected to be called from
2063  *   dtps_provide() and/or dtps_provide_module(), it may also be called from
2064  *   other non-DTrace contexts.  Neither cpu_lock nor mod_lock may be held.
2065  *
2066  * 2.9  void *dtrace_probe_arg(dtrace_provider_t id, dtrace_id_t probe)
2067  *
2068  * 2.9.1  Overview
2069  *
2070  *   Returns the probe argument associated with the specified probe.
2071  *
2072  * 2.9.2  Arguments and Notes
2073  *
2074  *   The first argument is the provider identifier, as returned from a
2075  *   successful call to dtrace_register().  The second argument is a probe
2076  *   identifier, as returned from dtrace_probe_lookup() or
2077  *   dtrace_probe_create().  This is useful if a probe has multiple
2078  *   provider-specific components to it:  the provider can create the probe
2079  *   once with provider-specific state, and then add to the state by looking
2080  *   up the probe based on probe identifier.
2081  *
2082  * 2.9.3  Return value
2083  *
2084  *   Returns the argument associated with the specified probe.  If the
2085  *   specified probe does not exist, or if the specified probe is not provided
2086  *   by the specified provider, NULL is returned.
2087  *
2088  * 2.9.4  Caller's context
2089  *
2090  *   While dtrace_probe_arg() is generally expected to be called from
2091  *   dtps_provide() and/or dtps_provide_module(), it may also be called from
2092  *   other non-DTrace contexts.  Neither cpu_lock nor mod_lock may be held.
2093  *
2094  * 2.10  void dtrace_probe(dtrace_id_t probe, uintptr_t arg0, uintptr_t arg1,
2095  *		uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
2096  *
2097  * 2.10.1  Overview
2098  *
2099  *   The epicenter of DTrace:  fires the specified probes with the specified
2100  *   arguments.
2101  *
2102  * 2.10.2  Arguments and Notes
2103  *
2104  *   The first argument is a probe identifier as returned by
2105  *   dtrace_probe_create() or dtrace_probe_lookup().  The second through sixth
2106  *   arguments are the values to which the D variables "arg0" through "arg4"
2107  *   will be mapped.
2108  *
2109  *   dtrace_probe() should be called whenever the specified probe has fired --
2110  *   however the provider defines it.
2111  *
2112  * 2.10.3  Return value
2113  *
2114  *   None.
2115  *
2116  * 2.10.4  Caller's context
2117  *
2118  *   dtrace_probe() may be called in virtually any context:  kernel, user,
2119  *   interrupt, high-level interrupt, with arbitrary adaptive locks held, with
2120  *   dispatcher locks held, with interrupts disabled, etc.  The only latitude
2121  *   that must be afforded to DTrace is the ability to make calls within
2122  *   itself (and to its in-kernel subroutines) and the ability to access
2123  *   arbitrary (but mapped) memory.  On some platforms, this constrains
2124  *   context.  For example, on UltraSPARC, dtrace_probe() cannot be called
2125  *   from any context in which TL is greater than zero.  dtrace_probe() may
2126  *   also not be called from any routine which may be called by dtrace_probe()
2127  *   -- which includes functions in the DTrace framework and some in-kernel
2128  *   DTrace subroutines.  All such functions "dtrace_"; providers that
2129  *   instrument the kernel arbitrarily should be sure to not instrument these
2130  *   routines.
2131  */
2132 typedef struct dtrace_pops {
2133 	void (*dtps_provide)(void *arg, dtrace_probedesc_t *spec);
2134 	void (*dtps_provide_module)(void *arg, modctl_t *mp);
2135 	void (*dtps_enable)(void *arg, dtrace_id_t id, void *parg);
2136 	void (*dtps_disable)(void *arg, dtrace_id_t id, void *parg);
2137 	void (*dtps_suspend)(void *arg, dtrace_id_t id, void *parg);
2138 	void (*dtps_resume)(void *arg, dtrace_id_t id, void *parg);
2139 	void (*dtps_getargdesc)(void *arg, dtrace_id_t id, void *parg,
2140 	    dtrace_argdesc_t *desc);
2141 	uint64_t (*dtps_getargval)(void *arg, dtrace_id_t id, void *parg,
2142 	    int argno, int aframes);
2143 	int (*dtps_usermode)(void *arg, dtrace_id_t id, void *parg);
2144 	void (*dtps_destroy)(void *arg, dtrace_id_t id, void *parg);
2145 } dtrace_pops_t;
2146 
2147 #define	DTRACE_MODE_KERNEL			0x01
2148 #define	DTRACE_MODE_USER			0x02
2149 #define	DTRACE_MODE_NOPRIV_DROP			0x10
2150 #define	DTRACE_MODE_NOPRIV_RESTRICT		0x20
2151 #define	DTRACE_MODE_LIMITEDPRIV_RESTRICT	0x40
2152 
2153 typedef uintptr_t	dtrace_provider_id_t;
2154 
2155 extern int dtrace_register(const char *, const dtrace_pattr_t *, uint32_t,
2156     cred_t *, const dtrace_pops_t *, void *, dtrace_provider_id_t *);
2157 extern int dtrace_unregister(dtrace_provider_id_t);
2158 extern int dtrace_condense(dtrace_provider_id_t);
2159 extern void dtrace_invalidate(dtrace_provider_id_t);
2160 extern dtrace_id_t dtrace_probe_lookup(dtrace_provider_id_t, char *,
2161     char *, char *);
2162 extern dtrace_id_t dtrace_probe_create(dtrace_provider_id_t, const char *,
2163     const char *, const char *, int, void *);
2164 extern void *dtrace_probe_arg(dtrace_provider_id_t, dtrace_id_t);
2165 extern void dtrace_probe(dtrace_id_t, uintptr_t arg0, uintptr_t arg1,
2166     uintptr_t arg2, uintptr_t arg3, uintptr_t arg4);
2167 
2168 /*
2169  * DTrace Meta Provider API
2170  *
2171  * The following functions are implemented by the DTrace framework and are
2172  * used to implement meta providers. Meta providers plug into the DTrace
2173  * framework and are used to instantiate new providers on the fly. At
2174  * present, there is only one type of meta provider and only one meta
2175  * provider may be registered with the DTrace framework at a time. The
2176  * sole meta provider type provides user-land static tracing facilities
2177  * by taking meta probe descriptions and adding a corresponding provider
2178  * into the DTrace framework.
2179  *
2180  * 1 Framework-to-Provider
2181  *
2182  * 1.1 Overview
2183  *
2184  * The Framework-to-Provider API is represented by the dtrace_mops structure
2185  * that the meta provider passes to the framework when registering itself as
2186  * a meta provider. This structure consists of the following members:
2187  *
2188  *   dtms_create_probe()	<-- Add a new probe to a created provider
2189  *   dtms_provide_pid()		<-- Create a new provider for a given process
2190  *   dtms_remove_pid()		<-- Remove a previously created provider
2191  *
2192  * 1.2  void dtms_create_probe(void *arg, void *parg,
2193  *           dtrace_helper_probedesc_t *probedesc);
2194  *
2195  * 1.2.1  Overview
2196  *
2197  *   Called by the DTrace framework to create a new probe in a provider
2198  *   created by this meta provider.
2199  *
2200  * 1.2.2  Arguments and notes
2201  *
2202  *   The first argument is the cookie as passed to dtrace_meta_register().
2203  *   The second argument is the provider cookie for the associated provider;
2204  *   this is obtained from the return value of dtms_provide_pid(). The third
2205  *   argument is the helper probe description.
2206  *
2207  * 1.2.3  Return value
2208  *
2209  *   None
2210  *
2211  * 1.2.4  Caller's context
2212  *
2213  *   dtms_create_probe() is called from either ioctl() or module load context
2214  *   in the context of a newly-created provider (that is, a provider that
2215  *   is a result of a call to dtms_provide_pid()). The DTrace framework is
2216  *   locked in such a way that meta providers may not register or unregister,
2217  *   such that no other thread can call into a meta provider operation and that
2218  *   atomicity is assured with respect to meta provider operations across
2219  *   dtms_provide_pid() and subsequent calls to dtms_create_probe().
2220  *   The context is thus effectively single-threaded with respect to the meta
2221  *   provider, and that the meta provider cannot call dtrace_meta_register()
2222  *   or dtrace_meta_unregister(). However, the context is such that the
2223  *   provider may (and is expected to) call provider-related DTrace provider
2224  *   APIs including dtrace_probe_create().
2225  *
2226  * 1.3  void *dtms_provide_pid(void *arg, dtrace_meta_provider_t *mprov,
2227  *	      pid_t pid)
2228  *
2229  * 1.3.1  Overview
2230  *
2231  *   Called by the DTrace framework to instantiate a new provider given the
2232  *   description of the provider and probes in the mprov argument. The
2233  *   meta provider should call dtrace_register() to insert the new provider
2234  *   into the DTrace framework.
2235  *
2236  * 1.3.2  Arguments and notes
2237  *
2238  *   The first argument is the cookie as passed to dtrace_meta_register().
2239  *   The second argument is a pointer to a structure describing the new
2240  *   helper provider. The third argument is the process identifier for
2241  *   process associated with this new provider. Note that the name of the
2242  *   provider as passed to dtrace_register() should be the contatenation of
2243  *   the dtmpb_provname member of the mprov argument and the processs
2244  *   identifier as a string.
2245  *
2246  * 1.3.3  Return value
2247  *
2248  *   The cookie for the provider that the meta provider creates. This is
2249  *   the same value that it passed to dtrace_register().
2250  *
2251  * 1.3.4  Caller's context
2252  *
2253  *   dtms_provide_pid() is called from either ioctl() or module load context.
2254  *   The DTrace framework is locked in such a way that meta providers may not
2255  *   register or unregister. This means that the meta provider cannot call
2256  *   dtrace_meta_register() or dtrace_meta_unregister(). However, the context
2257  *   is such that the provider may -- and is expected to --  call
2258  *   provider-related DTrace provider APIs including dtrace_register().
2259  *
2260  * 1.4  void dtms_remove_pid(void *arg, dtrace_meta_provider_t *mprov,
2261  *	     pid_t pid)
2262  *
2263  * 1.4.1  Overview
2264  *
2265  *   Called by the DTrace framework to remove a provider that had previously
2266  *   been instantiated via the dtms_provide_pid() entry point. The meta
2267  *   provider need not remove the provider immediately, but this entry
2268  *   point indicates that the provider should be removed as soon as possible
2269  *   using the dtrace_unregister() API.
2270  *
2271  * 1.4.2  Arguments and notes
2272  *
2273  *   The first argument is the cookie as passed to dtrace_meta_register().
2274  *   The second argument is a pointer to a structure describing the helper
2275  *   provider. The third argument is the process identifier for process
2276  *   associated with this new provider.
2277  *
2278  * 1.4.3  Return value
2279  *
2280  *   None
2281  *
2282  * 1.4.4  Caller's context
2283  *
2284  *   dtms_remove_pid() is called from either ioctl() or exit() context.
2285  *   The DTrace framework is locked in such a way that meta providers may not
2286  *   register or unregister. This means that the meta provider cannot call
2287  *   dtrace_meta_register() or dtrace_meta_unregister(). However, the context
2288  *   is such that the provider may -- and is expected to -- call
2289  *   provider-related DTrace provider APIs including dtrace_unregister().
2290  */
2291 typedef struct dtrace_helper_probedesc {
2292 	char *dthpb_mod;			/* probe module */
2293 	char *dthpb_func; 			/* probe function */
2294 	char *dthpb_name; 			/* probe name */
2295 	uint64_t dthpb_base;			/* base address */
2296 	uint32_t *dthpb_offs;			/* offsets array */
2297 	uint32_t *dthpb_enoffs;			/* is-enabled offsets array */
2298 	uint32_t dthpb_noffs;			/* offsets count */
2299 	uint32_t dthpb_nenoffs;			/* is-enabled offsets count */
2300 	uint8_t *dthpb_args;			/* argument mapping array */
2301 	uint8_t dthpb_xargc;			/* translated argument count */
2302 	uint8_t dthpb_nargc;			/* native argument count */
2303 	char *dthpb_xtypes;			/* translated types strings */
2304 	char *dthpb_ntypes;			/* native types strings */
2305 } dtrace_helper_probedesc_t;
2306 
2307 typedef struct dtrace_helper_provdesc {
2308 	char *dthpv_provname;			/* provider name */
2309 	dtrace_pattr_t dthpv_pattr;		/* stability attributes */
2310 } dtrace_helper_provdesc_t;
2311 
2312 typedef struct dtrace_mops {
2313 	void (*dtms_create_probe)(void *, void *, dtrace_helper_probedesc_t *);
2314 	void *(*dtms_provide_pid)(void *, dtrace_helper_provdesc_t *, pid_t);
2315 	void (*dtms_remove_pid)(void *, dtrace_helper_provdesc_t *, pid_t);
2316 } dtrace_mops_t;
2317 
2318 typedef uintptr_t	dtrace_meta_provider_id_t;
2319 
2320 extern int dtrace_meta_register(const char *, const dtrace_mops_t *, void *,
2321     dtrace_meta_provider_id_t *);
2322 extern int dtrace_meta_unregister(dtrace_meta_provider_id_t);
2323 
2324 /*
2325  * DTrace Kernel Hooks
2326  *
2327  * The following functions are implemented by the base kernel and form a set of
2328  * hooks used by the DTrace framework.  DTrace hooks are implemented in either
2329  * uts/common/os/dtrace_subr.c, an ISA-specific assembly file, or in a
2330  * uts/<platform>/os/dtrace_subr.c corresponding to each hardware platform.
2331  */
2332 
2333 typedef enum dtrace_vtime_state {
2334 	DTRACE_VTIME_INACTIVE = 0,	/* No DTrace, no TNF */
2335 	DTRACE_VTIME_ACTIVE,		/* DTrace virtual time, no TNF */
2336 	DTRACE_VTIME_INACTIVE_TNF,	/* No DTrace, TNF active */
2337 	DTRACE_VTIME_ACTIVE_TNF		/* DTrace virtual time _and_ TNF */
2338 } dtrace_vtime_state_t;
2339 
2340 #ifdef illumos
2341 extern dtrace_vtime_state_t dtrace_vtime_active;
2342 #endif
2343 extern void dtrace_vtime_switch(kthread_t *next);
2344 extern void dtrace_vtime_enable_tnf(void);
2345 extern void dtrace_vtime_disable_tnf(void);
2346 extern void dtrace_vtime_enable(void);
2347 extern void dtrace_vtime_disable(void);
2348 
2349 struct regs;
2350 struct reg;
2351 
2352 #ifdef illumos
2353 extern int (*dtrace_pid_probe_ptr)(struct reg *);
2354 extern int (*dtrace_return_probe_ptr)(struct reg *);
2355 extern void (*dtrace_fasttrap_fork_ptr)(proc_t *, proc_t *);
2356 extern void (*dtrace_fasttrap_exec_ptr)(proc_t *);
2357 extern void (*dtrace_fasttrap_exit_ptr)(proc_t *);
2358 extern void dtrace_fasttrap_fork(proc_t *, proc_t *);
2359 #endif
2360 
2361 typedef uintptr_t dtrace_icookie_t;
2362 typedef void (*dtrace_xcall_t)(void *);
2363 
2364 extern dtrace_icookie_t dtrace_interrupt_disable(void);
2365 extern void dtrace_interrupt_enable(dtrace_icookie_t);
2366 
2367 extern void dtrace_membar_producer(void);
2368 extern void dtrace_membar_consumer(void);
2369 
2370 extern void (*dtrace_cpu_init)(processorid_t);
2371 #ifdef illumos
2372 extern void (*dtrace_modload)(modctl_t *);
2373 extern void (*dtrace_modunload)(modctl_t *);
2374 #endif
2375 extern void (*dtrace_helpers_cleanup)(void);
2376 extern void (*dtrace_helpers_fork)(proc_t *parent, proc_t *child);
2377 extern void (*dtrace_cpustart_init)(void);
2378 extern void (*dtrace_cpustart_fini)(void);
2379 extern void (*dtrace_closef)(void);
2380 
2381 extern void (*dtrace_debugger_init)(void);
2382 extern void (*dtrace_debugger_fini)(void);
2383 extern dtrace_cacheid_t dtrace_predcache_id;
2384 
2385 #ifdef illumos
2386 extern hrtime_t dtrace_gethrtime(void);
2387 #else
2388 void dtrace_debug_printf(const char *, ...) __printflike(1, 2);
2389 #endif
2390 extern void dtrace_sync(void);
2391 extern void dtrace_toxic_ranges(void (*)(uintptr_t, uintptr_t));
2392 extern void dtrace_xcall(processorid_t, dtrace_xcall_t, void *);
2393 extern void dtrace_vpanic(const char *, __va_list);
2394 extern void dtrace_panic(const char *, ...);
2395 
2396 extern int dtrace_safe_defer_signal(void);
2397 extern void dtrace_safe_synchronous_signal(void);
2398 
2399 extern int dtrace_mach_aframes(void);
2400 
2401 #if defined(__i386) || defined(__amd64)
2402 extern int dtrace_instr_size_isa(uint8_t *, model_t, int *);
2403 #ifdef __i386
2404 extern void dtrace_invop_callsite(void);
2405 #endif
2406 #endif
2407 extern void dtrace_invop_add(int (*)(uintptr_t, struct trapframe *, uintptr_t));
2408 extern void dtrace_invop_remove(int (*)(uintptr_t, struct trapframe *,
2409     uintptr_t));
2410 
2411 #ifdef __sparc
2412 extern int dtrace_blksuword32(uintptr_t, uint32_t *, int);
2413 extern void dtrace_getfsr(uint64_t *);
2414 #endif
2415 
2416 #ifndef illumos
2417 extern void dtrace_helpers_duplicate(proc_t *, proc_t *);
2418 extern void dtrace_helpers_destroy(proc_t *);
2419 #endif
2420 
2421 #define	DTRACE_CPUFLAG_ISSET(flag) \
2422 	(cpu_core[curcpu].cpuc_dtrace_flags & (flag))
2423 
2424 #define	DTRACE_CPUFLAG_SET(flag) \
2425 	(cpu_core[curcpu].cpuc_dtrace_flags |= (flag))
2426 
2427 #define	DTRACE_CPUFLAG_CLEAR(flag) \
2428 	(cpu_core[curcpu].cpuc_dtrace_flags &= ~(flag))
2429 
2430 #endif /* _KERNEL */
2431 
2432 extern int dtrace_instr_size(uint8_t *instr);
2433 
2434 #if defined(__i386) || defined(__amd64)
2435 extern int dtrace_dis_get_byte(void *p);
2436 #endif
2437 
2438 #if defined(__riscv)
2439 extern int dtrace_match_opcode(uint32_t insn, int match, int mask);
2440 extern int dtrace_instr_sdsp(uint32_t **instr);
2441 extern int dtrace_instr_ret(uint32_t **instr);
2442 extern int dtrace_instr_c_sdsp(uint32_t **instr);
2443 extern int dtrace_instr_c_ret(uint32_t **instr);
2444 #endif
2445 
2446 #endif	/* _ASM */
2447 
2448 #if defined(__i386) || defined(__amd64)
2449 
2450 #define	DTRACE_INVOP_PUSHL_EBP		1
2451 #define	DTRACE_INVOP_PUSHQ_RBP		DTRACE_INVOP_PUSHL_EBP
2452 #define	DTRACE_INVOP_POPL_EBP		2
2453 #define	DTRACE_INVOP_POPQ_RBP		DTRACE_INVOP_POPL_EBP
2454 #define	DTRACE_INVOP_LEAVE		3
2455 #define	DTRACE_INVOP_NOP		4
2456 #define	DTRACE_INVOP_RET		5
2457 
2458 #if defined(__amd64)
2459 #define	DTRACE_INVOP_CALL		6
2460 #endif
2461 
2462 #elif defined(__powerpc__)
2463 
2464 #define DTRACE_INVOP_BCTR	1
2465 #define DTRACE_INVOP_BLR	2
2466 #define DTRACE_INVOP_JUMP	3
2467 #define DTRACE_INVOP_MFLR_R0	4
2468 #define DTRACE_INVOP_NOP	5
2469 
2470 #elif defined(__arm__)
2471 
2472 #define	DTRACE_INVOP_SHIFT	4
2473 #define	DTRACE_INVOP_MASK	((1 << DTRACE_INVOP_SHIFT) - 1)
2474 #define	DTRACE_INVOP_DATA(x)	((x) >> DTRACE_INVOP_SHIFT)
2475 
2476 #define DTRACE_INVOP_PUSHM	1
2477 #define DTRACE_INVOP_POPM	2
2478 #define DTRACE_INVOP_B		3
2479 
2480 #elif defined(__aarch64__)
2481 
2482 #define	INSN_SIZE	4
2483 
2484 #define	BRK_INSTR	0xd4200000
2485 #define	BRK_IMM16_SHIFT	5
2486 #define	BRK_IMM16_VAL	(0x40d << BRK_IMM16_SHIFT)
2487 
2488 #define	B_MASK		0xff000000
2489 #define	B_DATA_MASK	0x00ffffff
2490 #define	B_INSTR		0x14000000
2491 
2492 #define	BTI_MASK	0xffffff3f
2493 #define	BTI_INSTR	0xd503241f
2494 
2495 #define	NOP_INSTR	0xd503201f
2496 
2497 #define	RET_INSTR	0xd65f03c0
2498 
2499 #define	SUB_MASK	0xffc00000
2500 #define	SUB_INSTR	0xd1000000
2501 #define	SUB_RD_SHIFT	0
2502 #define	SUB_RN_SHIFT	5
2503 #define	SUB_R_MASK	0x1f
2504 #define	SUB_IMM_SHIFT	10
2505 #define	SUB_IMM_MASK	0xfff
2506 
2507 #define	LDP_STP_MASK	0xffc00000
2508 #define	STP_32		0x29800000
2509 #define	STP_64		0xa9800000
2510 #define	LDP_32		0x28c00000
2511 #define	LDP_64		0xa8c00000
2512 #define	LDP_STP_PREIND	(1 << 24)
2513 #define	LDP_STP_DIR	(1 << 22) /* Load instruction */
2514 #define	ARG1_SHIFT	0
2515 #define	ARG1_MASK	0x1f
2516 #define	ARG2_SHIFT	10
2517 #define	ARG2_MASK	0x1f
2518 #define	ADDR_SHIFT	5
2519 #define	ADDR_MASK	0x1f
2520 #define	OFFSET_SHIFT	15
2521 #define	OFFSET_SIZE	7
2522 #define	OFFSET_MASK	((1 << OFFSET_SIZE) - 1)
2523 
2524 #define	DTRACE_PATCHVAL		(BRK_INSTR | BRK_IMM16_VAL)
2525 
2526 #define	DTRACE_INVOP_STP	1
2527 #define	DTRACE_INVOP_RET	2
2528 #define	DTRACE_INVOP_B		3
2529 #define	DTRACE_INVOP_SUB	4
2530 
2531 #elif defined(__mips__)
2532 
2533 #define	INSN_SIZE		4
2534 
2535 /* Load/Store double RA to/from SP */
2536 #define	LDSD_RA_SP_MASK		0xffff0000
2537 #define	LDSD_DATA_MASK		0x0000ffff
2538 #define	SD_RA_SP		0xffbf0000
2539 #define	LD_RA_SP		0xdfbf0000
2540 
2541 #define	DTRACE_INVOP_SD		1
2542 #define	DTRACE_INVOP_LD		2
2543 
2544 #elif defined(__riscv)
2545 
2546 #define	DTRACE_INVOP_SD		1
2547 #define	DTRACE_INVOP_C_SDSP	2
2548 #define	DTRACE_INVOP_RET	3
2549 #define	DTRACE_INVOP_C_RET	4
2550 #define	DTRACE_INVOP_NOP	5
2551 
2552 #endif
2553 
2554 #ifdef	__cplusplus
2555 }
2556 #endif
2557 
2558 #endif	/* _SYS_DTRACE_H */
2559