includes/sys/sdt.h

   1 /* Copyright (C) 2005-2009 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 #ifdef __LP64__
  15 #define STAP_PROBE_ADDR "\t.quad "
  16 #else
  17 #define STAP_PROBE_ADDR "\t.long "
  18 #endif
  19
  20 /* Allocated section needs to be writable when creating pic shared objects
  21    because we store relocatable addresses in them.  We used to make this
  22    read only for non-pic executables, but the new semaphore support relies
  23    on having a writable .probes section to put the enabled variables in. */
  24 #define ALLOCSEC "\"aw\""
  25
  26 /* An allocated section .probes that holds the probe names and addrs. */
  27 #define STAP_PROBE_DATA_(probe,guard,arg)               \
  28   __asm__ volatile (".section .probes," ALLOCSEC "\n"   \
  29                     "\t.align 8\n"                      \
  30                     "1:\n\t.asciz " #probe "\n"         \
  31                     "\t.align 4\n"                      \
  32                     "\t.int " #guard "\n"               \
  33                     "\t.align 8\n"                      \
  34                     STAP_PROBE_ADDR "1b\n"              \
  35                     "\t.align 8\n"                      \
  36                     STAP_PROBE_ADDR #arg "\n"           \
  37                     "\t.int 0\n"                        \
  38                     "\t.previous\n")
  39
  40 #define STAP_PROBE_DATA(probe, guard, arg)      \
  41   STAP_PROBE_DATA_(#probe,guard,arg)
  42
  43 #if defined STAP_HAS_SEMAPHORES && defined EXPERIMENTAL_UTRACE_SDT
  44 #define STAP_SEMAPHORE(probe)   \
  45   if ( probe ## _semaphore )
  46 #else
  47 #define STAP_SEMAPHORE(probe)
  48 #endif
  49
  50 #if ! (defined EXPERIMENTAL_UTRACE_SDT || defined EXPERIMENTAL_KPROBE_SDT)
  51
  52 /* These baroque macros are used to create a unique label. */
  53 #define STAP_CONCAT(a,b) a ## b
  54 #define STAP_LABEL_PREFIX(p) _stapprobe1_ ## p
  55 /* __COUNTER__ is not present in gcc 4.1 */
  56 #if __GNUC__ == 4 && __GNUC_MINOR__ >= 3
  57 #define STAP_COUNTER  STAP_CONCAT(__,COUNTER__)
  58 #else
  59 #define STAP_COUNTER  STAP_CONCAT(__,LINE__)
  60 #endif
  61 #define STAP_LABEL(a,b) STAP_CONCAT(a,b)
  62
  63 /* Taking the address of a local label and/or referencing alloca prevents the
  64    containing function from being inlined, which keeps the parameters visible. */
  65
  66 #if __GNUC__ == 4 && __GNUC_MINOR__ <= 1
  67 #include <alloca.h>
  68 #define STAP_UNINLINE alloca((size_t)0)
  69 #else
  70 #define STAP_UNINLINE
  71 #endif
  72
  73 #if defined __x86_64__ || defined __i386__  || defined __powerpc__ || defined __arm__
  74 #define STAP_NOP "\tnop "
  75 #else
  76 #define STAP_NOP "\tnop 0 "
  77 #endif
  78
  79 #define STAP_UPROBE_GUARD 0x31425250
  80
  81 #define STAP_PROBE_(probe)                      \
  82 do {                                            \
  83   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);  \
  84   __asm__ volatile ("2:\n"                      \
  85                     STAP_NOP);                  \
  86 } while (0)
  87
  88 #define STAP_PROBE1_(probe,label,parm1)                 \
  89 do STAP_SEMAPHORE(probe) {                              \
  90   volatile __typeof__((parm1)) arg1 = parm1;            \
  91   STAP_UNINLINE;                                        \
  92   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);          \
  93   __asm__ volatile ("2:\n"                              \
  94                     STAP_NOP "/* %0 */" :: "g"(arg1));  \
  95  } while (0)
  96
  97 #define STAP_PROBE2_(probe,label,parm1,parm2)                           \
  98 do STAP_SEMAPHORE(probe) {                                              \
  99   volatile __typeof__((parm1)) arg1 = parm1;                            \
 100   volatile __typeof__((parm2)) arg2 = parm2;                            \
 101   STAP_UNINLINE;                                                        \
 102   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 103   __asm__ volatile ("2:\n"                                              \
 104                     STAP_NOP "/* %0 %1 */" :: "g"(arg1), "g"(arg2));    \
 105 } while (0)
 106
 107 #define STAP_PROBE3_(probe,label,parm1,parm2,parm3)                     \
 108 do STAP_SEMAPHORE(probe) {                                              \
 109   volatile __typeof__((parm1)) arg1 = parm1;                            \
 110   volatile __typeof__((parm2)) arg2 = parm2;                            \
 111   volatile __typeof__((parm3)) arg3 = parm3;                            \
 112   STAP_UNINLINE;                                                        \
 113   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 114   __asm__ volatile ("2:\n"                                              \
 115                     STAP_NOP "/* %0 %1 %2 */" :: "g"(arg1), "g"(arg2), "g"(arg3)); \
 116 } while (0)
 117
 118 #define STAP_PROBE4_(probe,label,parm1,parm2,parm3,parm4)               \
 119 do STAP_SEMAPHORE(probe) {                                              \
 120   volatile __typeof__((parm1)) arg1 = parm1;                            \
 121   volatile __typeof__((parm2)) arg2 = parm2;                            \
 122   volatile __typeof__((parm3)) arg3 = parm3;                            \
 123   volatile __typeof__((parm4)) arg4 = parm4;                            \
 124   STAP_UNINLINE;                                                        \
 125   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 126   __asm__ volatile ("2:\n"                                              \
 127                     STAP_NOP "/* %0 %1 %2 %3 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4)); \
 128 } while (0)
 129
 130 #define STAP_PROBE5_(probe,label,parm1,parm2,parm3,parm4,parm5)         \
 131 do  STAP_SEMAPHORE(probe) {                                             \
 132   volatile __typeof__((parm1)) arg1 = parm1;                            \
 133   volatile __typeof__((parm2)) arg2 = parm2;                            \
 134   volatile __typeof__((parm3)) arg3 = parm3;                            \
 135   volatile __typeof__((parm4)) arg4 = parm4;                            \
 136   volatile __typeof__((parm5)) arg5 = parm5;                            \
 137   STAP_UNINLINE;                                                        \
 138   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 139   __asm__ volatile ("2:\n"                                              \
 140                     STAP_NOP "/* %0 %1 %2 %3 %4 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5)); \
 141 } while (0)
 142
 143 #define STAP_PROBE6_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6)   \
 144 do STAP_SEMAPHORE(probe) {                                              \
 145   volatile __typeof__((parm1)) arg1 = parm1;                            \
 146   volatile __typeof__((parm2)) arg2 = parm2;                            \
 147   volatile __typeof__((parm3)) arg3 = parm3;                            \
 148   volatile __typeof__((parm4)) arg4 = parm4;                            \
 149   volatile __typeof__((parm5)) arg5 = parm5;                            \
 150   volatile __typeof__((parm6)) arg6 = parm6;                            \
 151   STAP_UNINLINE;                                                        \
 152   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 153   __asm__ volatile ("2:\n"                                              \
 154                     STAP_NOP "/* %0 %1 %2 %3 %4 %5 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6)); \
 155 } while (0)
 156
 157 #define STAP_PROBE7_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 158 do  STAP_SEMAPHORE(probe) {                                             \
 159   volatile __typeof__((parm1)) arg1 = parm1;                            \
 160   volatile __typeof__((parm2)) arg2 = parm2;                            \
 161   volatile __typeof__((parm3)) arg3 = parm3;                            \
 162   volatile __typeof__((parm4)) arg4 = parm4;                            \
 163   volatile __typeof__((parm5)) arg5 = parm5;                            \
 164   volatile __typeof__((parm6)) arg6 = parm6;                            \
 165   volatile __typeof__((parm7)) arg7 = parm7;                            \
 166   STAP_UNINLINE;                                                        \
 167   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 168   __asm__ volatile ("2:\n"                                              \
 169                     STAP_NOP "/* %0 %1 %2 %3 %4 %5 %6 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7)); \
 170 } while (0)
 171
 172 #define STAP_PROBE8_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 173 do STAP_SEMAPHORE(probe) {                                              \
 174   volatile __typeof__((parm1)) arg1 = parm1;                            \
 175   volatile __typeof__((parm2)) arg2 = parm2;                            \
 176   volatile __typeof__((parm3)) arg3 = parm3;                            \
 177   volatile __typeof__((parm4)) arg4 = parm4;                            \
 178   volatile __typeof__((parm5)) arg5 = parm5;                            \
 179   volatile __typeof__((parm6)) arg6 = parm6;                            \
 180   volatile __typeof__((parm7)) arg7 = parm7;                            \
 181   volatile __typeof__((parm8)) arg8 = parm8;                            \
 182   STAP_UNINLINE;                                                        \
 183   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 184   __asm__ volatile ("2:\n"                                              \
 185                     STAP_NOP "/* %0 %1 %2 %3 %4 %5 %6 %7 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8)); \
 186 } while (0)
 187
 188 #define STAP_PROBE9_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 189 do STAP_SEMAPHORE(probe) {                                              \
 190   volatile __typeof__((parm1)) arg1 = parm1;                            \
 191   volatile __typeof__((parm2)) arg2 = parm2;                            \
 192   volatile __typeof__((parm3)) arg3 = parm3;                            \
 193   volatile __typeof__((parm4)) arg4 = parm4;                            \
 194   volatile __typeof__((parm5)) arg5 = parm5;                            \
 195   volatile __typeof__((parm6)) arg6 = parm6;                            \
 196   volatile __typeof__((parm7)) arg7 = parm7;                            \
 197   volatile __typeof__((parm8)) arg8 = parm8;                            \
 198   volatile __typeof__((parm9)) arg9 = parm9;                            \
 199   STAP_UNINLINE;                                                        \
 200   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 201   __asm__ volatile ("2:\n"                                              \
 202                     STAP_NOP "/* %0 %1 %2 %3 %4 %5 %6 %7 %8 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9)); \
 203 } while (0)
 204
 205 #define STAP_PROBE10_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 206 do STAP_SEMAPHORE(probe) {                                              \
 207   volatile __typeof__((parm1)) arg1 = parm1;                            \
 208   volatile __typeof__((parm2)) arg2 = parm2;                            \
 209   volatile __typeof__((parm3)) arg3 = parm3;                            \
 210   volatile __typeof__((parm4)) arg4 = parm4;                            \
 211   volatile __typeof__((parm5)) arg5 = parm5;                            \
 212   volatile __typeof__((parm6)) arg6 = parm6;                            \
 213   volatile __typeof__((parm7)) arg7 = parm7;                            \
 214   volatile __typeof__((parm8)) arg8 = parm8;                            \
 215   volatile __typeof__((parm9)) arg9 = parm9;                            \
 216   volatile __typeof__((parm10)) arg10 = parm10;                         \
 217   STAP_UNINLINE;                                                        \
 218   STAP_PROBE_DATA(probe,STAP_UPROBE_GUARD,2f);                          \
 219   __asm__ volatile ("2:\n"                                              \
 220                     STAP_NOP "/* %0 %1 %2 %3 %4 %5 %6 %7 %8 %9 */" :: "g"(arg1), "g"(arg2), "g"(arg3), "g"(arg4), "g"(arg5), "g"(arg6), "g"(arg7), "g"(arg8), "g"(arg9), "g"(arg10)); \
 221 } while (0)
 222
 223 #else /* ! (defined EXPERIMENTAL_UTRACE_SDT || defined EXPERIMENTAL_KPROBE_SDT) */
 224 #include <unistd.h>
 225 #include <sys/syscall.h>
 226 # if defined (__USE_ANSI)
 227 extern long int syscall (long int __sysno, ...) __THROW;
 228 # endif
 229 # if defined EXPERIMENTAL_KPROBE_SDT
 230 # define STAP_SYSCALL __NR_getegid
 231 # define STAP_GUARD 0x32425250
 232 # elif defined EXPERIMENTAL_UTRACE_SDT
 233 # define STAP_SYSCALL 0xbead
 234 # define STAP_GUARD 0x33425250
 235 # endif
 236
 237 #include <sys/syscall.h>
 238
 239 #define STAP_PROBE_(probe)                      \
 240 do STAP_SEMAPHORE(probe) {                      \
 241   STAP_PROBE_DATA(probe,STAP_GUARD,0);          \
 242   syscall (STAP_SYSCALL, #probe, STAP_GUARD);   \
 243  } while (0)
 244
 245 #define STAP_PROBE1_(probe,label,parm1)                         \
 246 do STAP_SEMAPHORE(probe) {                                      \
 247   STAP_PROBE_DATA(probe,STAP_GUARD,1);                          \
 248   syscall (STAP_SYSCALL, #probe, STAP_GUARD, (size_t)parm1);    \
 249  } while (0)
 250
 251 #define STAP_PROBE2_(probe,label,parm1,parm2)                           \
 252 do STAP_SEMAPHORE(probe) {                                              \
 253   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 254           size_t arg2 __attribute__((aligned(8)));}                     \
 255   stap_probe2_args = {(size_t)parm1, (size_t)parm2};                    \
 256   STAP_PROBE_DATA(probe,STAP_GUARD,2);                                  \
 257   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe2_args);        \
 258  } while (0)
 259
 260 #define STAP_PROBE3_(probe,label,parm1,parm2,parm3)                     \
 261 do STAP_SEMAPHORE(probe) {                                              \
 262   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 263           size_t arg2 __attribute__((aligned(8)));                      \
 264           size_t arg3 __attribute__((aligned(8)));}                     \
 265   stap_probe3_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3};     \
 266   STAP_PROBE_DATA(probe,STAP_GUARD,3);                                  \
 267   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe3_args);        \
 268  } while (0)
 269
 270 #define STAP_PROBE4_(probe,label,parm1,parm2,parm3,parm4)               \
 271 do STAP_SEMAPHORE(probe) {                                              \
 272   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 273           size_t arg2 __attribute__((aligned(8)));                      \
 274           size_t arg3 __attribute__((aligned(8)));                      \
 275           size_t arg4 __attribute__((aligned(8)));}                     \
 276   stap_probe4_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4}; \
 277   STAP_PROBE_DATA(probe,STAP_GUARD,4);                                  \
 278   syscall (STAP_SYSCALL, #probe, STAP_GUARD,&stap_probe4_args); \
 279  } while (0)
 280
 281 #define STAP_PROBE5_(probe,label,parm1,parm2,parm3,parm4,parm5)         \
 282 do STAP_SEMAPHORE(probe) {                                              \
 283   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 284           size_t arg2 __attribute__((aligned(8)));                      \
 285           size_t arg3 __attribute__((aligned(8)));                      \
 286           size_t arg4 __attribute__((aligned(8)));                      \
 287           size_t arg5 __attribute__((aligned(8)));}                     \
 288   stap_probe5_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 289         (size_t)parm5};                                                 \
 290   STAP_PROBE_DATA(probe,STAP_GUARD,5);                                  \
 291   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe5_args);        \
 292  } while (0)
 293
 294 #define STAP_PROBE6_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6)   \
 295 do STAP_SEMAPHORE(probe) {                                              \
 296   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 297           size_t arg2 __attribute__((aligned(8)));                      \
 298           size_t arg3 __attribute__((aligned(8)));                      \
 299           size_t arg4 __attribute__((aligned(8)));                      \
 300           size_t arg5 __attribute__((aligned(8)));                      \
 301           size_t arg6 __attribute__((aligned(8)));}                     \
 302   stap_probe6_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 303         (size_t)parm5, (size_t)parm6};                                  \
 304   STAP_PROBE_DATA(probe,STAP_GUARD,6);                                  \
 305   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe6_args);        \
 306  } while (0)
 307
 308 #define STAP_PROBE7_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 309 do STAP_SEMAPHORE(probe) {                                              \
 310   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 311           size_t arg2 __attribute__((aligned(8)));                      \
 312           size_t arg3 __attribute__((aligned(8)));                      \
 313           size_t arg4 __attribute__((aligned(8)));                      \
 314           size_t arg5 __attribute__((aligned(8)));                      \
 315           size_t arg6 __attribute__((aligned(8)));                      \
 316           size_t arg7 __attribute__((aligned(8)));}                     \
 317   stap_probe7_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 318         (size_t)parm5, (size_t)parm6, (size_t)parm7};                   \
 319   STAP_PROBE_DATA(probe,STAP_GUARD,7);                                  \
 320   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe7_args);        \
 321  } while (0)
 322
 323 #define STAP_PROBE8_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 324 do STAP_SEMAPHORE(probe) {                                              \
 325   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 326           size_t arg2 __attribute__((aligned(8)));                      \
 327           size_t arg3 __attribute__((aligned(8)));                      \
 328           size_t arg4 __attribute__((aligned(8)));                      \
 329           size_t arg5 __attribute__((aligned(8)));                      \
 330           size_t arg6 __attribute__((aligned(8)));                      \
 331           size_t arg7 __attribute__((aligned(8)));                      \
 332           size_t arg8 __attribute__((aligned(8)));}                     \
 333   stap_probe8_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 334         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8};    \
 335   STAP_PROBE_DATA(probe,STAP_GUARD,8);                                  \
 336   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe8_args);        \
 337  } while (0)
 338
 339 #define STAP_PROBE9_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 340 do STAP_SEMAPHORE(probe) {                                              \
 341   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 342           size_t arg2 __attribute__((aligned(8)));                      \
 343           size_t arg3 __attribute__((aligned(8)));                      \
 344           size_t arg4 __attribute__((aligned(8)));                      \
 345           size_t arg5 __attribute__((aligned(8)));                      \
 346           size_t arg6 __attribute__((aligned(8)));                      \
 347           size_t arg7 __attribute__((aligned(8)));                      \
 348           size_t arg8 __attribute__((aligned(8)));                      \
 349           size_t arg9 __attribute__((aligned(8)));}                     \
 350   stap_probe9_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 351         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8, (size_t)parm9}; \
 352   STAP_PROBE_DATA(probe,STAP_GUARD,9);                                  \
 353   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe9_args);        \
 354  } while (0)
 355
 356 #define STAP_PROBE10_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 357 do STAP_SEMAPHORE(probe) {                                              \
 358   __extension__ struct {size_t arg1 __attribute__((aligned(8)));        \
 359           size_t arg2 __attribute__((aligned(8)));                      \
 360           size_t arg3 __attribute__((aligned(8)));                      \
 361           size_t arg4 __attribute__((aligned(8)));                      \
 362           size_t arg5 __attribute__((aligned(8)));                      \
 363           size_t arg6 __attribute__((aligned(8)));                      \
 364           size_t arg7 __attribute__((aligned(8)));                      \
 365           size_t arg8 __attribute__((aligned(8)));                      \
 366           size_t arg9 __attribute__((aligned(8)));                      \
 367           size_t arg10 __attribute__((aligned(8)));}                    \
 368   stap_probe10_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
 369         (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8, (size_t)parm9, (size_t)parm10}; \
 370   STAP_PROBE_DATA(probe,STAP_GUARD,10);                                 \
 371   syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe10_args);       \
 372  } while (0)
 373
 374 #endif
 375
 376 #define STAP_PROBE(provider,probe)      \
 377   STAP_PROBE_(probe)
 378 #define STAP_PROBE1(provider,probe,parm1)       \
 379   STAP_PROBE1_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1))
 380 #define STAP_PROBE2(provider,probe,parm1,parm2)                              \
 381   STAP_PROBE2_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2))
 382 #define STAP_PROBE3(provider,probe,parm1,parm2,parm3)                        \
 383   STAP_PROBE3_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3))
 384 #define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)                  \
 385   STAP_PROBE4_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4))
 386 #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)            \
 387   STAP_PROBE5_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5))
 388 #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6)      \
 389   STAP_PROBE6_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6))
 390 #define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 391   STAP_PROBE7_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7))
 392 #define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 393   STAP_PROBE8_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8))
 394 #define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 395   STAP_PROBE9_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8),(parm9))
 396 #define STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 397   STAP_PROBE10_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8),(parm9),(parm10))
 398
 399 #define DTRACE_PROBE(provider,probe) \
 400 STAP_PROBE(provider,probe)
 401 #define DTRACE_PROBE1(provider,probe,parm1) \
 402 STAP_PROBE1(provider,probe,parm1)
 403 #define DTRACE_PROBE2(provider,probe,parm1,parm2) \
 404 STAP_PROBE2(provider,probe,parm1,parm2)
 405 #define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \
 406 STAP_PROBE3(provider,probe,parm1,parm2,parm3)
 407 #define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
 408 STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)
 409 #define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
 410 STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)
 411 #define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
 412 STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6)
 413 #define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
 414 STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7)
 415 #define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
 416 STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8)
 417 #define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
 418 STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9)
 419 #define DTRACE_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
 420   STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10)
 421
 422 #endif /* sys/sdt.h */
 423