probes/lttng-events.h

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