-2519

kernel-include/sys/dtrace.h

reviewed

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

-2555

platform-include/sys/dtrace.h

reviewed

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

+1 -1

src/CMakeLists.txt

reviewed

··· 326 326 add_subdirectory(Metal) 327 327 add_subdirectory(kperf) 328 328 add_subdirectory(StreamingZip) 329 329 - add_subdirectory(external/dtrace) 330 329 add_subdirectory(external/bsm) 331 330 add_subdirectory(external/gdb) 332 331 add_subdirectory(external/Heimdal) ··· 358 357 add_subdirectory(external/libauto) 359 358 add_subdirectory(external/WTF) 360 359 add_subdirectory(external/bmalloc) 360 360 + add_subdirectory(external/dtrace) 361 361 362 362 add_subdirectory(lkm) 363 363