include/lttng/ust-tracepoint-event.h

   1 /*
   2  * Copyright (c) 2011-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <urcu/compiler.h>
  26 #include <urcu/rculist.h>
  27 #include <lttng/ust-events.h>
  28 #include <lttng/ringbuffer-config.h>
  29 #include <lttng/ust-compiler.h>
  30 #include <lttng/tracepoint.h>
  31 #include <string.h>
  32
  33 #undef tp_list_for_each_entry_rcu
  34 #define tp_list_for_each_entry_rcu(pos, head, member)   \
  35         for (pos = cds_list_entry(tp_rcu_dereference_bp((head)->next), __typeof__(*pos), member);       \
  36              &pos->member != (head);                                    \
  37              pos = cds_list_entry(tp_rcu_dereference_bp(pos->member.next), __typeof__(*pos), member))
  38
  39 /*
  40  * TRACEPOINT_EVENT_CLASS declares a class of tracepoints receiving the
  41  * same arguments and having the same field layout.
  42  *
  43  * TRACEPOINT_EVENT_INSTANCE declares an instance of a tracepoint, with
  44  * its own provider and name. It refers to a class (template).
  45  *
  46  * TRACEPOINT_EVENT declared both a class and an instance and does a
  47  * direct mapping from the instance to the class.
  48  */
  49
  50 #undef TRACEPOINT_EVENT
  51 #define TRACEPOINT_EVENT(_provider, _name, _args, _fields)      \
  52         TRACEPOINT_EVENT_CLASS(_provider, _name,                \
  53                          _TP_PARAMS(_args),                     \
  54                          _TP_PARAMS(_fields))                   \
  55         TRACEPOINT_EVENT_INSTANCE(_provider, _name, _name,      \
  56                          _TP_PARAMS(_args))
  57
  58 /* Helpers */
  59 #define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
  60
  61 #define _tp_max_t(type, x, y)                           \
  62         ({                                              \
  63                 type __max1 = (x);                      \
  64                 type __max2 = (y);                      \
  65                 __max1 > __max2 ? __max1: __max2;       \
  66         })
  67
  68 /*
  69  * Stage 0 of tracepoint event generation.
  70  *
  71  * Check that each TRACEPOINT_EVENT provider argument match the
  72  * TRACEPOINT_PROVIDER by creating dummy callbacks.
  73  */
  74
  75 /* Reset all macros within TRACEPOINT_EVENT */
  76 #include <lttng/ust-tracepoint-event-reset.h>
  77
  78 static inline
  79 void _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
  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_SYM_NAME_LEN] \
 111         __attribute__((unused)) =                                       \
 112                 #_provider ":" #_name;
 113
 114 #include TRACEPOINT_INCLUDE
 115
 116 /*
 117  * Stage 1 of tracepoint event generation.
 118  *
 119  * Create event field type metadata section.
 120  * Each event produce an array of fields.
 121  */
 122
 123 /* Reset all macros within TRACEPOINT_EVENT */
 124 #include <lttng/ust-tracepoint-event-reset.h>
 125 #include <lttng/ust-tracepoint-event-write.h>
 126 #include <lttng/ust-tracepoint-event-nowrite.h>
 127
 128 #undef _ctf_integer_ext
 129 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)      \
 130         {                                                       \
 131           .name = #_item,                                       \
 132           .type = __type_integer(_type, _byte_order, _base, none),\
 133           .nowrite = _nowrite,                                  \
 134         },
 135
 136 #undef _ctf_float
 137 #define _ctf_float(_type, _item, _src, _nowrite)                \
 138         {                                                       \
 139           .name = #_item,                                       \
 140           .type = __type_float(_type),                          \
 141           .nowrite = _nowrite,                                  \
 142         },
 143
 144 #undef _ctf_array_encoded
 145 #define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \
 146         {                                                       \
 147           .name = #_item,                                       \
 148           .type =                                               \
 149                 {                                               \
 150                   .atype = atype_array,                         \
 151                   .u =                                          \
 152                         {                                       \
 153                           .array =                              \
 154                                 {                               \
 155                                   .elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
 156                                   .length = _length,            \
 157                                 }                               \
 158                         }                                       \
 159                 },                                              \
 160           .nowrite = _nowrite,                                  \
 161         },
 162
 163 #undef _ctf_sequence_encoded
 164 #define _ctf_sequence_encoded(_type, _item, _src,       \
 165                         _length_type, _src_length, _encoding, _nowrite) \
 166         {                                                       \
 167           .name = #_item,                                       \
 168           .type =                                               \
 169                 {                                               \
 170                   .atype = atype_sequence,                      \
 171                   .u =                                          \
 172                         {                                       \
 173                           .sequence =                           \
 174                                 {                               \
 175                                   .length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
 176                                   .elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
 177                                 },                              \
 178                         },                                      \
 179                 },                                              \
 180           .nowrite = _nowrite,                                  \
 181         },
 182
 183 #undef _ctf_string
 184 #define _ctf_string(_item, _src, _nowrite)                      \
 185         {                                                       \
 186           .name = #_item,                                       \
 187           .type =                                               \
 188                 {                                               \
 189                   .atype = atype_string,                        \
 190                   .u =                                          \
 191                         {                                       \
 192                           .basic = { .string = { .encoding = lttng_encode_UTF8 } } \
 193                         },                                      \
 194                 },                                              \
 195           .nowrite = _nowrite,                                  \
 196         },
 197
 198 #undef TP_FIELDS
 199 #define TP_FIELDS(...) __VA_ARGS__      /* Only one used in this phase */
 200
 201 #undef TRACEPOINT_EVENT_CLASS
 202 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)                             \
 203         static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
 204                 _fields                                                                      \
 205         };
 206
 207 #include TRACEPOINT_INCLUDE
 208
 209 /*
 210  * Stage 2 of tracepoint event generation.
 211  *
 212  * Create probe callback prototypes.
 213  */
 214
 215 /* Reset all macros within TRACEPOINT_EVENT */
 216 #include <lttng/ust-tracepoint-event-reset.h>
 217
 218 #undef TP_ARGS
 219 #define TP_ARGS(...) __VA_ARGS__
 220
 221 #undef TRACEPOINT_EVENT_CLASS
 222 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)                \
 223 static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));
 224
 225 #include TRACEPOINT_INCLUDE
 226
 227 /*
 228  * Stage 3 of tracepoint event generation.
 229  *
 230  * Create static inline function that calculates event size.
 231  */
 232
 233 /* Reset all macros within TRACEPOINT_EVENT */
 234 #include <lttng/ust-tracepoint-event-reset.h>
 235 #include <lttng/ust-tracepoint-event-write.h>
 236
 237 #undef _ctf_integer_ext
 238 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)       \
 239         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 240         __event_len += sizeof(_type);
 241
 242 #undef _ctf_float
 243 #define _ctf_float(_type, _item, _src, _nowrite)                                 \
 244         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 245         __event_len += sizeof(_type);
 246
 247 #undef _ctf_array_encoded
 248 #define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite)     \
 249         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 250         __event_len += sizeof(_type) * (_length);
 251
 252 #undef _ctf_sequence_encoded
 253 #define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
 254                         _src_length, _encoding, _nowrite)       \
 255         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type));   \
 256         __event_len += sizeof(_length_type);                                   \
 257         __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 258         __dynamic_len[__dynamic_len_idx] = (_src_length);                      \
 259         __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
 260         __dynamic_len_idx++;
 261
 262 #undef _ctf_string
 263 #define _ctf_string(_item, _src, _nowrite)                                     \
 264         __event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
 265
 266 #undef TP_ARGS
 267 #define TP_ARGS(...) __VA_ARGS__
 268
 269 #undef TP_FIELDS
 270 #define TP_FIELDS(...) __VA_ARGS__
 271
 272 #undef TRACEPOINT_EVENT_CLASS
 273 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)              \
 274 static inline lttng_ust_notrace                                               \
 275 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)); \
 276 static inline                                                                 \
 277 size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)) \
 278 {                                                                             \
 279         size_t __event_len = 0;                                               \
 280         unsigned int __dynamic_len_idx = 0;                                   \
 281                                                                               \
 282         if (0)                                                                \
 283                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 284         _fields                                                               \
 285         return __event_len;                                                   \
 286 }
 287
 288 #include TRACEPOINT_INCLUDE
 289
 290 /*
 291  * Stage 3.1 of tracepoint event generation.
 292  *
 293  * Create static inline function that layout the filter stack data.
 294  * We make both write and nowrite data available to the filter.
 295  */
 296
 297 /* Reset all macros within TRACEPOINT_EVENT */
 298 #include <lttng/ust-tracepoint-event-reset.h>
 299 #include <lttng/ust-tracepoint-event-write.h>
 300 #include <lttng/ust-tracepoint-event-nowrite.h>
 301
 302 #undef _ctf_integer_ext
 303 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)     \
 304         if (lttng_is_signed_type(_type)) {                                     \
 305                 int64_t __ctf_tmp_int64;                                       \
 306                 switch (sizeof(_type)) {                                       \
 307                 case 1:                                                        \
 308                 {                                                              \
 309                         union { _type t; int8_t v; } __tmp = { (_type) (_src) }; \
 310                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 311                         break;                                                 \
 312                 }                                                              \
 313                 case 2:                                                        \
 314                 {                                                              \
 315                         union { _type t; int16_t v; } __tmp = { (_type) (_src) }; \
 316                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 317                         break;                                                 \
 318                 }                                                              \
 319                 case 4:                                                        \
 320                 {                                                              \
 321                         union { _type t; int32_t v; } __tmp = { (_type) (_src) }; \
 322                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 323                         break;                                                 \
 324                 }                                                              \
 325                 case 8:                                                        \
 326                 {                                                              \
 327                         union { _type t; int64_t v; } __tmp = { (_type) (_src) }; \
 328                         __ctf_tmp_int64 = (int64_t) __tmp.v;                   \
 329                         break;                                                 \
 330                 }                                                              \
 331                 default:                                                       \
 332                         abort();                                               \
 333                 };                                                             \
 334                 memcpy(__stack_data, &__ctf_tmp_int64, sizeof(int64_t));       \
 335         } else {                                                               \
 336                 uint64_t __ctf_tmp_uint64;                                     \
 337                 switch (sizeof(_type)) {                                       \
 338                 case 1:                                                        \
 339                 {                                                              \
 340                         union { _type t; uint8_t v; } __tmp = { (_type) (_src) }; \
 341                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 342                         break;                                                 \
 343                 }                                                              \
 344                 case 2:                                                        \
 345                 {                                                              \
 346                         union { _type t; uint16_t v; } __tmp = { (_type) (_src) }; \
 347                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 348                         break;                                                 \
 349                 }                                                              \
 350                 case 4:                                                        \
 351                 {                                                              \
 352                         union { _type t; uint32_t v; } __tmp = { (_type) (_src) }; \
 353                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 354                         break;                                                 \
 355                 }                                                              \
 356                 case 8:                                                        \
 357                 {                                                              \
 358                         union { _type t; uint64_t v; } __tmp = { (_type) (_src) }; \
 359                         __ctf_tmp_uint64 = (uint64_t) __tmp.v;                 \
 360                         break;                                                 \
 361                 }                                                              \
 362                 default:                                                       \
 363                         abort();                                               \
 364                 };                                                             \
 365                 memcpy(__stack_data, &__ctf_tmp_uint64, sizeof(uint64_t));     \
 366         }                                                                      \
 367         __stack_data += sizeof(int64_t);
 368
 369 #undef _ctf_float
 370 #define _ctf_float(_type, _item, _src, _nowrite)                               \
 371         {                                                                      \
 372                 double __ctf_tmp_double = (double) (_type) (_src);             \
 373                 memcpy(__stack_data, &__ctf_tmp_double, sizeof(double));       \
 374                 __stack_data += sizeof(double);                                \
 375         }
 376
 377 #undef _ctf_array_encoded
 378 #define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite)   \
 379         {                                                                      \
 380                 unsigned long __ctf_tmp_ulong = (unsigned long) (_length);     \
 381                 const void *__ctf_tmp_ptr = (_src);                            \
 382                 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
 383                 __stack_data += sizeof(unsigned long);                         \
 384                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void **));         \
 385                 __stack_data += sizeof(void **);                               \
 386         }
 387
 388 #undef _ctf_sequence_encoded
 389 #define _ctf_sequence_encoded(_type, _item, _src, _length_type,                \
 390                         _src_length, _encoding, _nowrite)                      \
 391         {                                                                      \
 392                 unsigned long __ctf_tmp_ulong = (unsigned long) (_src_length); \
 393                 const void *__ctf_tmp_ptr = (_src);                            \
 394                 memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \
 395                 __stack_data += sizeof(unsigned long);                         \
 396                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void **));         \
 397                 __stack_data += sizeof(void **);                               \
 398         }
 399
 400 #undef _ctf_string
 401 #define _ctf_string(_item, _src, _nowrite)                                     \
 402         {                                                                      \
 403                 const void *__ctf_tmp_ptr = (_src);                            \
 404                 memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void **));         \
 405                 __stack_data += sizeof(void **);                               \
 406         }
 407
 408 #undef TP_ARGS
 409 #define TP_ARGS(...) __VA_ARGS__
 410
 411 #undef TP_FIELDS
 412 #define TP_FIELDS(...) __VA_ARGS__
 413
 414 #undef TRACEPOINT_EVENT_CLASS
 415 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)              \
 416 static inline                                                                 \
 417 void __event_prepare_filter_stack__##_provider##___##_name(char *__stack_data,\
 418                                                  _TP_ARGS_DATA_PROTO(_args))  \
 419 {                                                                             \
 420         _fields                                                               \
 421 }
 422
 423 #include TRACEPOINT_INCLUDE
 424
 425
 426
 427 /*
 428  * Stage 4 of tracepoint event generation.
 429  *
 430  * Create static inline function that calculates event payload alignment.
 431  */
 432
 433 /* Reset all macros within TRACEPOINT_EVENT */
 434 #include <lttng/ust-tracepoint-event-reset.h>
 435 #include <lttng/ust-tracepoint-event-write.h>
 436
 437 #undef _ctf_integer_ext
 438 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite)     \
 439         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 440
 441 #undef _ctf_float
 442 #define _ctf_float(_type, _item, _src, _nowrite)                               \
 443         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 444
 445 #undef _ctf_array_encoded
 446 #define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite)   \
 447         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 448
 449 #undef _ctf_sequence_encoded
 450 #define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
 451                         _src_length, _encoding, _nowrite)       \
 452         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type));    \
 453         __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
 454
 455 #undef _ctf_string
 456 #define _ctf_string(_item, _src, _nowrite)
 457
 458 #undef TP_ARGS
 459 #define TP_ARGS(...) __VA_ARGS__
 460
 461 #undef TP_FIELDS
 462 #define TP_FIELDS(...) __VA_ARGS__
 463
 464 #undef TRACEPOINT_EVENT_CLASS
 465 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)              \
 466 static inline lttng_ust_notrace                                               \
 467 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args));     \
 468 static inline                                                                 \
 469 size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args))      \
 470 {                                                                             \
 471         size_t __event_align = 1;                                             \
 472         _fields                                                               \
 473         return __event_align;                                                 \
 474 }
 475
 476 #include TRACEPOINT_INCLUDE
 477
 478
 479 /*
 480  * Stage 5 of tracepoint event generation.
 481  *
 482  * Create the probe function. This function calls event size calculation
 483  * and writes event data into the buffer.
 484  */
 485
 486 /* Reset all macros within TRACEPOINT_EVENT */
 487 #include <lttng/ust-tracepoint-event-reset.h>
 488 #include <lttng/ust-tracepoint-event-write.h>
 489
 490 #undef _ctf_integer_ext
 491 #define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _nowrite) \
 492         {                                                               \
 493                 _type __tmp = (_src);                                   \
 494                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
 495                 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
 496         }
 497
 498 #undef _ctf_float
 499 #define _ctf_float(_type, _item, _src, _nowrite)                        \
 500         {                                                               \
 501                 _type __tmp = (_src);                                   \
 502                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
 503                 __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
 504         }
 505
 506 #undef _ctf_array_encoded
 507 #define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \
 508         lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));        \
 509         __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
 510
 511 #undef _ctf_sequence_encoded
 512 #define _ctf_sequence_encoded(_type, _item, _src, _length_type,         \
 513                         _src_length, _encoding, _nowrite)               \
 514         {                                                               \
 515                 _length_type __tmpl = __stackvar.__dynamic_len[__dynamic_len_idx]; \
 516                 lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
 517                 __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
 518         }                                                               \
 519         lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));        \
 520         __chan->ops->event_write(&__ctx, _src,                          \
 521                 sizeof(_type) * __get_dynamic_len(dest));
 522
 523 /*
 524  * __chan->ops->u.has_strcpy is a flag letting us know if the LTTng-UST
 525  * tracepoint provider ABI implements event_strcpy. This dynamic check
 526  * can be removed when the tracepoint provider ABI moves to 2.
 527  */
 528 #if (LTTNG_UST_PROVIDER_MAJOR > 1)
 529 #error "Tracepoint probe provider major version has changed. Please remove dynamic check for has_strcpy."
 530 #endif
 531
 532 #undef _ctf_string
 533 #define _ctf_string(_item, _src, _nowrite)                              \
 534         lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src)));      \
 535         if (__chan->ops->u.has_strcpy)                                  \
 536                 __chan->ops->event_strcpy(&__ctx, _src,                 \
 537                         __get_dynamic_len(dest));                       \
 538         else                                                            \
 539                 __chan->ops->event_write(&__ctx, _src,                  \
 540                         __get_dynamic_len(dest));
 541
 542 /* Beware: this get len actually consumes the len value */
 543 #undef __get_dynamic_len
 544 #define __get_dynamic_len(field)        __stackvar.__dynamic_len[__dynamic_len_idx++]
 545
 546 #undef TP_ARGS
 547 #define TP_ARGS(...) __VA_ARGS__
 548
 549 #undef TP_FIELDS
 550 #define TP_FIELDS(...) __VA_ARGS__
 551
 552 /*
 553  * For state dump, check that "session" argument (mandatory) matches the
 554  * session this event belongs to. Ensures that we write state dump data only
 555  * into the started session, not into all sessions.
 556  */
 557 #undef _TP_SESSION_CHECK
 558 #ifdef TP_SESSION_CHECK
 559 #define _TP_SESSION_CHECK(session, csession)   (session == csession)
 560 #else /* TP_SESSION_CHECK */
 561 #define _TP_SESSION_CHECK(session, csession)   1
 562 #endif /* TP_SESSION_CHECK */
 563
 564 /*
 565  * Using twice size for filter stack data to hold size and pointer for
 566  * each field (worse case). For integers, max size required is 64-bit.
 567  * Same for double-precision floats. Those fit within
 568  * 2*sizeof(unsigned long) for all supported architectures.
 569  * Perform UNION (||) of filter runtime list.
 570  */
 571 #undef TRACEPOINT_EVENT_CLASS
 572 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)              \
 573 static lttng_ust_notrace                                                      \
 574 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));      \
 575 static                                                                        \
 576 void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args))       \
 577 {                                                                             \
 578         struct lttng_event *__event = (struct lttng_event *) __tp_data;                       \
 579         struct lttng_channel *__chan = __event->chan;                         \
 580         struct lttng_ust_lib_ring_buffer_ctx __ctx;                           \
 581         size_t __event_len, __event_align;                                    \
 582         size_t __dynamic_len_idx = 0;                                         \
 583         union {                                                               \
 584                 size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
 585                 char __filter_stack_data[2 * sizeof(unsigned long) * _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
 586         } __stackvar;                                                         \
 587         int __ret;                                                            \
 588                                                                               \
 589         if (0)                                                                \
 590                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 591         if (!_TP_SESSION_CHECK(session, __chan->session))                     \
 592                 return;                                                       \
 593         if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active)))          \
 594                 return;                                                       \
 595         if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled)))                  \
 596                 return;                                                       \
 597         if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled)))                 \
 598                 return;                                                       \
 599         if (caa_unlikely(!TP_RCU_LINK_TEST()))                                \
 600                 return;                                                       \
 601         if (caa_unlikely(!cds_list_empty(&__event->bytecode_runtime_head))) { \
 602                 struct lttng_bytecode_runtime *bc_runtime;                    \
 603                 int __filter_record = __event->has_enablers_without_bytecode; \
 604                                                                               \
 605                 __event_prepare_filter_stack__##_provider##___##_name(__stackvar.__filter_stack_data, \
 606                         _TP_ARGS_DATA_VAR(_args));                            \
 607                 tp_list_for_each_entry_rcu(bc_runtime, &__event->bytecode_runtime_head, node) { \
 608                         if (caa_unlikely(bc_runtime->filter(bc_runtime,       \
 609                                         __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) \
 610                                 __filter_record = 1;                          \
 611                 }                                                             \
 612                 if (caa_likely(!__filter_record))                             \
 613                         return;                                               \
 614         }                                                                     \
 615         __event_len = __event_get_size__##_provider##___##_name(__stackvar.__dynamic_len, \
 616                  _TP_ARGS_DATA_VAR(_args));                                   \
 617         __event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_args)); \
 618         lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len,  \
 619                                  __event_align, -1, __chan->handle);          \
 620         __ctx.ip = __builtin_return_address(0);                               \
 621         __ret = __chan->ops->event_reserve(&__ctx, __event->id);              \
 622         if (__ret < 0)                                                        \
 623                 return;                                                       \
 624         _fields                                                               \
 625         __chan->ops->event_commit(&__ctx);                                    \
 626 }
 627
 628 #include TRACEPOINT_INCLUDE
 629
 630 #undef __get_dynamic_len
 631
 632 /*
 633  * Stage 5.1 of tracepoint event generation.
 634  *
 635  * Create probe signature
 636  */
 637
 638 /* Reset all macros within TRACEPOINT_EVENT */
 639 #include <lttng/ust-tracepoint-event-reset.h>
 640
 641 #undef TP_ARGS
 642 #define TP_ARGS(...) __VA_ARGS__
 643
 644 #define _TP_EXTRACT_STRING2(...)        #__VA_ARGS__
 645
 646 #undef TRACEPOINT_EVENT_CLASS
 647 #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)        \
 648 const char __tp_event_signature___##_provider##___##_name[] =           \
 649                 _TP_EXTRACT_STRING2(_args);
 650
 651 #include TRACEPOINT_INCLUDE
 652
 653 #undef _TP_EXTRACT_STRING2
 654
 655 /*
 656  * Stage 6 of tracepoint event generation.
 657  *
 658  * Tracepoint loglevel mapping definition generation. We generate a
 659  * symbol for each mapping for a provider/event to ensure at most a 1 to
 660  * 1 mapping between events and loglevels. If the symbol is repeated,
 661  * the compiler will complain.
 662  */
 663
 664 /* Reset all macros within TRACEPOINT_EVENT */
 665 #include <lttng/ust-tracepoint-event-reset.h>
 666
 667 #undef TRACEPOINT_LOGLEVEL
 668 #define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel)                \
 669 static const int _loglevel_value___##__provider##___##__name = __loglevel; \
 670 static const int *_loglevel___##__provider##___##__name =                  \
 671                 &_loglevel_value___##__provider##___##__name;
 672
 673 #include TRACEPOINT_INCLUDE
 674
 675 /*
 676  * Stage 6.1 of tracepoint event generation.
 677  *
 678  * Tracepoint UML URI info.
 679  */
 680
 681 /* Reset all macros within TRACEPOINT_EVENT */
 682 #include <lttng/ust-tracepoint-event-reset.h>
 683
 684 #undef TRACEPOINT_MODEL_EMF_URI
 685 #define TRACEPOINT_MODEL_EMF_URI(__provider, __name, __uri)                \
 686 static const char *_model_emf_uri___##__provider##___##__name = __uri;
 687
 688 #include TRACEPOINT_INCLUDE
 689
 690 /*
 691  * Stage 7.1 of tracepoint event generation.
 692  *
 693  * Create events description structures. We use a weakref because
 694  * loglevels are optional. If not declared, the event will point to the
 695  * a loglevel that contains NULL.
 696  */
 697
 698 /* Reset all macros within TRACEPOINT_EVENT */
 699 #include <lttng/ust-tracepoint-event-reset.h>
 700
 701 #undef TRACEPOINT_EVENT_INSTANCE
 702 #define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)          \
 703 static const int *                                                             \
 704         __ref_loglevel___##_provider##___##_name                               \
 705         __attribute__((weakref ("_loglevel___" #_provider "___" #_name)));     \
 706 static const char *                                                            \
 707         __ref_model_emf_uri___##_provider##___##_name                          \
 708         __attribute__((weakref ("_model_emf_uri___" #_provider "___" #_name)));\
 709 const struct lttng_event_desc __event_desc___##_provider##_##_name = {         \
 710         .name = #_provider ":" #_name,                                         \
 711         .probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template,\
 712         .ctx = NULL,                                                           \
 713         .fields = __event_fields___##_provider##___##_template,                \
 714         .nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
 715         .loglevel = &__ref_loglevel___##_provider##___##_name,                 \
 716         .signature = __tp_event_signature___##_provider##___##_template,       \
 717         .u = { .ext = { .model_emf_uri = &__ref_model_emf_uri___##_provider##___##_name } }, \
 718 };
 719
 720 #include TRACEPOINT_INCLUDE
 721
 722 /*
 723  * Stage 7.2 of tracepoint event generation.
 724  *
 725  * Create array of events.
 726  */
 727
 728 /* Reset all macros within TRACEPOINT_EVENT */
 729 #include <lttng/ust-tracepoint-event-reset.h>
 730
 731 #undef TRACEPOINT_EVENT_INSTANCE
 732 #define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)          \
 733         &__event_desc___##_provider##_##_name,
 734
 735 static const struct lttng_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)[] = {
 736 #include TRACEPOINT_INCLUDE
 737 };
 738
 739
 740 /*
 741  * Stage 8 of tracepoint event generation.
 742  *
 743  * Create a toplevel descriptor for the whole probe.
 744  */
 745
 746 /* non-const because list head will be modified when registered. */
 747 static struct lttng_probe_desc _TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER) = {
 748         .provider = __tp_stringify(TRACEPOINT_PROVIDER),
 749         .event_desc = _TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER),
 750         .nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)),
 751         .head = { NULL, NULL },
 752         .lazy_init_head = { NULL, NULL },
 753         .lazy = 0,
 754         .major = LTTNG_UST_PROVIDER_MAJOR,
 755         .minor = LTTNG_UST_PROVIDER_MINOR,
 756 };
 757
 758 static int _TP_COMBINE_TOKENS(__probe_register_refcount___, TRACEPOINT_PROVIDER);
 759
 760 /*
 761  * Stage 9 of tracepoint event generation.
 762  *
 763  * Register/unregister probes at module load/unload.
 764  *
 765  * Generate the constructor as an externally visible symbol for use when
 766  * linking the probe statically.
 767  *
 768  * Register refcount is protected by libc dynamic loader mutex.
 769  */
 770
 771 /* Reset all macros within TRACEPOINT_EVENT */
 772 #include <lttng/ust-tracepoint-event-reset.h>
 773 static void lttng_ust_notrace __attribute__((constructor))
 774 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void);
 775 static void
 776 _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
 777 {
 778         int ret;
 779
 780         if (_TP_COMBINE_TOKENS(__probe_register_refcount___,
 781                         TRACEPOINT_PROVIDER)++) {
 782                 return;
 783         }
 784         /*
 785          * __tracepoint_provider_check_ ## TRACEPOINT_PROVIDER() is a
 786          * static inline function that ensures every probe PROVIDER
 787          * argument match the provider within which they appear. It
 788          * calls empty static inline functions, and therefore has no
 789          * runtime effect. However, if it detects an error, a linker
 790          * error will appear.
 791          */
 792         _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)();
 793         ret = lttng_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
 794         if (ret) {
 795                 fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe. Duplicate registration of tracepoint probes having the same name is not allowed.\n", ret);
 796                 abort();
 797         }
 798 }
 799
 800 static void lttng_ust_notrace __attribute__((destructor))
 801 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void);
 802 static void
 803 _TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
 804 {
 805         if (--_TP_COMBINE_TOKENS(__probe_register_refcount___,
 806                         TRACEPOINT_PROVIDER)) {
 807                 return;
 808         }
 809         lttng_probe_unregister(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
 810 }
 811
 812 int _TP_COMBINE_TOKENS(__tracepoint_provider_, TRACEPOINT_PROVIDER);