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