projects / lttng-ust.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Refactoring: bytecode interpreter ABI
[lttng-ust.git] / include / lttng / ust-tracepoint-event.h
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright (C) 2011-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 */
6
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <urcu/compiler.h>
11 #include <urcu/rculist.h>
12 #include <lttng/ust-events.h>
13 #include <lttng/ringbuffer-context.h>
14 #include <lttng/ust-compiler.h>
15 #include <lttng/tracepoint.h>
16 #include <lttng/ust-endian.h>
17 #include <string.h>
18
19 #define __LTTNG_UST_NULL_STRING "(null)"
20
21 #undef tp_list_for_each_entry_rcu
22 #define tp_list_for_each_entry_rcu(pos, head, member) \
23 for (pos = cds_list_entry(tp_rcu_dereference((head)->next), __typeof__(*pos), member); \
24 &pos->member != (head); \
25 pos = cds_list_entry(tp_rcu_dereference(pos->member.next), __typeof__(*pos), member))
26
27 /*
28 * TRACEPOINT_EVENT_CLASS declares a class of tracepoints receiving the
29 * same arguments and having the same field layout.
30 *
31 * TRACEPOINT_EVENT_INSTANCE declares an instance of a tracepoint, with
32 * its own provider and name. It refers to a class (template).
33 *
34 * TRACEPOINT_EVENT declared both a class and an instance and does a
35 * direct mapping from the instance to the class.
36 */
37
38 #undef TRACEPOINT_EVENT
39 #define TRACEPOINT_EVENT(_provider, _name, _args, _fields) \
40 _TRACEPOINT_EVENT_CLASS(_provider, _name, \
41 _TP_PARAMS(_args), \
42 _TP_PARAMS(_fields)) \
43 _TRACEPOINT_EVENT_INSTANCE(_provider, _name, _name, \
44 _TP_PARAMS(_args))
45
46 #undef TRACEPOINT_EVENT_CLASS
47 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
48 _TRACEPOINT_EVENT_CLASS(_provider, _name, _TP_PARAMS(_args), _TP_PARAMS(_fields))
49
50 #undef TRACEPOINT_EVENT_INSTANCE
51 #define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
52 _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _TP_PARAMS(_args))
53
54 /* Helpers */
55 #define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
56
57 #define _tp_max_t(type, x, y) \
58 ({ \
59 type __max1 = (x); \
60 type __max2 = (y); \
61 __max1 > __max2 ? __max1: __max2; \
62 })
63
64 /*
65 * Stage 0 of tracepoint event generation.
66 *
67 * Check that each TRACEPOINT_EVENT provider argument match the
68 * TRACEPOINT_PROVIDER by creating dummy callbacks.
69 */
70
71 /* Reset all macros within TRACEPOINT_EVENT */
72 #include <lttng/ust-tracepoint-event-reset.h>
73
74 static inline lttng_ust_notrace
75 void _TP_COMBINE_TOKENS(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void);
76 static inline
77 void _TP_COMBINE_TOKENS(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void)
78 {
79 }
80
81 #undef _TRACEPOINT_EVENT_CLASS
82 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
83 __tracepoint_provider_mismatch_##_provider();
84
85 #undef _TRACEPOINT_EVENT_INSTANCE
86 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
87 __tracepoint_provider_mismatch_##_provider();
88
89 static inline lttng_ust_notrace
90 void _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void);
91 static inline
92 void _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
93 {
94 #include TRACEPOINT_INCLUDE
95 }
96
97 /*
98 * Stage 0.1 of tracepoint event generation.
99 *
100 * Check that each TRACEPOINT_EVENT provider:name does not exceed the
101 * tracepoint name length limit.
102 */
103
104 /* Reset all macros within TRACEPOINT_EVENT */
105 #include <lttng/ust-tracepoint-event-reset.h>
106
107 #undef _TRACEPOINT_EVENT_INSTANCE
108 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
109 static const char \
110 __tp_name_len_check##_provider##___##_name[LTTNG_UST_ABI_SYM_NAME_LEN] \
111 __attribute__((unused)) = \
112 #_provider ":" #_name;
113
114 #include TRACEPOINT_INCLUDE
115
116 /*
117 * Stage 0.2 of tracepoint event generation.
118 *
119 * Create dummy trace prototypes for each event class, and for each used
120 * template. This will allow checking whether the prototypes from the
121 * class and the instance using the class actually match.
122 */
123
124 /* Reset all macros within TRACEPOINT_EVENT */
125 #include <lttng/ust-tracepoint-event-reset.h>
126
127 #undef TP_ARGS
128 #define TP_ARGS(...) __VA_ARGS__
129
130 #undef _TRACEPOINT_EVENT_INSTANCE
131 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
132 void __event_template_proto___##_provider##___##_template(_TP_ARGS_DATA_PROTO(_args));
133
134 #undef _TRACEPOINT_EVENT_CLASS
135 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
136 void __event_template_proto___##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));
137
138 #include TRACEPOINT_INCLUDE
139
140 /*
141 * Stage 0.9 of tracepoint event generation
142 *
143 * Unfolding the enums
144 */
145 #include <lttng/ust-tracepoint-event-reset.h>
146
147 /* Enumeration entry (single value) */
148 #undef ctf_enum_value
149 #define ctf_enum_value(_string, _value) \
150 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_enum_entry, { \
151 .struct_size = sizeof(struct lttng_ust_enum_entry), \
152 .start = { \
153 .value = lttng_is_signed_type(__typeof__(_value)) ? \
154 (long long) (_value) : (_value), \
155 .signedness = lttng_is_signed_type(__typeof__(_value)), \
156 }, \
157 .end = { \
158 .value = lttng_is_signed_type(__typeof__(_value)) ? \
159 (long long) (_value) : (_value), \
160 .signedness = lttng_is_signed_type(__typeof__(_value)), \
161 }, \
162 .string = (_string), \
163 }),
164
165 /* Enumeration entry (range) */
166 #undef ctf_enum_range
167 #define ctf_enum_range(_string, _range_start, _range_end) \
168 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_enum_entry, { \
169 .struct_size = sizeof(struct lttng_ust_enum_entry), \
170 .start = { \
171 .value = lttng_is_signed_type(__typeof__(_range_start)) ? \
172 (long long) (_range_start) : (_range_start), \
173 .signedness = lttng_is_signed_type(__typeof__(_range_start)), \
174 }, \
175 .end = { \
176 .value = lttng_is_signed_type(__typeof__(_range_end)) ? \
177 (long long) (_range_end) : (_range_end), \
178 .signedness = lttng_is_signed_type(__typeof__(_range_end)), \
179 }, \
180 .string = (_string), \
181 }),
182
183 /* Enumeration entry (automatic value; follows the rules of CTF) */
184 #undef ctf_enum_auto
185 #define ctf_enum_auto(_string) \
186 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_enum_entry, { \
187 .struct_size = sizeof(struct lttng_ust_enum_entry), \
188 .start = { \
189 .value = -1ULL, \
190 .signedness = 0, \
191 }, \
192 .end = { \
193 .value = -1ULL, \
194 .signedness = 0, \
195 }, \
196 .string = (_string), \
197 .options = LTTNG_UST_ENUM_ENTRY_OPTION_IS_AUTO, \
198 }),
199
200 #undef TP_ENUM_VALUES
201 #define TP_ENUM_VALUES(...) \
202 __VA_ARGS__
203
204 #undef TRACEPOINT_ENUM
205 #define TRACEPOINT_ENUM(_provider, _name, _values) \
206 struct lttng_ust_enum_entry *__enum_values__##_provider##_##_name[] = { \
207 _values \
208 ctf_enum_value("", 0) /* Dummy, 0-len array forbidden by C99. */ \
209 };
210 #include TRACEPOINT_INCLUDE
211
212 /*
213 * Stage 0.9.1
214 * Verifying array and sequence elements are of an integer type.
215 */
216
217 /* Reset all macros within TRACEPOINT_EVENT */
218 #include <lttng/ust-tracepoint-event-reset.h>
219 #include <lttng/ust-tracepoint-event-write.h>
220 #include <lttng/ust-tracepoint-event-nowrite.h>
221
222 #undef _ctf_array_encoded
223 #define _ctf_array_encoded(_type, _item, _src, _byte_order, \
224 _length, _encoding, _nowrite, \
225 _elem_type_base) \
226 _lttng_array_element_type_is_supported(_type, _item)
227
228 #undef _ctf_sequence_encoded
229 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, \
230 _length_type, _src_length, _encoding, _nowrite, \
231 _elem_type_base) \
232 _lttng_array_element_type_is_supported(_type, _item)
233
234 #undef TP_FIELDS
235 #define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */
236
237 #undef _TRACEPOINT_EVENT_CLASS
238 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
239 _fields
240
241 #include TRACEPOINT_INCLUDE
242
243 /*
244 * Stage 1 of tracepoint event generation.
245 *
246 * Create event field type metadata section.
247 * Each event produce an array of fields.
248 */
249
250 /* Reset all macros within TRACEPOINT_EVENT */
251 #include <lttng/ust-tracepoint-event-reset.h>
252 #include <lttng/ust-tracepoint-event-write.h>
253 #include <lttng/ust-tracepoint-event-nowrite.h>
254
255 #undef _ctf_integer_ext
256 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
257 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
258 .struct_size = sizeof(struct lttng_ust_event_field), \
259 .name = #_item, \
260 .type = lttng_ust_type_integer_define(_type, _byte_order, _base), \
261 .nowrite = _nowrite, \
262 .nofilter = 0, \
263 }),
264
265 #undef _ctf_float
266 #define _ctf_float(_type, _item, _src, _nowrite) \
267 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
268 .struct_size = sizeof(struct lttng_ust_event_field), \
269 .name = #_item, \
270 .type = lttng_ust_type_float_define(_type), \
271 .nowrite = _nowrite, \
272 .nofilter = 0, \
273 }),
274
275 #undef _ctf_array_encoded
276 #define _ctf_array_encoded(_type, _item, _src, _byte_order, \
277 _length, _encoding, _nowrite, \
278 _elem_type_base) \
279 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
280 .struct_size = sizeof(struct lttng_ust_event_field), \
281 .name = #_item, \
282 .type = (struct lttng_ust_type_common *) __LTTNG_COMPOUND_LITERAL(struct lttng_ust_type_array, { \
283 .parent = { \
284 .type = lttng_ust_type_array, \
285 }, \
286 .struct_size = sizeof(struct lttng_ust_type_array), \
287 .elem_type = lttng_ust_type_integer_define(_type, _byte_order, _elem_type_base), \
288 .length = _length, \
289 .alignment = 0, \
290 .encoding = lttng_ust_string_encoding_##_encoding, \
291 }), \
292 .nowrite = _nowrite, \
293 .nofilter = 0, \
294 }),
295
296 #undef _ctf_sequence_encoded
297 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, \
298 _length_type, _src_length, _encoding, _nowrite, \
299 _elem_type_base) \
300 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
301 .struct_size = sizeof(struct lttng_ust_event_field), \
302 .name = "_" #_item "_length", \
303 .type = lttng_ust_type_integer_define(_length_type, BYTE_ORDER, 10), \
304 .nowrite = _nowrite, \
305 .nofilter = 1, \
306 }), \
307 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
308 .struct_size = sizeof(struct lttng_ust_event_field), \
309 .name = #_item, \
310 .type = (struct lttng_ust_type_common *) __LTTNG_COMPOUND_LITERAL(struct lttng_ust_type_sequence, { \
311 .parent = { \
312 .type = lttng_ust_type_sequence, \
313 }, \
314 .struct_size = sizeof(struct lttng_ust_type_sequence), \
315 .length_name = "_" #_item "_length", \
316 .elem_type = lttng_ust_type_integer_define(_type, _byte_order, _elem_type_base), \
317 .alignment = 0, \
318 .encoding = lttng_ust_string_encoding_##_encoding, \
319 }), \
320 .nowrite = _nowrite, \
321 .nofilter = 0, \
322 }),
323
324 #undef _ctf_string
325 #define _ctf_string(_item, _src, _nowrite) \
326 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
327 .struct_size = sizeof(struct lttng_ust_event_field), \
328 .name = #_item, \
329 .type = (struct lttng_ust_type_common *) __LTTNG_COMPOUND_LITERAL(struct lttng_ust_type_string, { \
330 .parent = { \
331 .type = lttng_ust_type_string, \
332 }, \
333 .struct_size = sizeof(struct lttng_ust_type_string), \
334 .encoding = lttng_ust_string_encoding_UTF8, \
335 }), \
336 .nowrite = _nowrite, \
337 .nofilter = 0, \
338 }),
339
340 #undef _ctf_enum
341 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
342 __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, { \
343 .struct_size = sizeof(struct lttng_ust_event_field), \
344 .name = #_item, \
345 .type = (struct lttng_ust_type_common *) __LTTNG_COMPOUND_LITERAL(struct lttng_ust_type_enum, { \
346 .parent = { \
347 .type = lttng_ust_type_enum, \
348 }, \
349 .struct_size = sizeof(struct lttng_ust_type_enum), \
350 .desc = &__enum_##_provider##_##_name, \
351 .container_type = lttng_ust_type_integer_define(_type, BYTE_ORDER, 10), \
352 }), \
353 .nowrite = _nowrite, \
354 .nofilter = 0, \
355 }),
356
357 #undef TP_FIELDS
358 #define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */
359
360 #undef _TRACEPOINT_EVENT_CLASS
361 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
362 static struct lttng_ust_event_field *__event_fields___##_provider##___##_name[] = { \
363 _fields \
364 ctf_integer(int, dummy, 0) /* Dummy, C99 forbids 0-len array. */ \
365 };
366
367 #undef TRACEPOINT_ENUM
368 #define TRACEPOINT_ENUM(_provider, _name, _values) \
369 static struct lttng_ust_enum_desc __enum_##_provider##_##_name = { \
370 .struct_size = sizeof(struct lttng_ust_enum_desc), \
371 .name = #_provider "_" #_name, \
372 .entries = __enum_values__##_provider##_##_name, \
373 .nr_entries = _TP_ARRAY_SIZE(__enum_values__##_provider##_##_name) - 1, \
374 };
375
376 #include TRACEPOINT_INCLUDE
377
378 /*
379 * Stage 2 of tracepoint event generation.
380 *
381 * Create probe callback prototypes.
382 */
383
384 /* Reset all macros within TRACEPOINT_EVENT */
385 #include <lttng/ust-tracepoint-event-reset.h>
386
387 #undef TP_ARGS
388 #define TP_ARGS(...) __VA_ARGS__
389
390 #undef _TRACEPOINT_EVENT_CLASS
391 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
392 static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));
393
394 #include TRACEPOINT_INCLUDE
395
396 /*
397 * Stage 3.0 of tracepoint event generation.
398 *
399 * Create static inline function that calculates event size.
400 */
401
402 /* Reset all macros within TRACEPOINT_EVENT */
403 #include <lttng/ust-tracepoint-event-reset.h>
404 #include <lttng/ust-tracepoint-event-write.h>
405
406 #undef _ctf_integer_ext
407 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
408 __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
409 __event_len += sizeof(_type);
410
411 #undef _ctf_float
412 #define _ctf_float(_type, _item, _src, _nowrite) \
413 __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
414 __event_len += sizeof(_type);
415
416 #undef _ctf_array_encoded
417 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, _encoding, \
418 _nowrite, _elem_type_base) \
419 __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
420 __event_len += sizeof(_type) * (_length);
421
422 #undef _ctf_sequence_encoded
423 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type, \
424 _src_length, _encoding, _nowrite, _elem_type_base) \
425 __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \
426 __event_len += sizeof(_length_type); \
427 __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
428 __dynamic_len[__dynamic_len_idx] = (_src_length); \
429 __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \
430 __dynamic_len_idx++;
431
432 #undef _ctf_string
433 #define _ctf_string(_item, _src, _nowrite) \
434 __event_len += __dynamic_len[__dynamic_len_idx++] = \
435 strlen((_src) ? (_src) : __LTTNG_UST_NULL_STRING) + 1;
436
437 #undef _ctf_enum
438 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
439 _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
440
441 #undef TP_ARGS
442 #define TP_ARGS(...) __VA_ARGS__
443
444 #undef TP_FIELDS
445 #define TP_FIELDS(...) __VA_ARGS__
446
447 #undef _TRACEPOINT_EVENT_CLASS
448 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
449 static inline lttng_ust_notrace \
450 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)); \
451 static inline \
452 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)) \
453 { \
454 size_t __event_len = 0; \
455 unsigned int __dynamic_len_idx = 0; \
456 \
457 if (0) \
458 (void) __dynamic_len_idx; /* don't warn if unused */ \
459 _fields \
460 return __event_len; \
461 }
462
463 #include TRACEPOINT_INCLUDE
464
465 /*
466 * Stage 3.1 of tracepoint event generation.
467 *
468 * Create static inline function that layout the filter stack data.
469 * We make both write and nowrite data available to the filter.
470 */
471
472 /* Reset all macros within TRACEPOINT_EVENT */
473 #include <lttng/ust-tracepoint-event-reset.h>
474 #include <lttng/ust-tracepoint-event-write.h>
475 #include <lttng/ust-tracepoint-event-nowrite.h>
476
477 #undef _ctf_integer_ext
478 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
479 if (lttng_is_signed_type(_type)) { \
480 int64_t __ctf_tmp_int64; \
481 switch (sizeof(_type)) { \
482 case 1: \
483 { \
484 union { _type t; int8_t v; } __tmp = { (_type) (_src) }; \
485 __ctf_tmp_int64 = (int64_t) __tmp.v; \
486 break; \
487 } \
488 case 2: \
489 { \
490 union { _type t; int16_t v; } __tmp = { (_type) (_src) }; \
491 if (_byte_order != BYTE_ORDER) \
492 __tmp.v = bswap_16(__tmp.v); \
493 __ctf_tmp_int64 = (int64_t) __tmp.v; \
494 break; \
495 } \
496 case 4: \
497 { \
498 union { _type t; int32_t v; } __tmp = { (_type) (_src) }; \
499 if (_byte_order != BYTE_ORDER) \
500 __tmp.v = bswap_32(__tmp.v); \
501 __ctf_tmp_int64 = (int64_t) __tmp.v; \
502 break; \
503 } \
504 case 8: \
505 { \
506 union { _type t; int64_t v; } __tmp = { (_type) (_src) }; \
507 if (_byte_order != BYTE_ORDER) \
508 __tmp.v = bswap_64(__tmp.v); \
509 __ctf_tmp_int64 = (int64_t) __tmp.v; \
510 break; \
511 } \
512 default: \
513 abort(); \
514 }; \
515 memcpy(__stack_data, &__ctf_tmp_int64, sizeof(int64_t)); \
516 } else { \
517 uint64_t __ctf_tmp_uint64; \
518 switch (sizeof(_type)) { \
519 case 1: \
520 { \
521 union { _type t; uint8_t v; } __tmp = { (_type) (_src) }; \
522 __ctf_tmp_uint64 = (uint64_t) __tmp.v; \
523 break; \
524 } \
525 case 2: \
526 { \
527 union { _type t; uint16_t v; } __tmp = { (_type) (_src) }; \
528 if (_byte_order != BYTE_ORDER) \
529 __tmp.v = bswap_16(__tmp.v); \
530 __ctf_tmp_uint64 = (uint64_t) __tmp.v; \
531 break; \
532 } \
533 case 4: \
534 { \
535 union { _type t; uint32_t v; } __tmp = { (_type) (_src) }; \
536 if (_byte_order != BYTE_ORDER) \
537 __tmp.v = bswap_32(__tmp.v); \
538 __ctf_tmp_uint64 = (uint64_t) __tmp.v; \
539 break; \
540 } \
541 case 8: \
542 { \
543 union { _type t; uint64_t v; } __tmp = { (_type) (_src) }; \
544 if (_byte_order != BYTE_ORDER) \
545 __tmp.v = bswap_64(__tmp.v); \
546 __ctf_tmp_uint64 = (uint64_t) __tmp.v; \
547 break; \
548 } \
549 default: \
550 abort(); \
551 }; \
552 memcpy(__stack_data, &__ctf_tmp_uint64, sizeof(uint64_t)); \
553 } \
554 __stack_data += sizeof(int64_t);
555
556 #undef _ctf_float
557 #define _ctf_float(_type, _item, _src, _nowrite) \
558 { \
559 double __ctf_tmp_double = (double) (_type) (_src); \
560 memcpy(__stack_data, &__ctf_tmp_double, sizeof(double)); \
561 __stack_data += sizeof(double); \
562 }
563
564 #undef _ctf_array_encoded
565 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \
566 _encoding, _nowrite, _elem_type_base) \
567 { \
568 unsigned long __ctf_tmp_ulong = (unsigned long) (_length); \
569 const void *__ctf_tmp_ptr = (_src); \
570 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
571 __stack_data += sizeof(unsigned long); \
572 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \
573 __stack_data += sizeof(void *); \
574 }
575
576 #undef _ctf_sequence_encoded
577 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type, \
578 _src_length, _encoding, _nowrite, _elem_type_base) \
579 { \
580 unsigned long __ctf_tmp_ulong = (unsigned long) (_src_length); \
581 const void *__ctf_tmp_ptr = (_src); \
582 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
583 __stack_data += sizeof(unsigned long); \
584 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \
585 __stack_data += sizeof(void *); \
586 }
587
588 #undef _ctf_string
589 #define _ctf_string(_item, _src, _nowrite) \
590 { \
591 const void *__ctf_tmp_ptr = \
592 ((_src) ? (_src) : __LTTNG_UST_NULL_STRING); \
593 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \
594 __stack_data += sizeof(void *); \
595 }
596
597 #undef _ctf_enum
598 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
599 _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
600
601 #undef TP_ARGS
602 #define TP_ARGS(...) __VA_ARGS__
603
604 #undef TP_FIELDS
605 #define TP_FIELDS(...) __VA_ARGS__
606
607 #undef _TRACEPOINT_EVENT_CLASS
608 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
609 static inline \
610 void __event_prepare_interpreter_stack__##_provider##___##_name(char *__stack_data,\
611 _TP_ARGS_DATA_PROTO(_args)) \
612 { \
613 _fields \
614 }
615
616 #include TRACEPOINT_INCLUDE
617
618 /*
619 * Stage 4 of tracepoint event generation.
620 *
621 * Create static inline function that calculates event payload alignment.
622 */
623
624 /* Reset all macros within TRACEPOINT_EVENT */
625 #include <lttng/ust-tracepoint-event-reset.h>
626 #include <lttng/ust-tracepoint-event-write.h>
627
628 #undef _ctf_integer_ext
629 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
630 __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
631
632 #undef _ctf_float
633 #define _ctf_float(_type, _item, _src, _nowrite) \
634 __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
635
636 #undef _ctf_array_encoded
637 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \
638 _encoding, _nowrite, _elem_type_base) \
639 __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
640
641 #undef _ctf_sequence_encoded
642 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type, \
643 _src_length, _encoding, _nowrite, _elem_type_base) \
644 __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type)); \
645 __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
646
647 #undef _ctf_string
648 #define _ctf_string(_item, _src, _nowrite)
649
650 #undef _ctf_enum
651 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
652 _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
653
654 #undef TP_ARGS
655 #define TP_ARGS(...) __VA_ARGS__
656
657 #undef TP_FIELDS
658 #define TP_FIELDS(...) __VA_ARGS__
659
660 #undef _TRACEPOINT_EVENT_CLASS
661 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
662 static inline lttng_ust_notrace \
663 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)); \
664 static inline \
665 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \
666 { \
667 size_t __event_align = 1; \
668 _fields \
669 return __event_align; \
670 }
671
672 #include TRACEPOINT_INCLUDE
673
674
675 /*
676 * Stage 5 of tracepoint event generation.
677 *
678 * Create the probe function. This function calls event size calculation
679 * and writes event data into the buffer.
680 */
681
682 /* Reset all macros within TRACEPOINT_EVENT */
683 #include <lttng/ust-tracepoint-event-reset.h>
684 #include <lttng/ust-tracepoint-event-write.h>
685
686 #undef _ctf_integer_ext
687 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
688 { \
689 _type __tmp = (_src); \
690 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
691 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
692 }
693
694 #undef _ctf_float
695 #define _ctf_float(_type, _item, _src, _nowrite) \
696 { \
697 _type __tmp = (_src); \
698 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
699 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
700 }
701
702 #undef _ctf_array_encoded
703 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \
704 _encoding, _nowrite, _elem_type_base) \
705 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
706 __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
707
708 #undef _ctf_sequence_encoded
709 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type, \
710 _src_length, _encoding, _nowrite, _elem_type_base) \
711 { \
712 _length_type __tmpl = __stackvar.__dynamic_len[__dynamic_len_idx]; \
713 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
714 __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
715 } \
716 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
717 __chan->ops->event_write(&__ctx, _src, \
718 sizeof(_type) * __get_dynamic_len(dest));
719
720 #undef _ctf_string
721 #define _ctf_string(_item, _src, _nowrite) \
722 { \
723 const char *__ctf_tmp_string = \
724 ((_src) ? (_src) : __LTTNG_UST_NULL_STRING); \
725 lib_ring_buffer_align_ctx(&__ctx, \
726 lttng_alignof(*__ctf_tmp_string)); \
727 __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string, \
728 __get_dynamic_len(dest)); \
729 }
730
731
732 #undef _ctf_enum
733 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
734 _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
735
736 /* Beware: this get len actually consumes the len value */
737 #undef __get_dynamic_len
738 #define __get_dynamic_len(field) __stackvar.__dynamic_len[__dynamic_len_idx++]
739
740 #undef TP_ARGS
741 #define TP_ARGS(...) __VA_ARGS__
742
743 #undef TP_FIELDS
744 #define TP_FIELDS(...) __VA_ARGS__
745
746 /*
747 * For state dump, check that "session" argument (mandatory) matches the
748 * session this event belongs to. Ensures that we write state dump data only
749 * into the started session, not into all sessions.
750 */
751 #undef _TP_SESSION_CHECK
752 #ifdef TP_SESSION_CHECK
753 #define _TP_SESSION_CHECK(session, csession) (session == csession)
754 #else /* TP_SESSION_CHECK */
755 #define _TP_SESSION_CHECK(session, csession) 1
756 #endif /* TP_SESSION_CHECK */
757
758 /*
759 * Use of __builtin_return_address(0) sometimes seems to cause stack
760 * corruption on 32-bit PowerPC. Disable this feature on that
761 * architecture for now by always using the NULL value for the ip
762 * context.
763 */
764 #undef _TP_IP_PARAM
765 #ifdef TP_IP_PARAM
766 #define _TP_IP_PARAM(x) (x)
767 #else /* TP_IP_PARAM */
768
769 #if defined(__PPC__) && !defined(__PPC64__)
770 #define _TP_IP_PARAM(x) NULL
771 #else /* #if defined(__PPC__) && !defined(__PPC64__) */
772 #define _TP_IP_PARAM(x) __builtin_return_address(0)
773 #endif /* #else #if defined(__PPC__) && !defined(__PPC64__) */
774
775 #endif /* TP_IP_PARAM */
776
777 /*
778 * Using twice size for filter stack data to hold size and pointer for
779 * each field (worse case). For integers, max size required is 64-bit.
780 * Same for double-precision floats. Those fit within
781 * 2*sizeof(unsigned long) for all supported architectures.
782 * Perform UNION (||) of filter runtime list.
783 */
784 #undef _TRACEPOINT_EVENT_CLASS
785 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
786 static lttng_ust_notrace \
787 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); \
788 static \
789 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \
790 { \
791 struct lttng_ust_event_common *__event = (struct lttng_ust_event_common *) __tp_data; \
792 size_t __dynamic_len_idx = 0; \
793 const size_t __num_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1; \
794 union { \
795 size_t __dynamic_len[__num_fields]; \
796 char __interpreter_stack_data[2 * sizeof(unsigned long) * __num_fields]; \
797 } __stackvar; \
798 int __ret; \
799 \
800 if (0) \
801 (void) __dynamic_len_idx; /* don't warn if unused */ \
802 switch (__event->type) { \
803 case LTTNG_UST_EVENT_TYPE_RECORDER: \
804 { \
805 struct lttng_ust_event_recorder *__event_recorder = (struct lttng_ust_event_recorder *) __event->child; \
806 struct lttng_ust_channel_buffer *__chan = __event_recorder->chan; \
807 struct lttng_ust_channel_common *__chan_common = __chan->parent; \
808 \
809 if (!_TP_SESSION_CHECK(session, __chan_common->session)) \
810 return; \
811 if (caa_unlikely(!CMM_ACCESS_ONCE(__chan_common->session->active))) \
812 return; \
813 if (caa_unlikely(!CMM_ACCESS_ONCE(__chan_common->enabled))) \
814 return; \
815 break; \
816 } \
817 case LTTNG_UST_EVENT_TYPE_NOTIFIER: \
818 break; \
819 } \
820 if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled))) \
821 return; \
822 if (caa_unlikely(!TP_RCU_LINK_TEST())) \
823 return; \
824 if (caa_unlikely(!cds_list_empty(&__event->filter_bytecode_runtime_head))) { \
825 struct lttng_ust_bytecode_runtime *__filter_bc_runtime; \
826 int __filter_record = __event->has_enablers_without_bytecode; \
827 struct lttng_ust_bytecode_filter_ctx filter_ctx; \
828 \
829 filter_ctx.struct_size = sizeof(struct lttng_ust_bytecode_filter_ctx); \
830 __event_prepare_interpreter_stack__##_provider##___##_name(__stackvar.__interpreter_stack_data, \
831 _TP_ARGS_DATA_VAR(_args)); \
832 tp_list_for_each_entry_rcu(__filter_bc_runtime, &__event->filter_bytecode_runtime_head, node) { \
833 if (caa_likely(__filter_bc_runtime->interpreter_func(__filter_bc_runtime, \
834 __stackvar.__interpreter_stack_data, &filter_ctx) == LTTNG_UST_BYTECODE_INTERPRETER_OK)) { \
835 if (caa_unlikely(filter_ctx.result == LTTNG_UST_BYTECODE_FILTER_ACCEPT)) { \
836 __filter_record = 1; \
837 break; \
838 } \
839 } \
840 } \
841 if (caa_likely(!__filter_record)) \
842 return; \
843 } \
844 switch (__event->type) { \
845 case LTTNG_UST_EVENT_TYPE_RECORDER: \
846 { \
847 size_t __event_len, __event_align; \
848 struct lttng_ust_event_recorder *__event_recorder = (struct lttng_ust_event_recorder *) __event->child; \
849 struct lttng_ust_channel_buffer *__chan = __event_recorder->chan; \
850 struct lttng_ust_lib_ring_buffer_ctx __ctx; \
851 struct lttng_ust_stack_ctx __lttng_ctx; \
852 \
853 __event_len = __event_get_size__##_provider##___##_name(__stackvar.__dynamic_len, \
854 _TP_ARGS_DATA_VAR(_args)); \
855 __event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_args)); \
856 memset(&__lttng_ctx, 0, sizeof(__lttng_ctx)); \
857 __lttng_ctx.struct_size = sizeof(struct lttng_ust_stack_ctx); \
858 __lttng_ctx.event_recorder = __event_recorder; \
859 lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_ctx, __event_len, \
860 __event_align, -1, __chan->handle); \
861 __ctx.ip = _TP_IP_PARAM(TP_IP_PARAM); \
862 __ret = __chan->ops->event_reserve(&__ctx, __event_recorder->id); \
863 if (__ret < 0) \
864 return; \
865 _fields \
866 __chan->ops->event_commit(&__ctx); \
867 break; \
868 } \
869 case LTTNG_UST_EVENT_TYPE_NOTIFIER: \
870 { \
871 struct lttng_ust_event_notifier *__event_notifier = (struct lttng_ust_event_notifier *) __event->child; \
872 \
873 if (caa_unlikely(!cds_list_empty(&__event_notifier->capture_bytecode_runtime_head))) \
874 __event_prepare_interpreter_stack__##_provider##___##_name(__stackvar.__interpreter_stack_data, \
875 _TP_ARGS_DATA_VAR(_args)); \
876 \
877 __event_notifier->notification_send(__event_notifier, \
878 __stackvar.__interpreter_stack_data); \
879 break; \
880 } \
881 } \
882 }
883
884 #include TRACEPOINT_INCLUDE
885
886 #undef __get_dynamic_len
887
888 /*
889 * Stage 5.1 of tracepoint event generation.
890 *
891 * Create probe signature
892 */
893
894 /* Reset all macros within TRACEPOINT_EVENT */
895 #include <lttng/ust-tracepoint-event-reset.h>
896
897 #undef TP_ARGS
898 #define TP_ARGS(...) __VA_ARGS__
899
900 #define _TP_EXTRACT_STRING2(...) #__VA_ARGS__
901
902 #undef _TRACEPOINT_EVENT_CLASS
903 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
904 static const char __tp_event_signature___##_provider##___##_name[] = \
905 _TP_EXTRACT_STRING2(_args);
906
907 #include TRACEPOINT_INCLUDE
908
909 #undef _TP_EXTRACT_STRING2
910
911 /*
912 * Stage 6 of tracepoint event generation.
913 *
914 * Tracepoint loglevel mapping definition generation. We generate a
915 * symbol for each mapping for a provider/event to ensure at most a 1 to
916 * 1 mapping between events and loglevels. If the symbol is repeated,
917 * the compiler will complain.
918 */
919
920 /* Reset all macros within TRACEPOINT_EVENT */
921 #include <lttng/ust-tracepoint-event-reset.h>
922
923 /*
924 * Declare _loglevel___##__provider##___##__name as non-static, with
925 * hidden visibility for c++ handling of weakref. We do a weakref to the
926 * symbol in a later stage, which requires that the symbol is not
927 * mangled.
928 */
929 #ifdef __cplusplus
930 #define LTTNG_TP_EXTERN_C extern "C"
931 #else
932 #define LTTNG_TP_EXTERN_C
933 #endif
934
935 #undef TRACEPOINT_LOGLEVEL
936 #define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel) \
937 static const int _loglevel_value___##__provider##___##__name = __loglevel; \
938 LTTNG_TP_EXTERN_C const int *_loglevel___##__provider##___##__name \
939 __attribute__((visibility("hidden"))) = \
940 &_loglevel_value___##__provider##___##__name;
941
942 #include TRACEPOINT_INCLUDE
943
944 #undef LTTNG_TP_EXTERN_C
945
946 /*
947 * Stage 6.1 of tracepoint event generation.
948 *
949 * Tracepoint UML URI info.
950 */
951
952 /* Reset all macros within TRACEPOINT_EVENT */
953 #include <lttng/ust-tracepoint-event-reset.h>
954
955 /*
956 * Declare _model_emf_uri___##__provider##___##__name as non-static,
957 * with hidden visibility for c++ handling of weakref. We do a weakref
958 * to the symbol in a later stage, which requires that the symbol is not
959 * mangled.
960 */
961 #ifdef __cplusplus
962 #define LTTNG_TP_EXTERN_C extern "C"
963 #else
964 #define LTTNG_TP_EXTERN_C
965 #endif
966
967 #undef TRACEPOINT_MODEL_EMF_URI
968 #define TRACEPOINT_MODEL_EMF_URI(__provider, __name, __uri) \
969 LTTNG_TP_EXTERN_C const char *_model_emf_uri___##__provider##___##__name \
970 __attribute__((visibility("hidden"))) = __uri; \
971
972 #include TRACEPOINT_INCLUDE
973
974 #undef LTTNG_TP_EXTERN_C
975
976 /*
977 * Stage 7.1 of tracepoint event generation.
978 *
979 * Create events description structures. We use a weakref because
980 * loglevels are optional. If not declared, the event will point to the
981 * a loglevel that contains NULL.
982 */
983
984 /* Reset all macros within TRACEPOINT_EVENT */
985 #include <lttng/ust-tracepoint-event-reset.h>
986
987 #undef _TRACEPOINT_EVENT_INSTANCE
988 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
989 static const int * \
990 __ref_loglevel___##_provider##___##_name \
991 __attribute__((weakref ("_loglevel___" #_provider "___" #_name))); \
992 static const char * \
993 __ref_model_emf_uri___##_provider##___##_name \
994 __attribute__((weakref ("_model_emf_uri___" #_provider "___" #_name)));\
995 static struct lttng_ust_event_desc __event_desc___##_provider##_##_name = { \
996 .struct_size = sizeof(struct lttng_ust_event_desc), \
997 .name = #_provider ":" #_name, \
998 .probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template, \
999 .ctx = NULL, \
1000 .fields = __event_fields___##_provider##___##_template, \
1001 .nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template) - 1, \
1002 .loglevel = &__ref_loglevel___##_provider##___##_name, \
1003 .signature = __tp_event_signature___##_provider##___##_template, \
1004 .model_emf_uri = &__ref_model_emf_uri___##_provider##___##_name, \
1005 };
1006
1007 #include TRACEPOINT_INCLUDE
1008
1009 /*
1010 * Stage 7.2 of tracepoint event generation.
1011 *
1012 * Create array of events.
1013 */
1014
1015 /* Reset all macros within TRACEPOINT_EVENT */
1016 #include <lttng/ust-tracepoint-event-reset.h>
1017
1018 #undef _TRACEPOINT_EVENT_INSTANCE
1019 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
1020 &__event_desc___##_provider##_##_name,
1021
1022 static struct lttng_ust_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)[] = {
1023 #include TRACEPOINT_INCLUDE
1024 NULL, /* Dummy, C99 forbids 0-len array. */
1025 };
1026
1027
1028 /*
1029 * Stage 8 of tracepoint event generation.
1030 *
1031 * Create a toplevel descriptor for the whole probe.
1032 */
1033
1034 /* non-const because list head will be modified when registered. */
1035 static struct lttng_ust_probe_desc _TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER) = {
1036 .struct_size = sizeof(struct lttng_ust_probe_desc),
1037 .provider = __tp_stringify(TRACEPOINT_PROVIDER),
1038 .event_desc = _TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER),
1039 .nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)) - 1,
1040 .head = { NULL, NULL },
1041 .lazy_init_head = { NULL, NULL },
1042 .lazy = 0,
1043 .major = LTTNG_UST_PROVIDER_MAJOR,
1044 .minor = LTTNG_UST_PROVIDER_MINOR,
1045 };
1046
1047 static int _TP_COMBINE_TOKENS(__probe_register_refcount___, TRACEPOINT_PROVIDER);
1048
1049 /*
1050 * Stage 9 of tracepoint event generation.
1051 *
1052 * Register/unregister probes at module load/unload.
1053 *
1054 * Generate the constructor as an externally visible symbol for use when
1055 * linking the probe statically.
1056 *
1057 * Register refcount is protected by libc dynamic loader mutex.
1058 */
1059
1060 /* Reset all macros within TRACEPOINT_EVENT */
1061 #include <lttng/ust-tracepoint-event-reset.h>
1062 static void lttng_ust_notrace __attribute__((constructor))
1063 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void);
1064 static void
1065 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
1066 {
1067 int ret;
1068
1069 if (_TP_COMBINE_TOKENS(__probe_register_refcount___,
1070 TRACEPOINT_PROVIDER)++) {
1071 return;
1072 }
1073 /*
1074 * __tracepoint_provider_check_ ## TRACEPOINT_PROVIDER() is a
1075 * static inline function that ensures every probe PROVIDER
1076 * argument match the provider within which they appear. It
1077 * calls empty static inline functions, and therefore has no
1078 * runtime effect. However, if it detects an error, a linker
1079 * error will appear.
1080 */
1081 _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)();
1082 ret = lttng_ust_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
1083 if (ret) {
1084 fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe.\n", ret);
1085 abort();
1086 }
1087 }
1088
1089 static void lttng_ust_notrace __attribute__((destructor))
1090 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void);
1091 static void
1092 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
1093 {
1094 if (--_TP_COMBINE_TOKENS(__probe_register_refcount___,
1095 TRACEPOINT_PROVIDER)) {
1096 return;
1097 }
1098 lttng_ust_probe_unregister(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
1099 }
1100
1101 int _TP_COMBINE_TOKENS(__tracepoint_provider_, TRACEPOINT_PROVIDER)
1102 __attribute__((visibility("default")));
LTTng 2.0 Userspace Tracer
This page took 0.05014 seconds and 5 git commands to generate.