]> 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://sourceware.org/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__ || defined __arm__
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 # elif defined EXPERIMENTAL_UTRACE_SDT
251 # define STAP_SYSCALL 0xbead
252 # define STAP_GUARD 0x33425250
253 # endif
254
255 #include <sys/syscall.h>
256
257 #define STAP_PROBE_(probe) \
258 do { \
259 STAP_PROBE_DATA(probe,STAP_SYSCALL,0); \
260 syscall (STAP_SYSCALL, #probe, STAP_GUARD); \
261 } while (0)
262
263 #define STAP_PROBE1_(probe,label,parm1) \
264 do { \
265 STAP_PROBE_DATA(probe,STAP_GUARD,1); \
266 syscall (STAP_SYSCALL, #probe, STAP_GUARD, (size_t)parm1); \
267 } while (0)
268
269 #define STAP_PROBE2_(probe,label,parm1,parm2) \
270 do { \
271 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
272 size_t arg2 __attribute__((aligned(8)));} \
273 stap_probe2_args = {(size_t)parm1, (size_t)parm2}; \
274 STAP_PROBE_DATA(probe,STAP_GUARD,2); \
275 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe2_args); \
276 } while (0)
277
278 #define STAP_PROBE3_(probe,label,parm1,parm2,parm3) \
279 do { \
280 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
281 size_t arg2 __attribute__((aligned(8))); \
282 size_t arg3 __attribute__((aligned(8)));} \
283 stap_probe3_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3}; \
284 STAP_PROBE_DATA(probe,STAP_GUARD,3); \
285 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe3_args); \
286 } while (0)
287
288 #define STAP_PROBE4_(probe,label,parm1,parm2,parm3,parm4) \
289 do { \
290 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
291 size_t arg2 __attribute__((aligned(8))); \
292 size_t arg3 __attribute__((aligned(8))); \
293 size_t arg4 __attribute__((aligned(8)));} \
294 stap_probe4_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4}; \
295 STAP_PROBE_DATA(probe,STAP_GUARD,4); \
296 syscall (STAP_SYSCALL, #probe, STAP_GUARD,&stap_probe4_args); \
297 } while (0)
298
299 #define STAP_PROBE5_(probe,label,parm1,parm2,parm3,parm4,parm5) \
300 do { \
301 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
302 size_t arg2 __attribute__((aligned(8))); \
303 size_t arg3 __attribute__((aligned(8))); \
304 size_t arg4 __attribute__((aligned(8))); \
305 size_t arg5 __attribute__((aligned(8)));} \
306 stap_probe5_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
307 (size_t)parm5}; \
308 STAP_PROBE_DATA(probe,STAP_GUARD,5); \
309 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe5_args); \
310 } while (0)
311
312 #define STAP_PROBE6_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6) \
313 do { \
314 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
315 size_t arg2 __attribute__((aligned(8))); \
316 size_t arg3 __attribute__((aligned(8))); \
317 size_t arg4 __attribute__((aligned(8))); \
318 size_t arg5 __attribute__((aligned(8))); \
319 size_t arg6 __attribute__((aligned(8)));} \
320 stap_probe6_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
321 (size_t)parm5, (size_t)parm6}; \
322 STAP_PROBE_DATA(probe,STAP_GUARD,6); \
323 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe6_args); \
324 } while (0)
325
326 #define STAP_PROBE7_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
327 do { \
328 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
329 size_t arg2 __attribute__((aligned(8))); \
330 size_t arg3 __attribute__((aligned(8))); \
331 size_t arg4 __attribute__((aligned(8))); \
332 size_t arg5 __attribute__((aligned(8))); \
333 size_t arg6 __attribute__((aligned(8))); \
334 size_t arg7 __attribute__((aligned(8)));} \
335 stap_probe7_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
336 (size_t)parm5, (size_t)parm6, (size_t)parm7}; \
337 STAP_PROBE_DATA(probe,STAP_GUARD,7); \
338 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe7_args); \
339 } while (0)
340
341 #define STAP_PROBE8_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
342 do { \
343 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
344 size_t arg2 __attribute__((aligned(8))); \
345 size_t arg3 __attribute__((aligned(8))); \
346 size_t arg4 __attribute__((aligned(8))); \
347 size_t arg5 __attribute__((aligned(8))); \
348 size_t arg6 __attribute__((aligned(8))); \
349 size_t arg7 __attribute__((aligned(8))); \
350 size_t arg8 __attribute__((aligned(8)));} \
351 stap_probe8_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
352 (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8}; \
353 STAP_PROBE_DATA(probe,STAP_GUARD,8); \
354 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe8_args); \
355 } while (0)
356
357 #define STAP_PROBE9_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
358 do { \
359 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
360 size_t arg2 __attribute__((aligned(8))); \
361 size_t arg3 __attribute__((aligned(8))); \
362 size_t arg4 __attribute__((aligned(8))); \
363 size_t arg5 __attribute__((aligned(8))); \
364 size_t arg6 __attribute__((aligned(8))); \
365 size_t arg7 __attribute__((aligned(8))); \
366 size_t arg8 __attribute__((aligned(8))); \
367 size_t arg9 __attribute__((aligned(8)));} \
368 stap_probe9_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}; \
370 STAP_PROBE_DATA(probe,STAP_GUARD,9); \
371 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe9_args); \
372 } while (0)
373
374 #define STAP_PROBE10_(probe,label,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
375 do { \
376 __extension__ struct {size_t arg1 __attribute__((aligned(8))); \
377 size_t arg2 __attribute__((aligned(8))); \
378 size_t arg3 __attribute__((aligned(8))); \
379 size_t arg4 __attribute__((aligned(8))); \
380 size_t arg5 __attribute__((aligned(8))); \
381 size_t arg6 __attribute__((aligned(8))); \
382 size_t arg7 __attribute__((aligned(8))); \
383 size_t arg8 __attribute__((aligned(8))); \
384 size_t arg9 __attribute__((aligned(8))); \
385 size_t arg10 __attribute__((aligned(8)));} \
386 stap_probe10_args = {(size_t)parm1, (size_t)parm2, (size_t)parm3, (size_t)parm4, \
387 (size_t)parm5, (size_t)parm6, (size_t)parm7, (size_t)parm8, (size_t)parm9, (size_t)parm10}; \
388 STAP_PROBE_DATA(probe,STAP_GUARD,10); \
389 syscall (STAP_SYSCALL, #probe, STAP_GUARD, &stap_probe10_args); \
390 } while (0)
391
392 #endif
393
394 #define STAP_PROBE(provider,probe) \
395 STAP_PROBE_(probe)
396 #define STAP_PROBE1(provider,probe,parm1) \
397 STAP_PROBE1_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1))
398 #define STAP_PROBE2(provider,probe,parm1,parm2) \
399 STAP_PROBE2_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2))
400 #define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \
401 STAP_PROBE3_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3))
402 #define STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
403 STAP_PROBE4_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4))
404 #define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
405 STAP_PROBE5_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5))
406 #define STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
407 STAP_PROBE6_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6))
408 #define STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
409 STAP_PROBE7_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7))
410 #define STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
411 STAP_PROBE8_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8))
412 #define STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
413 STAP_PROBE9_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8),(parm9))
414 #define STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \
415 STAP_PROBE10_(probe,STAP_LABEL(STAP_LABEL_PREFIX(probe),STAP_COUNTER),(parm1),(parm2),(parm3),(parm4),(parm5),(parm6),(parm7),(parm8),(parm9),(parm10))
416
417 #define DTRACE_PROBE(provider,probe) \
418 STAP_PROBE(provider,probe)
419 #define DTRACE_PROBE1(provider,probe,parm1) \
420 STAP_PROBE1(provider,probe,parm1)
421 #define DTRACE_PROBE2(provider,probe,parm1,parm2) \
422 STAP_PROBE2(provider,probe,parm1,parm2)
423 #define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \
424 STAP_PROBE3(provider,probe,parm1,parm2,parm3)
425 #define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \
426 STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4)
427 #define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
428 STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5)
429 #define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \
430 STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6)
431 #define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \
432 STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7)
433 #define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \
434 STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8)
435 #define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \
436 STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9)
437
438 #endif /* sys/sdt.h */
439
systemtap: system-wide probe/trace tool
This page took 0.063443 seconds and 6 git commands to generate.