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