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