probes/lttng-events.h

   1 #include <linux/debugfs.h>
   2 #include "lttng.h"
   3 #include "lttng-types.h"
   4 #include "../wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
   5 #include "../wrapper/ringbuffer/frontend_types.h"
   6 #include "../ltt-events.h"
   7 #include "../ltt-tracer-core.h"
   8
   9 /*
  10  * Macro declarations used for all stages.
  11  */
  12
  13 /*
  14  * DECLARE_EVENT_CLASS can be used to add a generic function
  15  * handlers for events. That is, if all events have the same
  16  * parameters and just have distinct trace points.
  17  * Each tracepoint can be defined with DEFINE_EVENT and that
  18  * will map the DECLARE_EVENT_CLASS to the tracepoint.
  19  *
  20  * TRACE_EVENT is a one to one mapping between tracepoint and template.
  21  */
  22
  23 #undef TRACE_EVENT
  24 #define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
  25         DECLARE_EVENT_CLASS(name,                              \
  26                              PARAMS(proto),                    \
  27                              PARAMS(args),                     \
  28                              PARAMS(tstruct),                  \
  29                              PARAMS(assign),                   \
  30                              PARAMS(print))                    \
  31         DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args))
  32
  33 #undef DEFINE_EVENT_PRINT
  34 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
  35         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
  36
  37 /* Callbacks are meaningless to LTTng. */
  38 #undef TRACE_EVENT_FN
  39 #define TRACE_EVENT_FN(name, proto, args, tstruct,                      \
  40                 assign, print, reg, unreg)                              \
  41         TRACE_EVENT(name, PARAMS(proto), PARAMS(args),                  \
  42                 PARAMS(tstruct), PARAMS(assign), PARAMS(print))         \
  43
  44 /*
  45  * Stage 1 of the trace events.
  46  *
  47  * Create dummy trace calls for each events, verifying that the LTTng module
  48  * TRACE_EVENT headers match the kernel arguments. Will be optimized out by the
  49  * compiler.
  50  */
  51
  52 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
  53
  54 #undef TP_PROTO
  55 #define TP_PROTO(args...) args
  56
  57 #undef TP_ARGS
  58 #define TP_ARGS(args...) args
  59
  60 #undef DEFINE_EVENT
  61 #define DEFINE_EVENT(_template, _name, _proto, _args)                   \
  62 void trace_##_name(_proto);
  63
  64 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
  65
  66 /*
  67  * Stage 2 of the trace events.
  68  *
  69  * Create event field type metadata section.
  70  * Each event produce an array of fields.
  71  */
  72
  73 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
  74
  75 /* Named field types must be defined in lttng-types.h */
  76
  77 #undef __field
  78 #define __field(_type, _item)                                   \
  79         {                                                       \
  80           .name = #_item,                                       \
  81           .type = __type_integer(_type, __BYTE_ORDER, 10, none),\
  82         },
  83
  84 #undef __field_ext
  85 #define __field_ext(_type, _item, _filter_type)         __field(_type, _item)
  86
  87 #undef __field_network
  88 #define __field_network(_type, _item)                           \
  89         {                                                       \
  90           .name = #_item,                                       \
  91           .type = __type_integer(_type, __BIG_ENDIAN, 10, none),\
  92         },
  93
  94 #undef __array_enc
  95 #define __array_enc(_type, _item, _length, _encoding)           \
  96         {                                                       \
  97           .name = #_item,                                       \
  98           .type =                                               \
  99                 {                                               \
 100                   .atype = atype_array,                         \
 101                   .u.array =                                    \
 102                         {                                       \
 103                             .length = _length,                  \
 104                             .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \
 105                         },                                      \
 106                 },                                              \
 107         },
 108
 109 #undef __array
 110 #define __array(_type, _item, _length)                          \
 111         __array_enc(_type, _item, _length, none)
 112
 113 #undef __array_text
 114 #define __array_text(_type, _item, _length)                     \
 115         __array_enc(_type, _item, _length, UTF8)
 116
 117 #undef __dynamic_array_enc
 118 #define __dynamic_array_enc(_type, _item, _length, _encoding)   \
 119         {                                                       \
 120           .name = #_item,                                       \
 121           .type =                                               \
 122                 {                                               \
 123                   .atype = atype_sequence,                      \
 124                   .u.sequence =                                 \
 125                         {                                       \
 126                             .length_type = __type_integer(u32, __BYTE_ORDER, 10, none), \
 127                             .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \
 128                         },                                      \
 129                 },                                              \
 130         },
 131
 132 #undef __dynamic_array
 133 #define __dynamic_array(_type, _item, _length)                  \
 134         __dynamic_array_enc(_type, _item, _length, none)
 135
 136 #undef __dynamic_array_text
 137 #define __dynamic_array_text(_type, _item, _length)             \
 138         __dynamic_array_enc(_type, _item, _length, UTF8)
 139
 140 #undef __string
 141 #define __string(_item, _src)                                   \
 142         {                                                       \
 143           .name = #_item,                                       \
 144           .type =                                               \
 145                 {                                               \
 146                   .atype = atype_string,                        \
 147                   .u.basic.string.encoding = lttng_encode_UTF8, \
 148                 },                                              \
 149         },
 150
 151 #undef TP_STRUCT__entry
 152 #define TP_STRUCT__entry(args...) args  /* Only one used in this phase */
 153
 154 #undef DECLARE_EVENT_CLASS
 155 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
 156         static const struct lttng_event_field __event_fields___##_name[] = { \
 157                 _tstruct                                                     \
 158         };
 159
 160 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 161
 162 #undef __type_integer
 163
 164 /*
 165  * Stage 3 of the trace events.
 166  *
 167  * Create probe callback prototypes.
 168  */
 169
 170 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 171
 172 #undef TP_PROTO
 173 #define TP_PROTO(args...) args
 174
 175 #undef DECLARE_EVENT_CLASS
 176 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
 177 static void __event_probe__##_name(void *__data, _proto);
 178
 179 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 180
 181 /*
 182  * Stage 4 of the trace events.
 183  *
 184  * Create an array of events.
 185  */
 186
 187 /* Named field types must be defined in lttng-types.h */
 188
 189 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 190
 191 #undef DEFINE_EVENT
 192 #define DEFINE_EVENT(_template, _name, _proto, _args)                          \
 193                 {                                                              \
 194                         .fields = __event_fields___##_template,                \
 195                         .name = #_name,                                        \
 196                         .probe_callback = (void *) &__event_probe__##_template,\
 197                         .nr_fields = ARRAY_SIZE(__event_fields___##_template), \
 198                         .owner = THIS_MODULE,                                  \
 199                 },
 200
 201 #define TP_ID1(_token, _system) _token##_system
 202 #define TP_ID(_token, _system)  TP_ID1(_token, _system)
 203
 204 static const struct lttng_event_desc TP_ID(__event_desc___, TRACE_SYSTEM)[] = {
 205 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 206 };
 207
 208 #undef TP_ID1
 209 #undef TP_ID
 210
 211
 212 /*
 213  * Stage 5 of the trace events.
 214  *
 215  * Create a toplevel descriptor for the whole probe.
 216  */
 217
 218 #define TP_ID1(_token, _system) _token##_system
 219 #define TP_ID(_token, _system)  TP_ID1(_token, _system)
 220
 221 /* non-const because list head will be modified when registered. */
 222 static struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = {
 223         .event_desc = TP_ID(__event_desc___, TRACE_SYSTEM),
 224         .nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)),
 225 };
 226
 227 #undef TP_ID1
 228 #undef TP_ID
 229
 230 /*
 231  * Stage 6 of the trace events.
 232  *
 233  * Create static inline function that calculates event size.
 234  */
 235
 236 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 237
 238 /* Named field types must be defined in lttng-types.h */
 239
 240 #undef __field
 241 #define __field(_type, _item)                                                  \
 242         __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
 243         __event_len += sizeof(_type);
 244
 245 #undef __field_ext
 246 #define __field_ext(_type, _item, _filter_type) __field(_type, _item)
 247
 248 #undef __array
 249 #define __array(_type, _item, _length)                                         \
 250         __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
 251         __event_len += sizeof(_type) * (_length);
 252
 253 #undef __array_text
 254 #define __array_text(_type, _item, _length)                                    \
 255         __array(_type, _item, _length)
 256
 257 #undef __dynamic_array
 258 #define __dynamic_array(_type, _item, _length)                                 \
 259         __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(u32));   \
 260         __event_len += sizeof(u32);                                            \
 261         __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
 262         __dynamic_len[__dynamic_len_idx] = (_length);                          \
 263         __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
 264         __dynamic_len_idx++;
 265
 266 #undef __dynamic_array_text
 267 #define __dynamic_array_text(_type, _item, _length)                            \
 268         __dynamic_array(_type, _item, _length)
 269
 270 #undef __string
 271 #define __string(_item, _src)                                                  \
 272         __event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
 273
 274 #undef TP_PROTO
 275 #define TP_PROTO(args...) args
 276
 277 #undef TP_STRUCT__entry
 278 #define TP_STRUCT__entry(args...) args
 279
 280 #undef DECLARE_EVENT_CLASS
 281 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
 282 static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
 283 {                                                                             \
 284         size_t __event_len = 0;                                               \
 285         unsigned int __dynamic_len_idx = 0;                                   \
 286                                                                               \
 287         if (0)                                                                \
 288                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 289         _tstruct                                                              \
 290         return __event_len;                                                   \
 291 }
 292
 293 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 294
 295 /*
 296  * Stage 7 of the trace events.
 297  *
 298  * Create static inline function that calculates event payload alignment.
 299  */
 300
 301 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 302
 303 /* Named field types must be defined in lttng-types.h */
 304
 305 #undef __field
 306 #define __field(_type, _item)                                             \
 307         __event_align = max_t(size_t, __event_align, ltt_alignof(_type));
 308
 309 #undef __field_ext
 310 #define __field_ext(_type, _item, _filter_type) __field(_type, _item)
 311
 312 #undef __array
 313 #define __array(_type, _item, _length)                                    \
 314         __event_align = max_t(size_t, __event_align, ltt_alignof(_type));
 315
 316 #undef __array_text
 317 #define __array_text(_type, _item, _length)                               \
 318         __array(_type, _item, _length)
 319
 320 #undef __dynamic_array
 321 #define __dynamic_array(_type, _item, _length)                            \
 322         __event_align = max_t(size_t, __event_align, ltt_alignof(u32));   \
 323         __event_align = max_t(size_t, __event_align, ltt_alignof(_type));
 324
 325 #undef __dynamic_array_text
 326 #define __dynamic_array_text(_type, _item, _length)                       \
 327         __dynamic_array(_type, _item, _length)
 328
 329 #undef __string
 330 #define __string(_item, _src)
 331
 332 #undef TP_PROTO
 333 #define TP_PROTO(args...) args
 334
 335 #undef TP_STRUCT__entry
 336 #define TP_STRUCT__entry(args...) args
 337
 338 #undef DECLARE_EVENT_CLASS
 339 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
 340 static inline size_t __event_get_align__##_name(_proto)                       \
 341 {                                                                             \
 342         size_t __event_align = 1;                                             \
 343         _tstruct                                                              \
 344         return __event_align;                                                 \
 345 }
 346
 347 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 348
 349
 350 /*
 351  * Stage 8 of the trace events.
 352  *
 353  * Create structure declaration that allows the "assign" macros to access the
 354  * field types.
 355  */
 356
 357 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 358
 359 /* Named field types must be defined in lttng-types.h */
 360
 361 #undef __field
 362 #define __field(_type, _item)   _type   _item;
 363
 364 #undef __field_ext
 365 #define __field_ext(_type, _item, _filter_type) __field(_type, _item)
 366
 367 #undef __array
 368 #define __array(_type, _item, _length)  _type   _item;
 369
 370 #undef __array_text
 371 #define __array_text(_type, _item, _length)                               \
 372         __array(_type, _item, _length)
 373
 374 #undef __dynamic_array
 375 #define __dynamic_array(_type, _item, _length)  _type   _item;
 376
 377 #undef __dynamic_array_text
 378 #define __dynamic_array_text(_type, _item, _length)                       \
 379         __dynamic_array(_type, _item, _length)
 380
 381 #undef __string
 382 #define __string(_item, _src)   char _item;
 383
 384 #undef TP_STRUCT__entry
 385 #define TP_STRUCT__entry(args...) args
 386
 387 #undef DECLARE_EVENT_CLASS
 388 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
 389 struct __event_typemap__##_name {                                             \
 390         _tstruct                                                              \
 391 };
 392
 393 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 394
 395
 396 /*
 397  * Stage 9 of the trace events.
 398  *
 399  * Create the probe function : call even size calculation and write event data
 400  * into the buffer.
 401  *
 402  * We use both the field and assignment macros to write the fields in the order
 403  * defined in the field declaration. The field declarations control the
 404  * execution order, jumping to the appropriate assignment block.
 405  */
 406
 407 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 408
 409 #undef __field
 410 #define __field(_type, _item)                                           \
 411         goto __assign_##_item;                                          \
 412 __end_field_##_item:
 413
 414 #undef __field_ext
 415 #define __field_ext(_type, _item, _filter_type) __field(_type, _item)
 416
 417 #undef __array
 418 #define __array(_type, _item, _length)                                  \
 419         goto __assign_##_item;                                          \
 420 __end_field_##_item:
 421
 422 #undef __array_text
 423 #define __array_text(_type, _item, _length)                             \
 424         __array(_type, _item, _length)
 425
 426 #undef __dynamic_array
 427 #define __dynamic_array(_type, _item, _length)                          \
 428         goto __assign_##_item##_1;                                      \
 429 __end_field_##_item##_1:                                                \
 430         goto __assign_##_item##_2;                                      \
 431 __end_field_##_item##_2:
 432
 433 #undef __dynamic_array_text
 434 #define __dynamic_array_text(_type, _item, _length)                     \
 435         __dynamic_array(_type, _item, _length)
 436
 437 #undef __string
 438 #define __string(_item, _src)                                           \
 439         goto __assign_##_item;                                          \
 440 __end_field_##_item:
 441
 442 /*
 443  * Macros mapping tp_assign() to "=", tp_memcpy() to memcpy() and tp_strcpy() to
 444  * strcpy().
 445  */
 446 #undef tp_assign
 447 #define tp_assign(dest, src)                                            \
 448 __assign_##dest:                                                        \
 449         {                                                               \
 450                 __typeof__(__typemap.dest) __tmp = (src);               \
 451                 lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__tmp));    \
 452                 __chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp));  \
 453         }                                                               \
 454         goto __end_field_##dest;
 455
 456 #undef tp_memcpy
 457 #define tp_memcpy(dest, src, len)                                       \
 458 __assign_##dest:                                                        \
 459         if (0)                                                          \
 460                 (void) __typemap.dest;                                  \
 461         lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest));   \
 462         __chan->ops->event_write(&ctx, src, len);                       \
 463         goto __end_field_##dest;
 464
 465 #undef tp_memcpy_dyn
 466 #define tp_memcpy_dyn(dest, src)                                        \
 467 __assign_##dest##_1:                                                    \
 468         {                                                               \
 469                 u32 __tmpl = __dynamic_len[__dynamic_len_idx];          \
 470                 lib_ring_buffer_align_ctx(&ctx, ltt_alignof(u32));      \
 471                 __chan->ops->event_write(&ctx, &__tmpl, sizeof(u32));   \
 472         }                                                               \
 473         goto __end_field_##dest##_1;                                    \
 474 __assign_##dest##_2:                                                    \
 475         lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest));   \
 476         __chan->ops->event_write(&ctx, src,                             \
 477                 sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\
 478         goto __end_field_##dest##_2;
 479
 480 #undef tp_strcpy
 481 #define tp_strcpy(dest, src)                                            \
 482         tp_memcpy(dest, src, __get_dynamic_array_len(dest))
 483
 484 /* Named field types must be defined in lttng-types.h */
 485
 486 #undef __get_str
 487 #define __get_str(field)                field
 488
 489 #undef __get_dynamic_array
 490 #define __get_dynamic_array(field)      field
 491
 492 /* Beware: this get len actually consumes the len value */
 493 #undef __get_dynamic_array_len
 494 #define __get_dynamic_array_len(field)  __dynamic_len[__dynamic_len_idx++]
 495
 496 #undef TP_PROTO
 497 #define TP_PROTO(args...) args
 498
 499 #undef TP_ARGS
 500 #define TP_ARGS(args...) args
 501
 502 #undef TP_STRUCT__entry
 503 #define TP_STRUCT__entry(args...) args
 504
 505 #undef TP_fast_assign
 506 #define TP_fast_assign(args...) args
 507
 508 #undef DECLARE_EVENT_CLASS
 509 #define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
 510 static void __event_probe__##_name(void *__data, _proto)                      \
 511 {                                                                             \
 512         struct ltt_event *__event = __data;                                   \
 513         struct ltt_channel *__chan = __event->chan;                           \
 514         struct lib_ring_buffer_ctx ctx;                                       \
 515         size_t __event_len, __event_align;                                    \
 516         size_t __dynamic_len_idx = 0;                                         \
 517         size_t __dynamic_len[ARRAY_SIZE(__event_fields___##_name)];           \
 518         struct __event_typemap__##_name __typemap;                            \
 519         int __ret;                                                            \
 520                                                                               \
 521         if (0)                                                                \
 522                 (void) __dynamic_len_idx;       /* don't warn if unused */    \
 523         if (!ACCESS_ONCE(__chan->session->active))                            \
 524                 return;                                                       \
 525         __event_len = __event_get_size__##_name(__dynamic_len, _args);        \
 526         __event_align = __event_get_align__##_name(_args);                    \
 527         lib_ring_buffer_ctx_init(&ctx, __chan->chan, __event, __event_len,    \
 528                                  __event_align, -1);                          \
 529         __ret = __chan->ops->event_reserve(&ctx, __event->id);                \
 530         if (__ret < 0)                                                        \
 531                 return;                                                       \
 532         /* Control code (field ordering) */                                   \
 533         _tstruct                                                              \
 534         __chan->ops->event_commit(&ctx);                                      \
 535         return;                                                               \
 536         /* Copy code, steered by control code */                              \
 537         _assign                                                               \
 538 }
 539
 540 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 541
 542 /*
 543  * Stage 10 of the trace events.
 544  *
 545  * Register/unregister probes at module load/unload.
 546  */
 547
 548 #include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
 549
 550 #define TP_ID1(_token, _system) _token##_system
 551 #define TP_ID(_token, _system)  TP_ID1(_token, _system)
 552 #define module_init_eval1(_token, _system)      module_init(_token##_system)
 553 #define module_init_eval(_token, _system)       module_init_eval1(_token, _system)
 554 #define module_exit_eval1(_token, _system)      module_exit(_token##_system)
 555 #define module_exit_eval(_token, _system)       module_exit_eval1(_token, _system)
 556
 557 static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void)
 558 {
 559         wrapper_vmalloc_sync_all();
 560         return ltt_probe_register(&TP_ID(__probe_desc___, TRACE_SYSTEM));
 561 }
 562
 563 module_init_eval(__lttng_events_init__, TRACE_SYSTEM);
 564
 565 static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void)
 566 {
 567         ltt_probe_unregister(&TP_ID(__probe_desc___, TRACE_SYSTEM));
 568 }
 569
 570 module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM);
 571
 572 #undef module_init_eval
 573 #undef module_exit_eval
 574 #undef TP_ID1
 575 #undef TP_ID