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