include/lttng/events.h

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * lttng/events.h
   4  *
   5  * Holds LTTng per-session event registry.
   6  *
   7  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  */
   9
  10 #ifndef _LTTNG_EVENTS_H
  11 #define _LTTNG_EVENTS_H
  12
  13 #include <lttng/kernel-version.h>
  14 #include <linux/list.h>
  15 #include <linux/kprobes.h>
  16 #include <linux/kref.h>
  17 #include <linux/uuid.h>
  18 #include <linux/irq_work.h>
  19 #include <linux/uprobes.h>
  20
  21 #include <lttng/cpuhotplug.h>
  22 #include <lttng/tracer.h>
  23 #include <lttng/abi.h>
  24 #include <lttng/abi-old.h>
  25 #include <lttng/endian.h>
  26
  27 #define lttng_is_signed_type(type)      (((type) -1) < (type) 1)
  28
  29 struct lttng_kernel_channel_buffer;
  30 struct lttng_kernel_channel_counter;
  31 struct lttng_kernel_session;
  32 struct lttng_kernel_ring_buffer_ctx;
  33
  34 /* Type description */
  35
  36 enum lttng_kernel_type {
  37         lttng_kernel_type_integer,
  38         lttng_kernel_type_string,
  39         lttng_kernel_type_enum,
  40         lttng_kernel_type_array,
  41         lttng_kernel_type_sequence,
  42         lttng_kernel_type_struct,
  43         lttng_kernel_type_variant,
  44         NR_LTTNG_KERNEL_TYPES,
  45 };
  46
  47 enum lttng_kernel_string_encoding {
  48         lttng_kernel_string_encoding_none = 0,
  49         lttng_kernel_string_encoding_UTF8 = 1,
  50         lttng_kernel_string_encoding_ASCII = 2,
  51         NR_LTTNG_KERNEL_STRING_ENCODING,
  52 };
  53
  54 struct lttng_kernel_enum_value {
  55         unsigned long long value;
  56         unsigned int signedness:1;
  57 };
  58
  59 struct lttng_kernel_enum_entry {
  60         struct lttng_kernel_enum_value start, end;      /* start and end are inclusive */
  61         const char *string;
  62         struct {
  63                 unsigned int is_auto:1;
  64         } options;
  65 };
  66
  67 /*
  68  * struct lttng_kernel_type_common is fixed-size. Its children inherits
  69  * from it by embedding struct lttng_kernel_type_common as its first field.
  70  */
  71 struct lttng_kernel_type_common {
  72         enum lttng_kernel_type type;
  73 };
  74
  75 struct lttng_kernel_type_integer {
  76         struct lttng_kernel_type_common parent;
  77         unsigned int size;              /* in bits */
  78         unsigned short alignment;       /* in bits */
  79         unsigned int signedness:1,
  80                 reverse_byte_order:1,
  81                 user:1;                 /* fetch from user-space */
  82         unsigned int base;              /* 2, 8, 10, 16, for pretty print */
  83 };
  84
  85 struct lttng_kernel_type_string {
  86         struct lttng_kernel_type_common parent;
  87         enum lttng_kernel_string_encoding encoding;
  88         unsigned int user:1;            /* fetch from user-space */
  89 };
  90
  91 struct lttng_kernel_type_enum {
  92         struct lttng_kernel_type_common parent;
  93         const struct lttng_kernel_enum_desc *desc;      /* Enumeration mapping */
  94         const struct lttng_kernel_type_common *container_type;
  95 };
  96
  97 struct lttng_kernel_type_array {
  98         struct lttng_kernel_type_common parent;
  99         const struct lttng_kernel_type_common *elem_type;
 100         unsigned int length;                    /* Num. elems. */
 101         unsigned int alignment;         /* Alignment in bytes before elements. */
 102         enum lttng_kernel_string_encoding encoding;
 103 };
 104
 105 struct lttng_kernel_type_sequence {
 106         struct lttng_kernel_type_common parent;
 107         const char *length_name;        /* Length field name. If NULL, use previous field. */
 108         const struct lttng_kernel_type_common *elem_type;
 109         unsigned int alignment;         /* Alignment in bytes before elements. */
 110         enum lttng_kernel_string_encoding encoding;
 111 };
 112
 113 struct lttng_kernel_type_struct {
 114         struct lttng_kernel_type_common parent;
 115         unsigned int nr_fields;
 116         const struct lttng_kernel_event_field * const *fields;  /* Array of pointers to fields. */
 117         unsigned int alignment;         /* Alignment in bits */
 118 };
 119
 120 struct lttng_kernel_type_variant {
 121         struct lttng_kernel_type_common parent;
 122         const char *tag_name;           /* Tag field name. If NULL, use previous field. */
 123         const struct lttng_kernel_event_field * const *choices; /* Array of pointers to fields. */
 124         unsigned int nr_choices;
 125         unsigned int alignment;         /* Alignment in bytes */
 126 };
 127
 128 struct lttng_kernel_enum_desc {
 129         const char *name;
 130         const struct lttng_kernel_enum_entry * const *entries;
 131         unsigned int nr_entries;
 132         const struct lttng_kernel_probe_desc *probe_desc;
 133 };
 134
 135 /* Event field description */
 136
 137 struct lttng_kernel_event_field {
 138         const char *name;
 139         const struct lttng_kernel_type_common *type;
 140         unsigned int nowrite:1,         /* do not write into trace */
 141                         nofilter:1;     /* do not consider for filter */
 142 };
 143
 144 #ifndef PARAMS
 145 #define PARAMS(args...) args
 146 #endif
 147
 148 #define _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _user, _base)    \
 149         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
 150                 .parent = {                                                                             \
 151                         .type = lttng_kernel_type_integer,                                                      \
 152                 },                                                                                      \
 153                 .size = (_size),                                                                        \
 154                 .alignment = (_alignment),                                                              \
 155                 .signedness = (_signedness),                                                            \
 156                 .reverse_byte_order = (_byte_order) != __BYTE_ORDER,                                    \
 157                 .user = (_user),                                                                        \
 158                 .base = (_base),                                                                        \
 159         }))
 160
 161 #define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base)            \
 162         _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 0, _base)
 163
 164 #define lttng_kernel_static_type_user_integer(_size, _alignment, _signedness, _byte_order, _base)       \
 165         _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 1, _base)
 166
 167 #define _lttng_kernel_static_type_integer_from_type(_type, _byte_order, _user, _base)                   \
 168         _lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT,                                     \
 169                         lttng_alignof(_type) * CHAR_BIT,                                                \
 170                         lttng_is_signed_type(_type),                                                    \
 171                         _byte_order, _user, _base)
 172
 173 #define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base)                           \
 174         _lttng_kernel_static_type_integer_from_type(_type, _byte_order, 0, _base)
 175
 176 #define lttng_kernel_static_type_user_integer_from_type(_type, _byte_order, _base)                      \
 177         _lttng_kernel_static_type_integer_from_type(_type, _byte_order, 1, _base)
 178
 179 #define lttng_kernel_static_type_enum(_desc, _container_type)                                           \
 180         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
 181                 .parent = {                                                                             \
 182                         .type = lttng_kernel_type_enum,                                                 \
 183                 },                                                                                      \
 184                 .desc = (_desc),                                                                        \
 185                 .container_type = (_container_type),                                                    \
 186         }))
 187
 188 #define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding)                      \
 189         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
 190                 .parent = {                                                                             \
 191                         .type = lttng_kernel_type_array,                                                \
 192                 },                                                                                      \
 193                 .length = (_length),                                                                    \
 194                 .alignment = (_alignment),                                                              \
 195                 .encoding = lttng_kernel_string_encoding_##_encoding,                                   \
 196                 .elem_type = (_elem_type),                                                              \
 197         }))
 198
 199 #define lttng_kernel_static_type_array_text(_length)                                                    \
 200         lttng_kernel_static_type_array(_length,                                                         \
 201                 lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT,                               \
 202                                 lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char),             \
 203                                 __BYTE_ORDER, 10),                                                      \
 204                 0, UTF8)
 205
 206 #define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding)                      \
 207         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
 208                 .parent = {                                                                             \
 209                         .type = lttng_kernel_type_sequence,                                             \
 210                 },                                                                                      \
 211                 .length_name = (_length_name),                                                          \
 212                 .alignment = (_alignment),                                                              \
 213                 .encoding = lttng_kernel_string_encoding_##_encoding,                                   \
 214                 .elem_type = (_elem_type),                                                              \
 215         }))
 216
 217 #define lttng_kernel_static_type_string(_encoding, _user)                                               \
 218         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
 219                 .parent = {                                                                             \
 220                         .type = lttng_kernel_type_string,                                               \
 221                 },                                                                                      \
 222                 .encoding = lttng_kernel_string_encoding_##_encoding,                                   \
 223                 .user = (_user),                                                                        \
 224         }))
 225
 226 #define lttng_kernel_static_type_struct_init(_nr_fields, _fields, _alignment)                           \
 227         {                                                                                               \
 228                 .parent = {                                                                             \
 229                         .type = lttng_kernel_type_struct,                                               \
 230                 },                                                                                      \
 231                 .nr_fields = (_nr_fields),                                                              \
 232                 .fields = _fields,                                                                      \
 233                 .alignment = (_alignment),                                                              \
 234         }
 235
 236 #define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment)                                \
 237         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, \
 238                 lttng_kernel_static_type_struct_init(_nr_fields, PARAMS(_fields), _alignment)                   \
 239         ))
 240
 241 #define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment)                  \
 242         ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
 243                 .parent = {                                                                             \
 244                         .type = lttng_kernel_type_variant,                                              \
 245                 },                                                                                      \
 246                 .tag_name = (_tag_name),                                                                \
 247                 .choices = _choices,                                                                    \
 248                 .nr_choices = (_nr_choices),                                                            \
 249                 .alignment = (_alignment),                                                              \
 250         }))
 251
 252 #define lttng_kernel_static_event_field(_name, _type, _nowrite, _nofilter)                              \
 253         __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, {                               \
 254                 .name = (_name),                                                                        \
 255                 .type = (_type),                                                                        \
 256                 .nowrite = (_nowrite),                                                                  \
 257                 .nofilter = (_nofilter),                                                                \
 258         })
 259
 260 #define lttng_kernel_static_event_field_array(_fields...)                                               \
 261         __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *,                               \
 262                 _fields                                                                                 \
 263         )
 264
 265 #define lttng_kernel_static_enum_entry_value(_string, _value)                                           \
 266         __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {                                \
 267                 .start = {                                                                              \
 268                         .signedness = lttng_is_signed_type(__typeof__(_value)),                         \
 269                         .value = lttng_is_signed_type(__typeof__(_value)) ?                             \
 270                                 (long long) (_value) : (_value),                                        \
 271                 },                                                                                      \
 272                 .end = {                                                                                \
 273                         .signedness = lttng_is_signed_type(__typeof__(_value)),                         \
 274                         .value = lttng_is_signed_type(__typeof__(_value)) ?                             \
 275                                 (long long) (_value) : (_value),                                        \
 276                 },                                                                                      \
 277                 .string = (_string),                                                                    \
 278         }),
 279
 280 #define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end)                         \
 281         __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {                                \
 282                 .start = {                                                                              \
 283                         .signedness = lttng_is_signed_type(__typeof__(_range_start)),                   \
 284                         .value = lttng_is_signed_type(__typeof__(_range_start)) ?                       \
 285                                 (long long) (_range_start) : (_range_start),                            \
 286                 },                                                                                      \
 287                 .end = {                                                                                \
 288                         .signedness = lttng_is_signed_type(__typeof__(_range_end)),                     \
 289                         .value = lttng_is_signed_type(__typeof__(_range_end)) ?                         \
 290                                 (long long) (_range_end) : (_range_end),                                \
 291                 },                                                                                      \
 292                 .string = (_string),                                                                    \
 293         }),
 294
 295 #define lttng_kernel_static_enum_entry_auto(_string)                                                    \
 296         __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {                                \
 297                 .start = {                                                                              \
 298                         .signedness = -1,                                                               \
 299                         .value = -1,                                                                    \
 300                 },                                                                                      \
 301                 .end = {                                                                                \
 302                         .signedness = -1,                                                               \
 303                         .value = -1,                                                                    \
 304                 },                                                                                      \
 305                 .string = (_string),                                                                    \
 306                 .options = {                                                                            \
 307                         .is_auto = 1,                                                                   \
 308                 }                                                                                       \
 309         }),
 310
 311 struct lttng_kernel_probe_ctx {
 312         struct lttng_kernel_event_common *event;
 313         uint8_t interruptible;
 314 };
 315
 316 struct lttng_kernel_tracepoint_class {
 317         void (*probe_callback)(void);
 318         const struct lttng_kernel_event_field * const *fields;  /* event payload */
 319         unsigned int nr_fields;
 320         const struct lttng_kernel_probe_desc *probe_desc;
 321 };
 322
 323 struct lttng_kernel_event_desc {
 324         const char *event_name;         /* lttng-modules name */
 325         const char *event_kname;        /* Linux kernel name (tracepoints) */
 326         const struct lttng_kernel_probe_desc *probe_desc;
 327         const struct lttng_kernel_tracepoint_class *tp_class;
 328         struct module *owner;
 329 };
 330
 331 struct lttng_kernel_probe_desc {
 332         const char *provider_name;
 333         const struct lttng_kernel_event_desc * const *event_desc;
 334         unsigned int nr_events;
 335         struct list_head head;                  /* chain registered probes */
 336         struct list_head lazy_init_head;
 337         int lazy;                               /* lazy registration */
 338 };
 339
 340 /*
 341  * Result of the run_filter() callback.
 342  */
 343 enum lttng_kernel_event_filter_result {
 344         LTTNG_KERNEL_EVENT_FILTER_ACCEPT = 0,
 345         LTTNG_KERNEL_EVENT_FILTER_REJECT = 1,
 346 };
 347
 348 struct lttng_kernel_event_common_private;
 349
 350 enum lttng_kernel_event_type {
 351         LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
 352         LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
 353         LTTNG_KERNEL_EVENT_TYPE_COUNTER = 2
 354 };
 355
 356 struct lttng_kernel_event_common {
 357         struct lttng_kernel_event_common_private *priv; /* Private event interface */
 358
 359         enum lttng_kernel_event_type type;
 360         /* Get child with container_of(). */
 361
 362         int enabled;
 363         int eval_filter;                                /* Need to evaluate filters */
 364         int (*run_filter)(const struct lttng_kernel_event_common *event,
 365                 const char *stack_data,
 366                 struct lttng_kernel_probe_ctx *probe_ctx,
 367                 void *filter_ctx);
 368 };
 369
 370 struct lttng_kernel_event_recorder_private;
 371
 372 struct lttng_kernel_event_recorder {
 373         struct lttng_kernel_event_common parent;
 374         struct lttng_kernel_event_recorder_private *priv;       /* Private event record interface */
 375
 376         struct lttng_kernel_channel_buffer *chan;
 377 };
 378
 379 struct lttng_kernel_event_counter_ctx {
 380         int args_available;
 381 };
 382
 383 struct lttng_kernel_event_counter_private;
 384
 385 struct lttng_kernel_event_counter {
 386         struct lttng_kernel_event_common parent;
 387         struct lttng_kernel_event_counter_private *priv;        /* Private event counter interface */
 388
 389         struct lttng_kernel_channel_counter *chan;
 390
 391         int use_args;                                           /* Use input arguments. */
 392 };
 393
 394 struct lttng_kernel_notification_ctx {
 395         int eval_capture;                                       /* Capture evaluation available. */
 396 };
 397
 398 struct lttng_kernel_event_notifier_private;
 399
 400 struct lttng_kernel_event_notifier {
 401         struct lttng_kernel_event_common parent;
 402         struct lttng_kernel_event_notifier_private *priv;       /* Private event notifier interface */
 403
 404         int eval_capture;                               /* Need to evaluate capture */
 405         void (*notification_send)(struct lttng_kernel_event_notifier *event_notifier,
 406                 const char *stack_data,
 407                 struct lttng_kernel_probe_ctx *probe_ctx,
 408                 struct lttng_kernel_notification_ctx *notif_ctx);
 409 };
 410
 411 struct lttng_kernel_channel_buffer_ops {
 412         struct lttng_kernel_channel_buffer_ops_private *priv;   /* Private channel buffer ops interface. */
 413
 414         int (*event_reserve)(struct lttng_kernel_ring_buffer_ctx *ctx);
 415         void (*event_commit)(struct lttng_kernel_ring_buffer_ctx *ctx);
 416         void (*event_write)(struct lttng_kernel_ring_buffer_ctx *ctx, const void *src,
 417                             size_t len, size_t alignment);
 418         void (*event_write_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
 419                                       const void *src, size_t len, size_t alignment);
 420         void (*event_memset)(struct lttng_kernel_ring_buffer_ctx *ctx,
 421                              int c, size_t len);
 422         void (*event_strcpy)(struct lttng_kernel_ring_buffer_ctx *ctx, const char *src,
 423                              size_t len);
 424         void (*event_strcpy_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
 425                                        const char __user *src, size_t len);
 426         void (*event_pstrcpy_pad)(struct lttng_kernel_ring_buffer_ctx *ctx,
 427                                   const char *src, size_t len);
 428         void (*event_pstrcpy_pad_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
 429                                   const char __user *src, size_t len);
 430         void (*lost_event_too_big)(struct lttng_kernel_channel_buffer *lttng_channel);
 431 };
 432
 433 enum lttng_kernel_channel_type {
 434         LTTNG_KERNEL_CHANNEL_TYPE_BUFFER = 0,
 435         LTTNG_KERNEL_CHANNEL_TYPE_COUNTER = 1,
 436 };
 437
 438 struct lttng_kernel_channel_common_private;
 439
 440 /* Use container_of() to get child. */
 441 struct lttng_kernel_channel_common {
 442         struct lttng_kernel_channel_common_private *priv;       /* Private channel interface. */
 443
 444         enum lttng_kernel_channel_type type;
 445
 446         int enabled;
 447         struct lttng_kernel_session *session;
 448 };
 449
 450 struct lttng_kernel_channel_buffer_private;
 451
 452 struct lttng_kernel_channel_buffer {
 453         struct lttng_kernel_channel_common parent;
 454         struct lttng_kernel_channel_buffer_private *priv;
 455
 456         struct lttng_kernel_channel_buffer_ops *ops;
 457 };
 458
 459 struct lttng_kernel_channel_counter;
 460 struct lttng_kernel_channel_counter_ops_private;
 461
 462 struct lttng_kernel_channel_counter_ops {
 463         struct lttng_kernel_channel_counter_ops_private *priv;  /* Private channel counter ops interface */
 464
 465         int (*counter_hit)(struct lttng_kernel_event_counter *event_counter,
 466                 const char *stack_data,
 467                 struct lttng_kernel_probe_ctx *probe_ctx,
 468                 struct lttng_kernel_event_counter_ctx *event_counter_ctx);
 469 };
 470
 471 struct lttng_kernel_channel_counter {
 472         struct lttng_kernel_channel_common parent;
 473         struct lttng_kernel_channel_counter_private *priv;      /* Private channel counter interface */
 474
 475         struct lttng_kernel_channel_counter_ops *ops;
 476 };
 477
 478 #define LTTNG_DYNAMIC_LEN_STACK_SIZE    128
 479
 480 struct lttng_dynamic_len_stack {
 481         size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
 482         size_t offset;
 483 };
 484
 485 DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
 486
 487 /*
 488  * struct lttng_kernel_id_tracker declared in header due to deferencing of *v
 489  * in RCU_INITIALIZER(v).
 490  */
 491 #define LTTNG_ID_HASH_BITS      6
 492 #define LTTNG_ID_TABLE_SIZE     (1 << LTTNG_ID_HASH_BITS)
 493
 494 struct lttng_kernel_id_tracker_rcu {
 495         struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
 496 };
 497
 498 struct lttng_kernel_id_tracker {
 499         struct lttng_kernel_id_tracker_private *priv;   /* Private API */
 500
 501         struct lttng_kernel_id_tracker_rcu *p;  /* RCU dereferenced. */
 502 };
 503
 504 struct lttng_kernel_session_private;
 505
 506 struct lttng_kernel_session {
 507         struct lttng_kernel_session_private *priv;      /* Private session interface */
 508
 509         int active;                     /* Is trace session active ? */
 510
 511         struct lttng_kernel_id_tracker pid_tracker;
 512         struct lttng_kernel_id_tracker vpid_tracker;
 513         struct lttng_kernel_id_tracker uid_tracker;
 514         struct lttng_kernel_id_tracker vuid_tracker;
 515         struct lttng_kernel_id_tracker gid_tracker;
 516         struct lttng_kernel_id_tracker vgid_tracker;
 517 };
 518
 519 int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc);
 520 void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc);
 521
 522 bool lttng_id_tracker_lookup(struct lttng_kernel_id_tracker_rcu *p, int id);
 523
 524 static inline
 525 struct lttng_kernel_channel_common *lttng_kernel_get_chan_common_from_event_common(
 526                 struct lttng_kernel_event_common *event)
 527 {
 528         switch (event->type) {
 529         case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
 530         {
 531                 struct lttng_kernel_event_recorder *event_recorder =
 532                         container_of(event, struct lttng_kernel_event_recorder, parent);
 533                 struct lttng_kernel_channel_buffer *chan_buf = event_recorder->chan;
 534
 535                 return &chan_buf->parent;
 536         }
 537         case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
 538         {
 539                 struct lttng_kernel_event_counter *event_counter =
 540                         container_of(event, struct lttng_kernel_event_counter, parent);
 541                 struct lttng_kernel_channel_counter *chan_counter = event_counter->chan;
 542
 543                 return &chan_counter->parent;
 544         }
 545         default:
 546                 return NULL;
 547         }
 548 }
 549
 550 #endif /* _LTTNG_EVENTS_H */