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