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-config.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_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         const 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 = __type_integer(_type, _byte_order, _base, none), \
 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 = __type_float(_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 = {                                       \
 283                         .atype = atype_array_nestable,          \
 284                         .u = {                                  \
 285                                 .array_nestable = {             \
 286                                         .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \
 287                                         __type_integer(_type, _byte_order, _elem_type_base, _encoding)), \
 288                                         .length = _length,      \
 289                                         .alignment = 0,         \
 290                                 }                               \
 291                         }                                       \
 292                 },                                              \
 293                 .nowrite = _nowrite,                            \
 294                 .nofilter = 0,                                  \
 295         }),
 296
 297 #undef _ctf_sequence_encoded
 298 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order,  \
 299                         _length_type, _src_length, _encoding, _nowrite, \
 300                         _elem_type_base)                        \
 301         __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, {        \
 302                 .struct_size = sizeof(struct lttng_ust_event_field), \
 303                 .name = "_" #_item "_length",                   \
 304                 .type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
 305                 .nowrite = _nowrite,                            \
 306                 .nofilter = 1,                                  \
 307         }),                                                     \
 308         __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, {        \
 309                 .struct_size = sizeof(struct lttng_ust_event_field), \
 310                 .name = #_item,                                 \
 311                 .type = {                                       \
 312                         .atype = atype_sequence_nestable,       \
 313                         .u = {                                  \
 314                                 .sequence_nestable = {          \
 315                                         .length_name = "_" #_item "_length", \
 316                                         .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \
 317                                                 __type_integer(_type, _byte_order, _elem_type_base, _encoding)), \
 318                                         .alignment = 0,         \
 319                                 },                              \
 320                         },                                      \
 321                 },                                              \
 322                 .nowrite = _nowrite,                            \
 323                 .nofilter = 0,                                  \
 324         }),
 325
 326 #undef _ctf_string
 327 #define _ctf_string(_item, _src, _nowrite)                      \
 328         __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, {        \
 329                 .struct_size = sizeof(struct lttng_ust_event_field), \
 330                 .name = #_item,                                 \
 331                 .type = {                                       \
 332                         .atype = atype_string,                  \
 333                         .u = {                                  \
 334                                 .string = { .encoding = lttng_encode_UTF8 } \
 335                         },                                      \
 336                 },                                              \
 337                 .nowrite = _nowrite,                            \
 338                 .nofilter = 0,                                  \
 339         }),
 340
 341 #undef _ctf_enum
 342 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite) \
 343         __LTTNG_COMPOUND_LITERAL(struct lttng_ust_event_field, {        \
 344                 .struct_size = sizeof(struct lttng_ust_event_field), \
 345                 .name = #_item,                                 \
 346                 .type = {                                       \
 347                         .atype = atype_enum_nestable,           \
 348                         .u = {                                  \
 349                                 .enum_nestable = {              \
 350                                         .desc = &__enum_##_provider##_##_name, \
 351                                         .container_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \
 352                                                                 __type_integer(_type, BYTE_ORDER, 10, none)), \
 353                                 },                              \
 354                         },                                      \
 355                 },                                              \
 356                 .nowrite = _nowrite,                            \
 357                 .nofilter = 0,                                  \
 358         }),
 359
 360 #undef TP_FIELDS
 361 #define TP_FIELDS(...) __VA_ARGS__      /* Only one used in this phase */
 362
 363 #undef _TRACEPOINT_EVENT_CLASS
 364 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)                            \
 365         static const struct lttng_ust_event_field *__event_fields___##_provider##___##_name[] = { \
 366                 _fields                                                                      \
 367                 ctf_integer(int, dummy, 0)      /* Dummy, C99 forbids 0-len array. */        \
 368         };
 369
 370 #undef TRACEPOINT_ENUM
 371 #define TRACEPOINT_ENUM(_provider, _name, _values)                                      \
 372         static const struct lttng_ust_enum_desc __enum_##_provider##_##_name = {                \
 373                 .struct_size = sizeof(struct lttng_ust_enum_desc),                              \
 374                 .name = #_provider "_" #_name,                                          \
 375                 .entries = __enum_values__##_provider##_##_name,                        \
 376                 .nr_entries = _TP_ARRAY_SIZE(__enum_values__##_provider##_##_name) - 1, \
 377         };
 378
 379 #include TRACEPOINT_INCLUDE
 380
 381 /*
 382  * Stage 2 of tracepoint event generation.
 383  *
 384  * Create probe callback prototypes.
 385  */
 386
 387 /* Reset all macros within TRACEPOINT_EVENT */
 388 #include <lttng/ust-tracepoint-event-reset.h>
 389
 390 #undef TP_ARGS
 391 #define TP_ARGS(...) __VA_ARGS__
 392
 393 #undef _TRACEPOINT_EVENT_CLASS
 394 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)               \
 395 static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));
 396
 397 #include TRACEPOINT_INCLUDE
 398
 399 /*
 400  * Stage 3.0 of tracepoint event generation.
 401  *
 402  * Create static inline function that calculates event size.
 403  */
 404
 405 /* Reset all macros within TRACEPOINT_EVENT */
 406 #include <lttng/ust-tracepoint-event-reset.h>
 407 #include <lttng/ust-tracepoint-event-write.h>
 408
 409 #undef _ctf_integer_ext
 410 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)       \
 411         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 412         __event_len += sizeof(_type);
 413
 414 #undef _ctf_float
 415 #define _ctf_float(_type, _item, _src, _nowrite)                                 \
 416         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 417         __event_len += sizeof(_type);
 418
 419 #undef _ctf_array_encoded
 420 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, _encoding,  \
 421                         _nowrite, _elem_type_base)                               \
 422         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 423         __event_len += sizeof(_type) * (_length);
 424
 425 #undef _ctf_sequence_encoded
 426 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type,     \
 427                         _src_length, _encoding, _nowrite, _elem_type_base)       \
 428         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type));   \
 429         __event_len += sizeof(_length_type);                                   \
 430         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 431         __dynamic_len[__dynamic_len_idx] = (_src_length);                      \
 432         __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
 433         __dynamic_len_idx++;
 434
 435 #undef _ctf_string
 436 #define _ctf_string(_item, _src, _nowrite)                                     \
 437         __event_len += __dynamic_len[__dynamic_len_idx++] =                    \
 438                 strlen((_src) ? (_src) : __LTTNG_UST_NULL_STRING) + 1;
 439
 440 #undef _ctf_enum
 441 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite)               \
 442         _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
 443
 444 #undef TP_ARGS
 445 #define TP_ARGS(...) __VA_ARGS__
 446
 447 #undef TP_FIELDS
 448 #define TP_FIELDS(...) __VA_ARGS__
 449
 450 #undef _TRACEPOINT_EVENT_CLASS
 451 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)             \
 452 static inline lttng_ust_notrace                                               \
 453 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)); \
 454 static inline                                                                 \
 455 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)) \
 456 {                                                                             \
 457         size_t __event_len = 0;                                               \
 458         unsigned int __dynamic_len_idx = 0;                                   \
 459                                                                               \
 460         if (0)                                                                \
 461                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 462         _fields                                                               \
 463         return __event_len;                                                   \
 464 }
 465
 466 #include TRACEPOINT_INCLUDE
 467
 468 /*
 469  * Stage 3.1 of tracepoint event generation.
 470  *
 471  * Create static inline function that layout the filter stack data.
 472  * We make both write and nowrite data available to the filter.
 473  */
 474
 475 /* Reset all macros within TRACEPOINT_EVENT */
 476 #include <lttng/ust-tracepoint-event-reset.h>
 477 #include <lttng/ust-tracepoint-event-write.h>
 478 #include <lttng/ust-tracepoint-event-nowrite.h>
 479
 480 #undef _ctf_integer_ext
 481 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)     \
 482         if (lttng_is_signed_type(_type)) {                                     \
 483                 int64_t __ctf_tmp_int64;                                       \
 484                 switch (sizeof(_type)) {                                       \
 485                 case 1:                                                        \
 486                 {                                                              \
 487                         union { _type t; int8_t v; } __tmp = { (_type) (_src) }; \
 488                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 489                         break;                                                 \
 490                 }                                                              \
 491                 case 2:                                                        \
 492                 {                                                              \
 493                         union { _type t; int16_t v; } __tmp = { (_type) (_src) }; \
 494                         if (_byte_order != BYTE_ORDER)                         \
 495                                 __tmp.v = bswap_16(__tmp.v);                   \
 496                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 497                         break;                                                 \
 498                 }                                                              \
 499                 case 4:                                                        \
 500                 {                                                              \
 501                         union { _type t; int32_t v; } __tmp = { (_type) (_src) }; \
 502                         if (_byte_order != BYTE_ORDER)                         \
 503                                 __tmp.v = bswap_32(__tmp.v);                   \
 504                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 505                         break;                                                 \
 506                 }                                                              \
 507                 case 8:                                                        \
 508                 {                                                              \
 509                         union { _type t; int64_t v; } __tmp = { (_type) (_src) }; \
 510                         if (_byte_order != BYTE_ORDER)                         \
 511                                 __tmp.v = bswap_64(__tmp.v);                   \
 512                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 513                         break;                                                 \
 514                 }                                                              \
 515                 default:                                                       \
 516                         abort();                                               \
 517                 };                                                             \
 518                 memcpy(__stack_data, &__ctf_tmp_int64, sizeof(int64_t));       \
 519         } else {                                                               \
 520                 uint64_t __ctf_tmp_uint64;                                     \
 521                 switch (sizeof(_type)) {                                       \
 522                 case 1:                                                        \
 523                 {                                                              \
 524                         union { _type t; uint8_t v; } __tmp = { (_type) (_src) }; \
 525                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 526                         break;                                                 \
 527                 }                                                              \
 528                 case 2:                                                        \
 529                 {                                                              \
 530                         union { _type t; uint16_t v; } __tmp = { (_type) (_src) }; \
 531                         if (_byte_order != BYTE_ORDER)                         \
 532                                 __tmp.v = bswap_16(__tmp.v);                   \
 533                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 534                         break;                                                 \
 535                 }                                                              \
 536                 case 4:                                                        \
 537                 {                                                              \
 538                         union { _type t; uint32_t v; } __tmp = { (_type) (_src) }; \
 539                         if (_byte_order != BYTE_ORDER)                         \
 540                                 __tmp.v = bswap_32(__tmp.v);                   \
 541                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 542                         break;                                                 \
 543                 }                                                              \
 544                 case 8:                                                        \
 545                 {                                                              \
 546                         union { _type t; uint64_t v; } __tmp = { (_type) (_src) }; \
 547                         if (_byte_order != BYTE_ORDER)                         \
 548                                 __tmp.v = bswap_64(__tmp.v);                   \
 549                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 550                         break;                                                 \
 551                 }                                                              \
 552                 default:                                                       \
 553                         abort();                                               \
 554                 };                                                             \
 555                 memcpy(__stack_data, &__ctf_tmp_uint64, sizeof(uint64_t));     \
 556         }                                                                      \
 557         __stack_data += sizeof(int64_t);
 558
 559 #undef _ctf_float
 560 #define _ctf_float(_type, _item, _src, _nowrite)                               \
 561         {                                                                      \
 562                 double __ctf_tmp_double = (double) (_type) (_src);             \
 563                 memcpy(__stack_data, &__ctf_tmp_double, sizeof(double));       \
 564                 __stack_data += sizeof(double);                                \
 565         }
 566
 567 #undef _ctf_array_encoded
 568 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length,           \
 569                         _encoding, _nowrite, _elem_type_base)                  \
 570         {                                                                      \
 571                 unsigned long __ctf_tmp_ulong = (unsigned long) (_length);     \
 572                 const void *__ctf_tmp_ptr = (_src);                            \
 573                 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
 574                 __stack_data += sizeof(unsigned long);                         \
 575                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *));          \
 576                 __stack_data += sizeof(void *);                                \
 577         }
 578
 579 #undef _ctf_sequence_encoded
 580 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type,   \
 581                         _src_length, _encoding, _nowrite, _elem_type_base)     \
 582         {                                                                      \
 583                 unsigned long __ctf_tmp_ulong = (unsigned long) (_src_length); \
 584                 const void *__ctf_tmp_ptr = (_src);                            \
 585                 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
 586                 __stack_data += sizeof(unsigned long);                         \
 587                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *));          \
 588                 __stack_data += sizeof(void *);                                \
 589         }
 590
 591 #undef _ctf_string
 592 #define _ctf_string(_item, _src, _nowrite)                                     \
 593         {                                                                      \
 594                 const void *__ctf_tmp_ptr =                                    \
 595                         ((_src) ? (_src) : __LTTNG_UST_NULL_STRING);           \
 596                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *));          \
 597                 __stack_data += sizeof(void *);                                \
 598         }
 599
 600 #undef _ctf_enum
 601 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite)               \
 602         _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
 603
 604 #undef TP_ARGS
 605 #define TP_ARGS(...) __VA_ARGS__
 606
 607 #undef TP_FIELDS
 608 #define TP_FIELDS(...) __VA_ARGS__
 609
 610 #undef _TRACEPOINT_EVENT_CLASS
 611 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)             \
 612 static inline                                                                 \
 613 void __event_prepare_interpreter_stack__##_provider##___##_name(char *__stack_data,\
 614                                                  _TP_ARGS_DATA_PROTO(_args))  \
 615 {                                                                             \
 616         _fields                                                               \
 617 }
 618
 619 #include TRACEPOINT_INCLUDE
 620
 621 /*
 622  * Stage 4 of tracepoint event generation.
 623  *
 624  * Create static inline function that calculates event payload alignment.
 625  */
 626
 627 /* Reset all macros within TRACEPOINT_EVENT */
 628 #include <lttng/ust-tracepoint-event-reset.h>
 629 #include <lttng/ust-tracepoint-event-write.h>
 630
 631 #undef _ctf_integer_ext
 632 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)     \
 633         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 634
 635 #undef _ctf_float
 636 #define _ctf_float(_type, _item, _src, _nowrite)                               \
 637         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 638
 639 #undef _ctf_array_encoded
 640 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length,           \
 641                         _encoding, _nowrite, _elem_type_base)                  \
 642         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 643
 644 #undef _ctf_sequence_encoded
 645 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type,   \
 646                         _src_length, _encoding, _nowrite, _elem_type_base)     \
 647         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type));    \
 648         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 649
 650 #undef _ctf_string
 651 #define _ctf_string(_item, _src, _nowrite)
 652
 653 #undef _ctf_enum
 654 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite)               \
 655         _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
 656
 657 #undef TP_ARGS
 658 #define TP_ARGS(...) __VA_ARGS__
 659
 660 #undef TP_FIELDS
 661 #define TP_FIELDS(...) __VA_ARGS__
 662
 663 #undef _TRACEPOINT_EVENT_CLASS
 664 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)             \
 665 static inline lttng_ust_notrace                                               \
 666 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args));     \
 667 static inline                                                                 \
 668 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args))      \
 669 {                                                                             \
 670         size_t __event_align = 1;                                             \
 671         _fields                                                               \
 672         return __event_align;                                                 \
 673 }
 674
 675 #include TRACEPOINT_INCLUDE
 676
 677
 678 /*
 679  * Stage 5 of tracepoint event generation.
 680  *
 681  * Create the probe function. This function calls event size calculation
 682  * and writes event data into the buffer.
 683  */
 684
 685 /* Reset all macros within TRACEPOINT_EVENT */
 686 #include <lttng/ust-tracepoint-event-reset.h>
 687 #include <lttng/ust-tracepoint-event-write.h>
 688
 689 #undef _ctf_integer_ext
 690 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
 691         {                                                               \
 692                 _type __tmp = (_src);                                   \
 693                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
 694                 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
 695         }
 696
 697 #undef _ctf_float
 698 #define _ctf_float(_type, _item, _src, _nowrite)                        \
 699         {                                                               \
 700                 _type __tmp = (_src);                                   \
 701                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
 702                 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
 703         }
 704
 705 #undef _ctf_array_encoded
 706 #define _ctf_array_encoded(_type, _item, _src, _byte_order, _length,    \
 707                         _encoding, _nowrite, _elem_type_base)           \
 708         lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));        \
 709         __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
 710
 711 #undef _ctf_sequence_encoded
 712 #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, _length_type, \
 713                         _src_length, _encoding, _nowrite, _elem_type_base) \
 714         {                                                               \
 715                 _length_type __tmpl = __stackvar.__dynamic_len[__dynamic_len_idx]; \
 716                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
 717                 __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
 718         }                                                               \
 719         lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));        \
 720         __chan->ops->event_write(&__ctx, _src,                          \
 721                 sizeof(_type) * __get_dynamic_len(dest));
 722
 723 #undef _ctf_string
 724 #define _ctf_string(_item, _src, _nowrite)                              \
 725         {                                                                       \
 726                 const char *__ctf_tmp_string =                                  \
 727                         ((_src) ? (_src) : __LTTNG_UST_NULL_STRING);            \
 728                 lib_ring_buffer_align_ctx(&__ctx,                               \
 729                         lttng_alignof(*__ctf_tmp_string));                      \
 730                 __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string,             \
 731                         __get_dynamic_len(dest));                               \
 732         }
 733
 734
 735 #undef _ctf_enum
 736 #define _ctf_enum(_provider, _name, _type, _item, _src, _nowrite)       \
 737         _ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10, _nowrite)
 738
 739 /* Beware: this get len actually consumes the len value */
 740 #undef __get_dynamic_len
 741 #define __get_dynamic_len(field)        __stackvar.__dynamic_len[__dynamic_len_idx++]
 742
 743 #undef TP_ARGS
 744 #define TP_ARGS(...) __VA_ARGS__
 745
 746 #undef TP_FIELDS
 747 #define TP_FIELDS(...) __VA_ARGS__
 748
 749 /*
 750  * For state dump, check that "session" argument (mandatory) matches the
 751  * session this event belongs to. Ensures that we write state dump data only
 752  * into the started session, not into all sessions.
 753  */
 754 #undef _TP_SESSION_CHECK
 755 #ifdef TP_SESSION_CHECK
 756 #define _TP_SESSION_CHECK(session, csession)   (session == csession)
 757 #else /* TP_SESSION_CHECK */
 758 #define _TP_SESSION_CHECK(session, csession)   1
 759 #endif /* TP_SESSION_CHECK */
 760
 761 /*
 762  * Use of __builtin_return_address(0) sometimes seems to cause stack
 763  * corruption on 32-bit PowerPC. Disable this feature on that
 764  * architecture for now by always using the NULL value for the ip
 765  * context.
 766  */
 767 #undef _TP_IP_PARAM
 768 #ifdef TP_IP_PARAM
 769 #define _TP_IP_PARAM(x)         (x)
 770 #else /* TP_IP_PARAM */
 771
 772 #if defined(__PPC__) && !defined(__PPC64__)
 773 #define _TP_IP_PARAM(x)         NULL
 774 #else /* #if defined(__PPC__) && !defined(__PPC64__) */
 775 #define _TP_IP_PARAM(x)         __builtin_return_address(0)
 776 #endif /* #else #if defined(__PPC__) && !defined(__PPC64__) */
 777
 778 #endif /* TP_IP_PARAM */
 779
 780 /*
 781  * Using twice size for filter stack data to hold size and pointer for
 782  * each field (worse case). For integers, max size required is 64-bit.
 783  * Same for double-precision floats. Those fit within
 784  * 2*sizeof(unsigned long) for all supported architectures.
 785  * Perform UNION (||) of filter runtime list.
 786  */
 787 #undef _TRACEPOINT_EVENT_CLASS
 788 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)             \
 789 static lttng_ust_notrace                                                      \
 790 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));      \
 791 static                                                                        \
 792 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args))       \
 793 {                                                                             \
 794         struct lttng_ust_event_common *__event = (struct lttng_ust_event_common *) __tp_data; \
 795         size_t __dynamic_len_idx = 0;                                         \
 796         const size_t __num_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1; \
 797         union {                                                               \
 798                 size_t __dynamic_len[__num_fields];                           \
 799                 char __interpreter_stack_data[2 * sizeof(unsigned long) * __num_fields]; \
 800         } __stackvar;                                                         \
 801         int __ret;                                                            \
 802                                                                               \
 803         if (0)                                                                \
 804                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 805         switch (__event->type) {                                              \
 806         case LTTNG_UST_EVENT_TYPE_RECORDER:                                   \
 807         {                                                                     \
 808                 struct lttng_ust_event_recorder *__event_recorder = (struct lttng_ust_event_recorder *) __event->child; \
 809                 struct lttng_channel *__chan = __event_recorder->chan;        \
 810                                                                               \
 811                 if (!_TP_SESSION_CHECK(session, __chan->session))             \
 812                         return;                                               \
 813                 if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active)))  \
 814                         return;                                               \
 815                 if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled)))          \
 816                         return;                                               \
 817                 break;                                                        \
 818         }                                                                     \
 819         case LTTNG_UST_EVENT_TYPE_NOTIFIER:                                   \
 820                 break;                                                        \
 821         }                                                                     \
 822         if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled)))                 \
 823                 return;                                                       \
 824         if (caa_unlikely(!TP_RCU_LINK_TEST()))                                \
 825                 return;                                                       \
 826         if (caa_unlikely(!cds_list_empty(&__event->filter_bytecode_runtime_head))) { \
 827                 struct lttng_bytecode_runtime *__filter_bc_runtime;           \
 828                 int __filter_record = __event->has_enablers_without_bytecode; \
 829                                                                               \
 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_unlikely(__filter_bc_runtime->interpreter_funcs.filter(__filter_bc_runtime,     \
 834                                         __stackvar.__interpreter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \
 835                                 __filter_record = 1;                          \
 836                                 break;                                        \
 837                         }                                                     \
 838                 }                                                             \
 839                 if (caa_likely(!__filter_record))                             \
 840                         return;                                               \
 841         }                                                                     \
 842         switch (__event->type) {                                              \
 843         case LTTNG_UST_EVENT_TYPE_RECORDER:                                   \
 844         {                                                                     \
 845                 size_t __event_len, __event_align;                            \
 846                 struct lttng_ust_event_recorder *__event_recorder = (struct lttng_ust_event_recorder *) __event->child; \
 847                 struct lttng_channel *__chan = __event_recorder->chan;        \
 848                 struct lttng_ust_lib_ring_buffer_ctx __ctx;                   \
 849                 struct lttng_stack_ctx __lttng_ctx;                           \
 850                                                                               \
 851                 __event_len = __event_get_size__##_provider##___##_name(__stackvar.__dynamic_len, \
 852                          _TP_ARGS_DATA_VAR(_args));                           \
 853                 __event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_args)); \
 854                 memset(&__lttng_ctx, 0, sizeof(__lttng_ctx));                 \
 855                 __lttng_ctx.event_recorder = __event_recorder;                \
 856                 __lttng_ctx.chan_ctx = tp_rcu_dereference(__chan->ctx);       \
 857                 __lttng_ctx.event_ctx = tp_rcu_dereference(__event_recorder->ctx); \
 858                 lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_ctx, __event_len, \
 859                                          __event_align, -1, __chan->handle); \
 860                 __ctx.ip = _TP_IP_PARAM(TP_IP_PARAM);                         \
 861                 __ret = __chan->ops->event_reserve(&__ctx, __event_recorder->id); \
 862                 if (__ret < 0)                                                \
 863                         return;                                               \
 864                 _fields                                                       \
 865                 __chan->ops->event_commit(&__ctx);                            \
 866                 break;                                                        \
 867         }                                                                     \
 868         case LTTNG_UST_EVENT_TYPE_NOTIFIER:                                   \
 869         {                                                                     \
 870                 struct lttng_ust_event_notifier *__event_notifier = (struct lttng_ust_event_notifier *) __event->child; \
 871                                                                               \
 872                 if (caa_unlikely(!cds_list_empty(&__event_notifier->capture_bytecode_runtime_head))) \
 873                         __event_prepare_interpreter_stack__##_provider##___##_name(__stackvar.__interpreter_stack_data, \
 874                                 _TP_ARGS_DATA_VAR(_args));                    \
 875                                                                               \
 876                 __event_notifier->notification_send(__event_notifier,         \
 877                                 __stackvar.__interpreter_stack_data);         \
 878                 break;                                                        \
 879         }                                                                     \
 880         }                                                                     \
 881 }
 882
 883 #include TRACEPOINT_INCLUDE
 884
 885 #undef __get_dynamic_len
 886
 887 /*
 888  * Stage 5.1 of tracepoint event generation.
 889  *
 890  * Create probe signature
 891  */
 892
 893 /* Reset all macros within TRACEPOINT_EVENT */
 894 #include <lttng/ust-tracepoint-event-reset.h>
 895
 896 #undef TP_ARGS
 897 #define TP_ARGS(...) __VA_ARGS__
 898
 899 #define _TP_EXTRACT_STRING2(...)        #__VA_ARGS__
 900
 901 #undef _TRACEPOINT_EVENT_CLASS
 902 #define _TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)       \
 903 static const char __tp_event_signature___##_provider##___##_name[] =    \
 904                 _TP_EXTRACT_STRING2(_args);
 905
 906 #include TRACEPOINT_INCLUDE
 907
 908 #undef _TP_EXTRACT_STRING2
 909
 910 /*
 911  * Stage 6 of tracepoint event generation.
 912  *
 913  * Tracepoint loglevel mapping definition generation. We generate a
 914  * symbol for each mapping for a provider/event to ensure at most a 1 to
 915  * 1 mapping between events and loglevels. If the symbol is repeated,
 916  * the compiler will complain.
 917  */
 918
 919 /* Reset all macros within TRACEPOINT_EVENT */
 920 #include <lttng/ust-tracepoint-event-reset.h>
 921
 922 /*
 923  * Declare _loglevel___##__provider##___##__name as non-static, with
 924  * hidden visibility for c++ handling of weakref. We do a weakref to the
 925  * symbol in a later stage, which requires that the symbol is not
 926  * mangled.
 927  */
 928 #ifdef __cplusplus
 929 #define LTTNG_TP_EXTERN_C extern "C"
 930 #else
 931 #define LTTNG_TP_EXTERN_C
 932 #endif
 933
 934 #undef TRACEPOINT_LOGLEVEL
 935 #define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel)                \
 936 static const int _loglevel_value___##__provider##___##__name = __loglevel; \
 937 LTTNG_TP_EXTERN_C const int *_loglevel___##__provider##___##__name         \
 938                 __attribute__((visibility("hidden"))) =                    \
 939                 &_loglevel_value___##__provider##___##__name;
 940
 941 #include TRACEPOINT_INCLUDE
 942
 943 #undef LTTNG_TP_EXTERN_C
 944
 945 /*
 946  * Stage 6.1 of tracepoint event generation.
 947  *
 948  * Tracepoint UML URI info.
 949  */
 950
 951 /* Reset all macros within TRACEPOINT_EVENT */
 952 #include <lttng/ust-tracepoint-event-reset.h>
 953
 954 /*
 955  * Declare _model_emf_uri___##__provider##___##__name as non-static,
 956  * with hidden visibility for c++ handling of weakref. We do a weakref
 957  * to the symbol in a later stage, which requires that the symbol is not
 958  * mangled.
 959  */
 960 #ifdef __cplusplus
 961 #define LTTNG_TP_EXTERN_C extern "C"
 962 #else
 963 #define LTTNG_TP_EXTERN_C
 964 #endif
 965
 966 #undef TRACEPOINT_MODEL_EMF_URI
 967 #define TRACEPOINT_MODEL_EMF_URI(__provider, __name, __uri)                \
 968 LTTNG_TP_EXTERN_C const char *_model_emf_uri___##__provider##___##__name   \
 969                 __attribute__((visibility("hidden"))) = __uri;             \
 970
 971 #include TRACEPOINT_INCLUDE
 972
 973 #undef LTTNG_TP_EXTERN_C
 974
 975 /*
 976  * Stage 7.1 of tracepoint event generation.
 977  *
 978  * Create events description structures. We use a weakref because
 979  * loglevels are optional. If not declared, the event will point to the
 980  * a loglevel that contains NULL.
 981  */
 982
 983 /* Reset all macros within TRACEPOINT_EVENT */
 984 #include <lttng/ust-tracepoint-event-reset.h>
 985
 986 #undef _TRACEPOINT_EVENT_INSTANCE
 987 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)         \
 988 static const int *                                                             \
 989         __ref_loglevel___##_provider##___##_name                               \
 990         __attribute__((weakref ("_loglevel___" #_provider "___" #_name)));     \
 991 static const char *                                                            \
 992         __ref_model_emf_uri___##_provider##___##_name                          \
 993         __attribute__((weakref ("_model_emf_uri___" #_provider "___" #_name)));\
 994 static const struct lttng_ust_event_desc __event_desc___##_provider##_##_name = { \
 995         .struct_size = sizeof(struct lttng_ust_event_desc),                    \
 996         .name = #_provider ":" #_name,                                         \
 997         .probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template, \
 998         .ctx = NULL,                                                           \
 999         .fields = __event_fields___##_provider##___##_template,                \
1000         .nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template) - 1, \
1001         .loglevel = &__ref_loglevel___##_provider##___##_name,                 \
1002         .signature = __tp_event_signature___##_provider##___##_template,       \
1003         .model_emf_uri = &__ref_model_emf_uri___##_provider##___##_name,       \
1004 };
1005
1006 #include TRACEPOINT_INCLUDE
1007
1008 /*
1009  * Stage 7.2 of tracepoint event generation.
1010  *
1011  * Create array of events.
1012  */
1013
1014 /* Reset all macros within TRACEPOINT_EVENT */
1015 #include <lttng/ust-tracepoint-event-reset.h>
1016
1017 #undef _TRACEPOINT_EVENT_INSTANCE
1018 #define _TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)         \
1019         &__event_desc___##_provider##_##_name,
1020
1021 static const struct lttng_ust_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)[] = {
1022 #include TRACEPOINT_INCLUDE
1023         NULL,   /* Dummy, C99 forbids 0-len array. */
1024 };
1025
1026
1027 /*
1028  * Stage 8 of tracepoint event generation.
1029  *
1030  * Create a toplevel descriptor for the whole probe.
1031  */
1032
1033 /* non-const because list head will be modified when registered. */
1034 static struct lttng_ust_probe_desc _TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER) = {
1035         .struct_size = sizeof(struct lttng_ust_probe_desc),
1036         .provider = __tp_stringify(TRACEPOINT_PROVIDER),
1037         .event_desc = _TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER),
1038         .nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)) - 1,
1039         .head = { NULL, NULL },
1040         .lazy_init_head = { NULL, NULL },
1041         .lazy = 0,
1042         .major = LTTNG_UST_PROVIDER_MAJOR,
1043         .minor = LTTNG_UST_PROVIDER_MINOR,
1044 };
1045
1046 static int _TP_COMBINE_TOKENS(__probe_register_refcount___, TRACEPOINT_PROVIDER);
1047
1048 /*
1049  * Stage 9 of tracepoint event generation.
1050  *
1051  * Register/unregister probes at module load/unload.
1052  *
1053  * Generate the constructor as an externally visible symbol for use when
1054  * linking the probe statically.
1055  *
1056  * Register refcount is protected by libc dynamic loader mutex.
1057  */
1058
1059 /* Reset all macros within TRACEPOINT_EVENT */
1060 #include <lttng/ust-tracepoint-event-reset.h>
1061 static void lttng_ust_notrace __attribute__((constructor))
1062 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void);
1063 static void
1064 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
1065 {
1066         int ret;
1067
1068         if (_TP_COMBINE_TOKENS(__probe_register_refcount___,
1069                         TRACEPOINT_PROVIDER)++) {
1070                 return;
1071         }
1072         /*
1073          * __tracepoint_provider_check_ ## TRACEPOINT_PROVIDER() is a
1074          * static inline function that ensures every probe PROVIDER
1075          * argument match the provider within which they appear. It
1076          * calls empty static inline functions, and therefore has no
1077          * runtime effect. However, if it detects an error, a linker
1078          * error will appear.
1079          */
1080         _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)();
1081         ret = lttng_ust_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
1082         if (ret) {
1083                 fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe.\n", ret);
1084                 abort();
1085         }
1086 }
1087
1088 static void lttng_ust_notrace __attribute__((destructor))
1089 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void);
1090 static void
1091 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
1092 {
1093         if (--_TP_COMBINE_TOKENS(__probe_register_refcount___,
1094                         TRACEPOINT_PROVIDER)) {
1095                 return;
1096         }
1097         lttng_ust_probe_unregister(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
1098 }
1099
1100 int _TP_COMBINE_TOKENS(__tracepoint_provider_, TRACEPOINT_PROVIDER)
1101 __attribute__((visibility("default")));