includes/sys/sdt.h

   1 /* Copyright (C) 2005-2010 Red Hat Inc.
   2
   3    This file is part of systemtap, and is free software in the public domain.
   4 */
   5
   6 #ifndef _SYS_SDT_H
   7 #define _SYS_SDT_H    1
   8
   9 #include <string.h>
  10 #include <sys/types.h>
  11 #include <errno.h>
  12
  13
  14 /* The asm operand string stap_sdt_probe_entry_v2.arg_string
  15    is currently only supported for x86 */
  16 #if ! defined __x86_64__ && ! defined __i386__
  17 #define STAP_SDT_V1 1
  18 #undef STAP_SDT_V2
  19 #endif
  20
  21
  22 typedef struct
  23 {
  24   __extension__ struct
  25   {
  26     int type_a;
  27     int type_b;
  28   };
  29   __uint64_t name;
  30   __uint64_t arg;
  31 }  stap_sdt_probe_entry_v1;
  32
  33 typedef struct
  34 {
  35   __uint64_t type;
  36   __uint64_t name;
  37   __uint64_t provider;
  38   __uint64_t arg_count;
  39   __uint64_t pc;
  40   __uint64_t arg_string;
  41 }   stap_sdt_probe_entry_v2;
  42
  43 #ifdef __LP64__
  44 #define STAP_PROBE_ADDR(arg) "\t.quad " arg
  45 #elif defined (__BIG_ENDIAN__)
  46 #define STAP_PROBE_ADDR(arg) "\t.long 0\n\t.long " arg
  47 #else
  48 #define STAP_PROBE_ADDR(arg) "\t.long " arg
  49 #endif
  50
  51 /* Allocated section needs to be writable when creating pic shared objects
  52    because we store relocatable addresses in them.  We used to make this
  53    read only for non-pic executables, but the new semaphore support relies
  54    on having a writable .probes section to put the enabled variables in. */
  55 #define ALLOCSEC "\"aw\""
  56
  57 /* The asm operand string stap_sdt_probe_entry_v2.arg_string
  58    is currently only supported for x86 */
  59 #if ! defined __x86_64__ && ! defined __i386__
  60 #define STAP_SDT_V1 1
  61 #endif
  62
  63 #define STAP_SEMAPHORE(provider,probe)
  64 #ifdef STAP_SDT_IMPLICIT_ENABLED /* allow users to override */
  65  #if defined STAP_HAS_SEMAPHORES
  66  #undef STAP_SEMAPHORE
  67   #if defined STAP_SDT_V1 || ! defined STAP_SDT_V2
  68   #define STAP_SEMAPHORE(provider,probe) if (__builtin_expect ( probe##_semaphore , 0))
  69   #else /* V2 semaphores are named  with provider prefix */
  70   #define STAP_SEMAPHORE(provider,probe) if (__builtin_expect ( provider##_##probe##_semaphore , 0))
  71   #endif
  72  #endif
  73 #endif
  74
  75 #if ! defined EXPERIMENTAL_KPROBE_SDT
  76
  77 /* An allocated section .probes that holds the probe names and addrs. */
  78 #if defined STAP_SDT_V1 || ! defined STAP_SDT_V2
  79 #define STAP_UPROBE_GUARD 0x31425250
  80 #define STAP_TYPE(t) __typeof__((t))
  81 #define STAP_CAST(t) t
  82 #define STAP_PROBE_DATA_(provider,probe,guard,arg)      \
  83   __asm__ volatile (".section .probes," ALLOCSEC "\n"   \
  84                     "\t.balign 8\n"                     \
  85                     "1:\n\t.asciz " #probe "\n"         \
  86                     "\t.balign 4\n"                     \
  87                     "\t.int " #guard "\n"               \
  88                     "\t.balign 8\n"                     \
  89                     STAP_PROBE_ADDR("1b\n")             \
  90                     "\t.balign 8\n"                     \
  91                     STAP_PROBE_ADDR(#arg "\n")          \
  92                     "\t.int 0\n"                        \
  93                     "\t.previous\n")
  94 #elif defined STAP_SDT_V2
  95 #define STAP_UPROBE_GUARD 0x32425055
  96 #define STAP_TYPE(t) size_t
  97 #define STAP_CAST(t) (size_t)t
  98 #define STAP_PROBE_DATA_(provider,probe,guard,argc)     \
  99   __asm__ volatile ("\t.balign 8\n"                     \
 100                     "1:\n\t.asciz " #probe "\n"         \
 101                     "\t.balign 8\n"                     \
 102                     "4:\n\t.asciz " #provider "\n"      \
 103                     "\t.balign 8\n"                     \
 104                     "\t.int " #guard "\n"               \
 105                     "\t.balign 8\n"                     \
 106                     STAP_PROBE_ADDR ("1b\n")            \
 107                     "\t.balign 8\n"                     \
 108                     STAP_PROBE_ADDR ("4b\n")            \
 109                     "\t.balign 8\n"                     \
 110                     STAP_PROBE_ADDR (#argc "\n")        \
 111                     "\t.balign 8\n"                     \
 112                     STAP_PROBE_ADDR("2f\n")             \
 113                     "\t.balign 8\n"                     \
 114                     STAP_PROBE_ADDR("3b\n")             \
 115                     "\t.int 0\n"                        \
 116                     "\t.previous\n")
 117 #endif
 118 #define STAP_PROBE_DATA(provider,probe, guard, argc)    \
 119   STAP_PROBE_DATA_(#provider,#probe,guard,argc)
 120
 121 /* Taking the address of a local label and/or referencing alloca prevents the
 122    containing function from being inlined, which keeps the parameters visible. */
 123
 124 #if __GNUC__ == 4 && __GNUC_MINOR__ <= 1
 125 #include <alloca.h>
 126 #define STAP_UNINLINE alloca((size_t)0)
 127 #else
 128 #define STAP_UNINLINE
 129 #endif
 130
 131
 132 #if defined __x86_64__ || defined __i386__  || defined __powerpc__ || defined __arm__ || defined __sparc__
 133 #define STAP_NOP "\tnop "
 134 #else
 135 #define STAP_NOP "\tnop 0 "
 136 #endif
 137
 138 #ifndef STAP_SDT_VOLATILE /* allow users to override */
 139 #if (__GNUC__ >= 4 && __GNUC_MINOR__ >= 5 \
 140      || (defined __GNUC_RH_RELEASE__ \
 141          && __GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ >= 3 \
 142          && (__GNUC_PATCHLEVEL__ > 3 || __GNUC_RH_RELEASE__ >= 10)))
 143 #define STAP_SDT_VOLATILE
 144 #else
 145 #define STAP_SDT_VOLATILE volatile
 146 #endif
 147 #endif
 148
 149 /* variadic macro args not allowed by -ansi -pedantic so... */
 150 /* Use "ro" constraint as "g" constraint sometimes gives an auto increment operand */
 151 #define __stap_arg1 "ro"(arg1)
 152 #define __stap_arg2 "ro"(arg1), "ro"(arg2)
 153 #define __stap_arg3 "ro"(arg1), "ro"(arg2), "ro"(arg3)
 154 #define __stap_arg4 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4)
 155 #define __stap_arg5 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5)
 156 #define __stap_arg6 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5), "ro"(arg6)
 157 #define __stap_arg7 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5), "ro"(arg6), "ro"(arg7)
 158 #define __stap_arg8 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5), "ro"(arg6), "ro"(arg7), "ro"(arg8)
 159 #define __stap_arg9 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5), "ro"(arg6), "ro"(arg7), "ro"(arg8), "ro"(arg9)
 160 #define __stap_arg10 "ro"(arg1), "ro"(arg2), "ro"(arg3), "ro"(arg4), "ro"(arg5), "ro"(arg6), "ro"(arg7), "ro"(arg8), "ro"(arg9), "ro"(arg10)
 161
 162 #if defined STAP_SDT_V1 || ! defined STAP_SDT_V2
 163 #define STAP_PROBE_POINT(provider,probe,argc,arg_format,args)   \
 164   STAP_UNINLINE;                                        \
 165   STAP_PROBE_DATA(provider,probe,STAP_UPROBE_GUARD,2f);                 \
 166   __asm__ volatile ("2:\n" STAP_NOP "/* " arg_format " */" :: args);
 167 #define STAP_PROBE(provider,probe)             \
 168 do {                                            \
 169   STAP_PROBE_DATA(provider,probe,STAP_UPROBE_GUARD,2f); \
 170   __asm__ volatile ("2:\n" STAP_NOP);           \
 171 } while (0)
 172 #elif defined STAP_SDT_V2
 173 #define STAP_PROBE_POINT(provider,probe,argc,arg_format,args)   \
 174   STAP_UNINLINE;                                                \
 175   __asm__ volatile (".section .probes," ALLOCSEC "\n"           \
 176                     "\t.balign 8\n"                             \
 177                     "3:\n\t.asciz " #arg_format :: args);       \
 178   STAP_PROBE_DATA(provider,probe,STAP_UPROBE_GUARD,argc);       \
 179   __asm__ volatile ("2:\n" STAP_NOP);
 180 #define STAP_PROBE(provider,probe)                      \
 181 do {                                                    \
 182   __asm__ volatile (".section .probes," ALLOCSEC "\n"   \
 183                     "\t.balign 8\n3:\n");               \
 184   STAP_PROBE_DATA(provider,probe,STAP_UPROBE_GUARD,0);  \
 185   __asm__ volatile ("2:\n" STAP_NOP);                   \
 186 } while (0)
 187 #endif
 188
 189 #define STAP_PROBE1(provider,probe,parm1)                               \
 190   do { STAP_SEMAPHORE(provider,probe) {                                 \
 191   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);   \
 192   STAP_PROBE_POINT(provider,probe, 1, "%0", __stap_arg1)                        \
 193     } } while (0)
 194
 195 #define STAP_PROBE2(provider,probe,parm1,parm2)                 \
 196   do { STAP_SEMAPHORE(provider,probe) {                          \
 197   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);   \
 198   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);   \
 199   STAP_PROBE_POINT(provider,probe, 2, "%0 %1", __stap_arg2);            \
 200        } } while (0)
 201
 202 #define STAP_PROBE3(provider,probe,parm1,parm2,parm3)           \
 203   do { STAP_SEMAPHORE(provider,probe) {                          \
 204   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);   \
 205   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);   \
 206   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);   \
 207   STAP_PROBE_POINT(provider,probe, 3, "%0 %1 %2", __stap_arg3);         \
 208        } } while (0)
 209
 210 #define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)     \
 211   do { STAP_SEMAPHORE(provider,probe) {                          \
 212   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);   \
 213   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);   \
 214   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);   \
 215   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);   \
 216   STAP_PROBE_POINT(provider,probe, 4, "%0 %1 %2 %3", __stap_arg4);      \
 217        } } while (0)
 218
 219 #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)       \
 220   do { STAP_SEMAPHORE(provider,probe) {                                 \
 221   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);   \
 222   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);   \
 223   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);   \
 224   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);   \
 225   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = STAP_CAST(parm5);   \
 226   STAP_PROBE_POINT(provider,probe, 5, "%0 %1 %2 %3 %4", __stap_arg5);   \
 227        } } while (0)
 228
 229 #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
 230   do { STAP_SEMAPHORE(provider,probe) {                                  \
 231   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);           \
 232   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);           \
 233   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);           \
 234   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);           \
 235   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = STAP_CAST(parm5);           \
 236   STAP_SDT_VOLATILE STAP_TYPE(parm6) arg6 = STAP_CAST(parm6);           \
 237   STAP_PROBE_POINT(provider,probe, 6, "%0 %1 %2 %3 %4 %5", __stap_arg6);                \
 238        } } while (0)
 239
 240 #define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 241   do { STAP_SEMAPHORE(provider,probe) {                                 \
 242   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);           \
 243   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);           \
 244   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);           \
 245   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);           \
 246   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = STAP_CAST(parm5);           \
 247   STAP_SDT_VOLATILE STAP_TYPE(parm6) arg6 = STAP_CAST(parm6);           \
 248   STAP_SDT_VOLATILE STAP_TYPE(parm7) arg7 = STAP_CAST(parm7);           \
 249   STAP_PROBE_POINT(provider,probe, 7, "%0 %1 %2 %3 %4 %5 %6", __stap_arg7);     \
 250        } } while (0)
 251
 252 #define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 253   do { STAP_SEMAPHORE(provider,probe) {                                  \
 254   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);           \
 255   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);           \
 256   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);           \
 257   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);           \
 258   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = STAP_CAST(parm5);           \
 259   STAP_SDT_VOLATILE STAP_TYPE(parm6) arg6 = STAP_CAST(parm6);           \
 260   STAP_SDT_VOLATILE STAP_TYPE(parm7) arg7 = STAP_CAST(parm7);           \
 261   STAP_SDT_VOLATILE STAP_TYPE(parm8) arg8 = STAP_CAST(parm8);           \
 262   STAP_PROBE_POINT(provider,probe, 8, "%0 %1 %2 %3 %4 %5 %6 %7", __stap_arg8);  \
 263        } } while (0)
 264
 265 #define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 266   do { STAP_SEMAPHORE(provider,probe) {                                  \
 267   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = STAP_CAST(parm1);           \
 268   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = STAP_CAST(parm2);           \
 269   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = STAP_CAST(parm3);           \
 270   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = STAP_CAST(parm4);           \
 271   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = STAP_CAST(parm5);           \
 272   STAP_SDT_VOLATILE STAP_TYPE(parm6) arg6 = STAP_CAST(parm6);           \
 273   STAP_SDT_VOLATILE STAP_TYPE(parm7) arg7 = STAP_CAST(parm7);           \
 274   STAP_SDT_VOLATILE STAP_TYPE(parm8) arg8 = STAP_CAST(parm8);           \
 275   STAP_SDT_VOLATILE STAP_TYPE(parm9) arg9 = STAP_CAST(parm9);           \
 276   STAP_PROBE_POINT(provider,probe, 9, "%0 %1 %2 %3 %4 %5 %6 %7 %8", __stap_arg9); \
 277        } } while (0)
 278
 279 #define STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 280   do { STAP_SEMAPHORE(provider,probe) {                                  \
 281   STAP_SDT_VOLATILE STAP_TYPE(parm1) arg1 = parm1;                      \
 282   STAP_SDT_VOLATILE STAP_TYPE(parm2) arg2 = parm2;                      \
 283   STAP_SDT_VOLATILE STAP_TYPE(parm3) arg3 = parm3;                      \
 284   STAP_SDT_VOLATILE STAP_TYPE(parm4) arg4 = parm4;                      \
 285   STAP_SDT_VOLATILE STAP_TYPE(parm5) arg5 = parm5;                      \
 286   STAP_SDT_VOLATILE STAP_TYPE(parm6) arg6 = parm6;                      \
 287   STAP_SDT_VOLATILE STAP_TYPE(parm7) arg7 = parm7;                      \
 288   STAP_SDT_VOLATILE STAP_TYPE(parm8) arg8 = parm8;                      \
 289   STAP_SDT_VOLATILE STAP_TYPE(parm9) arg9 = parm9;                      \
 290   STAP_SDT_VOLATILE STAP_TYPE(parm10) arg10 = parm10;                   \
 291   STAP_PROBE_POINT(provider,probe, 10, "%0 %1 %2 %3 %4 %5 %6 %7 %8 %9", __stap_arg10); \
 292        } } while (0)
 293
 294 #else /* ! defined EXPERIMENTAL_KPROBE_SDT */
 295 #include <unistd.h>
 296 #include <sys/syscall.h>
 297 # if defined (__USE_ANSI)
 298 extern long int syscall (long int __sysno, ...) __THROW;
 299 # endif
 300
 301 #include <sys/syscall.h>
 302
 303 /* An allocated section .probes that holds the probe names and addrs. */
 304 # define STAP_SYSCALL __NR_getegid
 305 #if defined STAP_SDT_V1
 306 # define STAP_GUARD 0x32425250
 307 #define STAP_PROBE_DATA_(provider,probe,guard,arg)              \
 308   __asm__ volatile (".section .probes," ALLOCSEC "\n"   \
 309                     "\t.balign 8\n"                     \
 310                     "1:\n\t.asciz " #probe "\n"         \
 311                     "\t.balign 4\n"                     \
 312                     "\t.int " #guard "\n"               \
 313                     "\t.balign 8\n"                     \
 314                     STAP_PROBE_ADDR("1b\n")             \
 315                     "\t.balign 8\n"                     \
 316                     STAP_PROBE_ADDR(#arg "\n")          \
 317                     "\t.int 0\n"                        \
 318                     "\t.previous\n")
 319 #elif defined STAP_SDT_V2 || ! defined STAP_SDT_V1
 320 # define STAP_GUARD 0x3242504b
 321 #define STAP_PROBE_DATA_(provider,probe,guard,argc)     \
 322   __asm__ volatile (".section .probes," ALLOCSEC "\n"   \
 323                     "\t.balign 8\n"                     \
 324                     "1:\n\t.asciz " #probe "\n"         \
 325                     "\t.balign 8\n"                     \
 326                     "4:\t.asciz " #provider "\n"                \
 327                     "\t.balign 8\n"                     \
 328                     "\t.int " #guard "\n"               \
 329                     "\t.balign 8\n"                     \
 330                     STAP_PROBE_ADDR ("1b\n")            \
 331                     "\t.balign 8\n"                     \
 332                     STAP_PROBE_ADDR ("4b\n")            \
 333                     "\t.balign 8\n"                     \
 334                     STAP_PROBE_ADDR (#argc "\n")        \
 335                     "\t.balign 8\n"                     \
 336                     STAP_PROBE_ADDR ("0\n")             \
 337                     "\t.balign 8\n"                     \
 338                     STAP_PROBE_ADDR ("0\n")             \
 339                     "\t.int 0\n"                        \
 340                     "\t.previous\n")
 341 #endif
 342
 343 #define STAP_PROBE_DATA(provider,probe, guard, argc)    \
 344   STAP_PROBE_DATA_(#provider,#probe,guard,argc)
 345
 346 #define STAP_PROBE(provider,probe)                      \
 347   do { STAP_SEMAPHORE(provider,probe) {                 \
 348       STAP_PROBE_DATA(provider,probe,STAP_GUARD,0);     \
 349   syscall (STAP_SYSCALL, #probe, STAP_GUARD);   \
 350        } } while (0)
 351
 352 #define STAP_PROBE1(provider,probe,parm1)                               \
 353   do { STAP_SEMAPHORE(provider,probe) {                                 \
 354       STAP_PROBE_DATA(provider,probe,STAP_GUARD,1);                     \
 355   syscall (STAP_SYSCALL, #probe, STAP_GUARD, (size_t)parm1);    \
 356        } } while (0)
 357
 358 #define STAP_PROBE2(provider,probe,parm1,parm2)                         \
 359   do { STAP_SEMAPHORE(provider,probe) {                                  \
 360   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 361           size_t arg2 __attribute__((aligned(8)));}                     \
 362   stap_probe2_args = {(size_t)parm1, (size_t)parm2};                    \
 363   STAP_PROBE_DATA(provider,probe,STAP_GUARD,2);                         \
 364   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe2_args);        \
 365  } } while (0)
 366
 367 #define STAP_PROBE3(provider,probe,parm1,parm2,parm3)                   \
 368 do { STAP_SEMAPHORE(provider,probe) {                                           \
 369   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 370           size_t arg2 __attribute__((aligned(8)));                      \
 371           size_t arg3 __attribute__((aligned(8)));}                     \
 372   stap_probe3_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3};     \
 373   STAP_PROBE_DATA(provider,probe,STAP_GUARD,3);                         \
 374   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe3_args);        \
 375  } } while (0)
 376
 377 #define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)             \
 378 do { STAP_SEMAPHORE(provider,probe) {                                           \
 379   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 380           size_t arg2 __attribute__((aligned(8)));                      \
 381           size_t arg3 __attribute__((aligned(8)));                      \
 382           size_t arg4 __attribute__((aligned(8)));}                     \
 383   stap_probe4_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4}; \
 384   STAP_PROBE_DATA(provider,probe,STAP_GUARD,4);                         \
 385   syscall (STAP_SYSCALL, #probe, STAP_GUARD,&stap_probe4_args); \
 386  } } while (0)
 387
 388 #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)               \
 389 do { STAP_SEMAPHORE(provider,probe) {                                           \
 390   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 391           size_t arg2 __attribute__((aligned(8)));                      \
 392           size_t arg3 __attribute__((aligned(8)));                      \
 393           size_t arg4 __attribute__((aligned(8)));                      \
 394           size_t arg5 __attribute__((aligned(8)));}                     \
 395   stap_probe5_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 396         (size_t)parm5};                                                 \
 397   STAP_PROBE_DATA(provider,probe,STAP_GUARD,5);                         \
 398   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe5_args);        \
 399  } } while (0)
 400
 401 #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
 402 do { STAP_SEMAPHORE(provider,probe) {                                           \
 403   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 404           size_t arg2 __attribute__((aligned(8)));                      \
 405           size_t arg3 __attribute__((aligned(8)));                      \
 406           size_t arg4 __attribute__((aligned(8)));                      \
 407           size_t arg5 __attribute__((aligned(8)));                      \
 408           size_t arg6 __attribute__((aligned(8)));}                     \
 409   stap_probe6_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 410         (size_t)parm5, (size_t)parm6};                                  \
 411   STAP_PROBE_DATA(provider,probe,STAP_GUARD,6);                         \
 412   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe6_args);        \
 413  } } while (0)
 414
 415 #define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 416 do { STAP_SEMAPHORE(provider,probe) {                                           \
 417   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 418           size_t arg2 __attribute__((aligned(8)));                      \
 419           size_t arg3 __attribute__((aligned(8)));                      \
 420           size_t arg4 __attribute__((aligned(8)));                      \
 421           size_t arg5 __attribute__((aligned(8)));                      \
 422           size_t arg6 __attribute__((aligned(8)));                      \
 423           size_t arg7 __attribute__((aligned(8)));}                     \
 424   stap_probe7_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 425         (size_t)parm5, (size_t)parm6, (size_t)parm7};                   \
 426   STAP_PROBE_DATA(provider,probe,STAP_GUARD,7);                         \
 427   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe7_args);        \
 428  } } while (0)
 429
 430 #define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 431 do { STAP_SEMAPHORE(provider,probe) {                                           \
 432   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 433           size_t arg2 __attribute__((aligned(8)));                      \
 434           size_t arg3 __attribute__((aligned(8)));                      \
 435           size_t arg4 __attribute__((aligned(8)));                      \
 436           size_t arg5 __attribute__((aligned(8)));                      \
 437           size_t arg6 __attribute__((aligned(8)));                      \
 438           size_t arg7 __attribute__((aligned(8)));                      \
 439           size_t arg8 __attribute__((aligned(8)));}                     \
 440   stap_probe8_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 441         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8};    \
 442   STAP_PROBE_DATA(provider,probe,STAP_GUARD,8);                         \
 443   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe8_args);        \
 444  } } while (0)
 445
 446 #define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 447 do { STAP_SEMAPHORE(provider,probe) {                                           \
 448   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 449           size_t arg2 __attribute__((aligned(8)));                      \
 450           size_t arg3 __attribute__((aligned(8)));                      \
 451           size_t arg4 __attribute__((aligned(8)));                      \
 452           size_t arg5 __attribute__((aligned(8)));                      \
 453           size_t arg6 __attribute__((aligned(8)));                      \
 454           size_t arg7 __attribute__((aligned(8)));                      \
 455           size_t arg8 __attribute__((aligned(8)));                      \
 456           size_t arg9 __attribute__((aligned(8)));}                     \
 457   stap_probe9_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 458         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8, (size_t)parm9}; \
 459   STAP_PROBE_DATA(provider,probe,STAP_GUARD,9);                         \
 460   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe9_args);        \
 461  } } while (0)
 462
 463 #define STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 464 do { STAP_SEMAPHORE(provider,probe) {                                           \
 465   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 466           size_t arg2 __attribute__((aligned(8)));                      \
 467           size_t arg3 __attribute__((aligned(8)));                      \
 468           size_t arg4 __attribute__((aligned(8)));                      \
 469           size_t arg5 __attribute__((aligned(8)));                      \
 470           size_t arg6 __attribute__((aligned(8)));                      \
 471           size_t arg7 __attribute__((aligned(8)));                      \
 472           size_t arg8 __attribute__((aligned(8)));                      \
 473           size_t arg9 __attribute__((aligned(8)));                      \
 474           size_t arg10 __attribute__((aligned(8)));}                    \
 475   stap_probe10_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 476         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8, (size_t)parm9, (size_t)parm10}; \
 477   STAP_PROBE_DATA(provider,probe,STAP_GUARD,10);                        \
 478   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe10_args);       \
 479  } } while (0)
 480
 481 #endif
 482
 483 #define DTRACE_PROBE(provider,probe) \
 484 STAP_PROBE(provider,probe)
 485 #define DTRACE_PROBE1(provider,probe,parm1) \
 486 STAP_PROBE1(provider,probe,parm1)
 487 #define DTRACE_PROBE2(provider,probe,parm1,parm2) \
 488 STAP_PROBE2(provider,probe,parm1,parm2)
 489 #define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \
 490 STAP_PROBE3(provider,probe,parm1,parm2,parm3)
 491 #define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
 492 STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)
 493 #define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
 494 STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)
 495 #define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
 496 STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6)
 497 #define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 498 STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7)
 499 #define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 500 STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8)
 501 #define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 502 STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9)
 503 #define DTRACE_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 504   STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10)
 505
 506 #endif /* sys/sdt.h */