probes/lttng-events.h

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