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