include/lttng/ust-events.h

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Holds LTTng per-session event registry.
   7  */
   8
   9 #ifndef _LTTNG_UST_EVENTS_H
  10 #define _LTTNG_UST_EVENTS_H
  11
  12 #include <urcu/list.h>
  13 #include <urcu/hlist.h>
  14 #include <stddef.h>
  15 #include <stdint.h>
  16 #include <lttng/ust-abi.h>
  17 #include <lttng/ust-tracer.h>
  18 #include <lttng/ust-endian.h>
  19 #include <float.h>
  20 #include <errno.h>
  21 #include <urcu/ref.h>
  22 #include <pthread.h>
  23
  24 #ifndef LTTNG_PACKED
  25 #error "LTTNG_PACKED should be defined"
  26 #endif
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #define LTTNG_UST_UUID_LEN              16
  33
  34 /*
  35  * Tracepoint provider version. Compatibility based on the major number.
  36  * Older tracepoint providers can always register to newer lttng-ust
  37  * library, but the opposite is rejected: a newer tracepoint provider is
  38  * rejected by an older lttng-ust library.
  39  */
  40 #define LTTNG_UST_PROVIDER_MAJOR        2
  41 #define LTTNG_UST_PROVIDER_MINOR        0
  42
  43 struct lttng_channel;
  44 struct lttng_session;
  45 struct lttng_ust_lib_ring_buffer_ctx;
  46 struct lttng_event_field;
  47 struct lttng_event_notifier;
  48 struct lttng_event_notifier_group;
  49
  50 /*
  51  * Data structures used by tracepoint event declarations, and by the
  52  * tracer. Those structures have padding for future extension.
  53  */
  54
  55 /* Type description */
  56
  57 /* Update the astract_types name table in lttng-types.c along with this enum */
  58 enum lttng_abstract_types {
  59         atype_integer,
  60         atype_enum,     /* legacy */
  61         atype_array,    /* legacy */
  62         atype_sequence, /* legacy */
  63         atype_string,
  64         atype_float,
  65         atype_dynamic,
  66         atype_struct,   /* legacy */
  67         atype_enum_nestable,
  68         atype_array_nestable,
  69         atype_sequence_nestable,
  70         atype_struct_nestable,
  71         NR_ABSTRACT_TYPES,
  72 };
  73
  74 /* Update the string_encodings name table in lttng-types.c along with this enum */
  75 enum lttng_string_encodings {
  76         lttng_encode_none = 0,
  77         lttng_encode_UTF8 = 1,
  78         lttng_encode_ASCII = 2,
  79         NR_STRING_ENCODINGS,
  80 };
  81
  82 struct lttng_enum_value {
  83         unsigned long long value;
  84         unsigned int signedness:1;
  85 };
  86
  87 enum lttng_enum_entry_options {
  88         LTTNG_ENUM_ENTRY_OPTION_IS_AUTO = 1U << 0,
  89 };
  90
  91 #define LTTNG_UST_ENUM_ENTRY_PADDING    16
  92 struct lttng_enum_entry {
  93         struct lttng_enum_value start, end; /* start and end are inclusive */
  94         const char *string;
  95         union {
  96                 struct {
  97                         unsigned int options;
  98                 } LTTNG_PACKED extra;
  99                 char padding[LTTNG_UST_ENUM_ENTRY_PADDING];
 100         } u;
 101 };
 102
 103 #define __type_integer(_type, _byte_order, _base, _encoding)    \
 104         {                                                       \
 105           .atype = atype_integer,                               \
 106           .u =                                                  \
 107                 {                                               \
 108                   .integer =                                    \
 109                         {                                       \
 110                           .size = sizeof(_type) * CHAR_BIT,     \
 111                           .alignment = lttng_alignof(_type) * CHAR_BIT, \
 112                           .signedness = lttng_is_signed_type(_type), \
 113                           .reverse_byte_order = _byte_order != BYTE_ORDER, \
 114                           .base = _base,                        \
 115                           .encoding = lttng_encode_##_encoding, \
 116                         }                                       \
 117                 },                                              \
 118         }                                                       \
 119
 120 #define LTTNG_UST_INTEGER_TYPE_PADDING  24
 121 struct lttng_integer_type {
 122         unsigned int size;              /* in bits */
 123         unsigned short alignment;       /* in bits */
 124         unsigned int signedness:1;
 125         unsigned int reverse_byte_order:1;
 126         unsigned int base;              /* 2, 8, 10, 16, for pretty print */
 127         enum lttng_string_encodings encoding;
 128         char padding[LTTNG_UST_INTEGER_TYPE_PADDING];
 129 };
 130
 131 /*
 132  * Only float and double are supported. long double is not supported at
 133  * the moment.
 134  */
 135 #define _float_mant_dig(_type)                                          \
 136         (sizeof(_type) == sizeof(float) ? FLT_MANT_DIG                  \
 137                 : (sizeof(_type) == sizeof(double) ? DBL_MANT_DIG       \
 138                 : 0))
 139
 140 #define __type_float(_type)                                     \
 141         {                                                       \
 142           .atype = atype_float,                                 \
 143           .u =                                                  \
 144                 {                                               \
 145                   ._float =                                     \
 146                         {                                       \
 147                           .exp_dig = sizeof(_type) * CHAR_BIT   \
 148                                           - _float_mant_dig(_type), \
 149                           .mant_dig = _float_mant_dig(_type),   \
 150                           .alignment = lttng_alignof(_type) * CHAR_BIT, \
 151                           .reverse_byte_order = BYTE_ORDER != FLOAT_WORD_ORDER, \
 152                         }                                       \
 153                 }                                               \
 154         }                                                       \
 155
 156 #define LTTNG_UST_FLOAT_TYPE_PADDING    24
 157 struct lttng_float_type {
 158         unsigned int exp_dig;           /* exponent digits, in bits */
 159         unsigned int mant_dig;          /* mantissa digits, in bits */
 160         unsigned short alignment;       /* in bits */
 161         unsigned int reverse_byte_order:1;
 162         char padding[LTTNG_UST_FLOAT_TYPE_PADDING];
 163 };
 164
 165 /* legacy */
 166 #define LTTNG_UST_BASIC_TYPE_PADDING    128
 167 union _lttng_basic_type {
 168         struct lttng_integer_type integer;      /* legacy */
 169         struct {
 170                 const struct lttng_enum_desc *desc;     /* Enumeration mapping */
 171                 struct lttng_integer_type container_type;
 172         } enumeration;                          /* legacy */
 173         struct {
 174                 enum lttng_string_encodings encoding;
 175         } string;                               /* legacy */
 176         struct lttng_float_type _float;         /* legacy */
 177         char padding[LTTNG_UST_BASIC_TYPE_PADDING];
 178 };
 179
 180 /* legacy */
 181 struct lttng_basic_type {
 182         enum lttng_abstract_types atype;
 183         union {
 184                 union _lttng_basic_type basic;
 185         } u;
 186 };
 187
 188 #define LTTNG_UST_TYPE_PADDING  128
 189 struct lttng_type {
 190         enum lttng_abstract_types atype;
 191         union {
 192                 /* provider ABI 2.0 */
 193                 struct lttng_integer_type integer;
 194                 struct lttng_float_type _float;
 195                 struct {
 196                         enum lttng_string_encodings encoding;
 197                 } string;
 198                 struct {
 199                         const struct lttng_enum_desc *desc;     /* Enumeration mapping */
 200                         struct lttng_type *container_type;
 201                 } enum_nestable;
 202                 struct {
 203                         const struct lttng_type *elem_type;
 204                         unsigned int length;                    /* Num. elems. */
 205                         unsigned int alignment;
 206                 } array_nestable;
 207                 struct {
 208                         const char *length_name;                /* Length field name. */
 209                         const struct lttng_type *elem_type;
 210                         unsigned int alignment;                 /* Alignment before elements. */
 211                 } sequence_nestable;
 212                 struct {
 213                         unsigned int nr_fields;
 214                         const struct lttng_event_field *fields; /* Array of fields. */
 215                         unsigned int alignment;
 216                 } struct_nestable;
 217
 218                 union {
 219                         /* legacy provider ABI 1.0 */
 220                         union _lttng_basic_type basic;  /* legacy */
 221                         struct {
 222                                 struct lttng_basic_type elem_type;
 223                                 unsigned int length;            /* Num. elems. */
 224                         } array;                        /* legacy */
 225                         struct {
 226                                 struct lttng_basic_type length_type;
 227                                 struct lttng_basic_type elem_type;
 228                         } sequence;                     /* legacy */
 229                         struct {
 230                                 unsigned int nr_fields;
 231                                 struct lttng_event_field *fields;       /* Array of fields. */
 232                         } _struct;                      /* legacy */
 233                 } legacy;
 234                 char padding[LTTNG_UST_TYPE_PADDING];
 235         } u;
 236 };
 237
 238 #define LTTNG_UST_ENUM_TYPE_PADDING     24
 239 struct lttng_enum_desc {
 240         const char *name;
 241         const struct lttng_enum_entry *entries;
 242         unsigned int nr_entries;
 243         char padding[LTTNG_UST_ENUM_TYPE_PADDING];
 244 };
 245
 246 /*
 247  * Event field description
 248  *
 249  * IMPORTANT: this structure is part of the ABI between the probe and
 250  * UST. Fields need to be only added at the end, never reordered, never
 251  * removed.
 252  */
 253
 254 #define LTTNG_UST_EVENT_FIELD_PADDING   28
 255 struct lttng_event_field {
 256         const char *name;
 257         struct lttng_type type;
 258         unsigned int nowrite;   /* do not write into trace */
 259         union {
 260                 struct {
 261                         unsigned int nofilter:1;        /* do not consider for filter */
 262                 } ext;
 263                 char padding[LTTNG_UST_EVENT_FIELD_PADDING];
 264         } u;
 265 };
 266
 267 enum lttng_ust_dynamic_type {
 268         LTTNG_UST_DYNAMIC_TYPE_NONE,
 269         LTTNG_UST_DYNAMIC_TYPE_S8,
 270         LTTNG_UST_DYNAMIC_TYPE_S16,
 271         LTTNG_UST_DYNAMIC_TYPE_S32,
 272         LTTNG_UST_DYNAMIC_TYPE_S64,
 273         LTTNG_UST_DYNAMIC_TYPE_U8,
 274         LTTNG_UST_DYNAMIC_TYPE_U16,
 275         LTTNG_UST_DYNAMIC_TYPE_U32,
 276         LTTNG_UST_DYNAMIC_TYPE_U64,
 277         LTTNG_UST_DYNAMIC_TYPE_FLOAT,
 278         LTTNG_UST_DYNAMIC_TYPE_DOUBLE,
 279         LTTNG_UST_DYNAMIC_TYPE_STRING,
 280         _NR_LTTNG_UST_DYNAMIC_TYPES,
 281 };
 282
 283 struct lttng_ctx_value {
 284         enum lttng_ust_dynamic_type sel;
 285         union {
 286                 int64_t s64;
 287                 uint64_t u64;
 288                 const char *str;
 289                 double d;
 290         } u;
 291 };
 292
 293 struct lttng_perf_counter_field;
 294
 295 #define LTTNG_UST_CTX_FIELD_PADDING     40
 296 struct lttng_ctx_field {
 297         struct lttng_event_field event_field;
 298         size_t (*get_size)(struct lttng_ctx_field *field, size_t offset);
 299         void (*record)(struct lttng_ctx_field *field,
 300                        struct lttng_ust_lib_ring_buffer_ctx *ctx,
 301                        struct lttng_channel *chan);
 302         void (*get_value)(struct lttng_ctx_field *field,
 303                          struct lttng_ctx_value *value);
 304         union {
 305                 struct lttng_perf_counter_field *perf_counter;
 306                 char padding[LTTNG_UST_CTX_FIELD_PADDING];
 307         } u;
 308         void (*destroy)(struct lttng_ctx_field *field);
 309         char *field_name;       /* Has ownership, dynamically allocated. */
 310 };
 311
 312 #define LTTNG_UST_CTX_PADDING   20
 313 struct lttng_ctx {
 314         struct lttng_ctx_field *fields;
 315         unsigned int nr_fields;
 316         unsigned int allocated_fields;
 317         unsigned int largest_align;
 318         char padding[LTTNG_UST_CTX_PADDING];
 319 };
 320
 321 #define LTTNG_UST_EVENT_DESC_PADDING    40
 322 struct lttng_event_desc {
 323         const char *name;
 324         void (*probe_callback)(void);
 325         const struct lttng_event_ctx *ctx;      /* context */
 326         const struct lttng_event_field *fields; /* event payload */
 327         unsigned int nr_fields;
 328         const int **loglevel;
 329         const char *signature;  /* Argument types/names received */
 330         union {
 331                 struct {
 332                         const char **model_emf_uri;
 333                         void (*event_notifier_callback)(void);
 334                 } ext;
 335                 char padding[LTTNG_UST_EVENT_DESC_PADDING];
 336         } u;
 337 };
 338
 339 #define LTTNG_UST_PROBE_DESC_PADDING    12
 340 struct lttng_probe_desc {
 341         const char *provider;
 342         const struct lttng_event_desc **event_desc;
 343         unsigned int nr_events;
 344         struct cds_list_head head;              /* chain registered probes */
 345         struct cds_list_head lazy_init_head;
 346         int lazy;                               /* lazy registration */
 347         uint32_t major;
 348         uint32_t minor;
 349         char padding[LTTNG_UST_PROBE_DESC_PADDING];
 350 };
 351
 352 /* Data structures used by the tracer. */
 353
 354 struct tp_list_entry {
 355         struct lttng_ust_tracepoint_iter tp;
 356         struct cds_list_head head;
 357 };
 358
 359 struct lttng_ust_tracepoint_list {
 360         struct tp_list_entry *iter;
 361         struct cds_list_head head;
 362 };
 363
 364 struct tp_field_list_entry {
 365         struct lttng_ust_field_iter field;
 366         struct cds_list_head head;
 367 };
 368
 369 struct lttng_ust_field_list {
 370         struct tp_field_list_entry *iter;
 371         struct cds_list_head head;
 372 };
 373
 374 /*
 375  * Bytecode interpreter return value masks.
 376  */
 377 enum lttng_bytecode_interpreter_ret {
 378         LTTNG_INTERPRETER_DISCARD = 0,
 379         LTTNG_INTERPRETER_RECORD_FLAG = (1ULL << 0),
 380         /* Other bits are kept for future use. */
 381 };
 382
 383 struct lttng_interpreter_output;
 384
 385 /*
 386  * This structure is used in the probes. More specifically, the `filter` and
 387  * `node` fields are explicity used in the probes. When modifying this
 388  * structure we must not change the layout of these two fields as it is
 389  * considered ABI.
 390  */
 391 struct lttng_bytecode_runtime {
 392         /* Associated bytecode */
 393         struct lttng_ust_bytecode_node *bc;
 394         union {
 395                 uint64_t (*filter)(void *interpreter_data,
 396                                 const char *interpreter_stack_data);
 397                 uint64_t (*capture)(void *interpreter_data,
 398                                 const char *interpreter_stack_data,
 399                                 struct lttng_interpreter_output *interpreter_output);
 400         } interpreter_funcs;
 401         int link_failed;
 402         struct cds_list_head node;      /* list of bytecode runtime in event */
 403         /*
 404          * Pointer to a URCU-protected pointer owned by an `struct
 405          * lttng_session`or `struct lttng_event_notifier_group`.
 406          */
 407         struct lttng_ctx **pctx;
 408 };
 409
 410 /*
 411  * Objects in a linked-list of enablers, owned by an event or event_notifier.
 412  * This is used because an event (or a event_notifier) can be enabled by more
 413  * than one enabler and we want a quick way to iterate over all enablers of an
 414  * object.
 415  *
 416  * For example, event rules "my_app:a*" and "my_app:ab*" will both match the
 417  * event with the name "my_app:abc".
 418  */
 419 struct lttng_enabler_ref {
 420         struct cds_list_head node;              /* enabler ref list */
 421         struct lttng_enabler *ref;              /* backward ref */
 422 };
 423
 424 /*
 425  * lttng_event structure is referred to by the tracing fast path. It
 426  * must be kept small.
 427  *
 428  * IMPORTANT: this structure is part of the ABI between the probe and
 429  * UST. Fields need to be only added at the end, never reordered, never
 430  * removed.
 431  */
 432 struct lttng_event {
 433         unsigned int id;
 434         struct lttng_channel *chan;
 435         int enabled;
 436         const struct lttng_event_desc *desc;
 437         struct lttng_ctx *ctx;
 438         enum lttng_ust_instrumentation instrumentation;
 439         struct cds_list_head node;              /* Event list in session */
 440
 441         /* list of struct lttng_bytecode_runtime, sorted by seqnum */
 442         struct cds_list_head filter_bytecode_runtime_head;
 443         int has_enablers_without_bytecode;
 444         /* Backward references: list of lttng_enabler_ref (ref to enablers) */
 445         struct cds_list_head enablers_ref_head;
 446         struct cds_hlist_node hlist;    /* session ht of events */
 447         int registered;                 /* has reg'd tracepoint probe */
 448 };
 449
 450 struct lttng_event_notifier {
 451         uint64_t user_token;
 452         uint64_t error_counter_index;
 453         int enabled;
 454         int registered;                 /* has reg'd tracepoint probe */
 455         size_t num_captures;            /* Needed to allocate the msgpack array. */
 456         void (*notification_send)(struct lttng_event_notifier *event_notifier,
 457                 const char *stack_data);
 458         struct cds_list_head filter_bytecode_runtime_head;
 459         struct cds_list_head capture_bytecode_runtime_head;
 460         int has_enablers_without_bytecode;
 461         struct cds_list_head enablers_ref_head;
 462         const struct lttng_event_desc *desc;
 463         struct cds_hlist_node hlist;    /* hashtable of event_notifiers */
 464         struct cds_list_head node;      /* event_notifier list in session */
 465         struct lttng_event_notifier_group *group; /* weak ref */
 466 };
 467
 468 struct lttng_enum {
 469         const struct lttng_enum_desc *desc;
 470         struct lttng_session *session;
 471         struct cds_list_head node;      /* Enum list in session */
 472         struct cds_hlist_node hlist;    /* Session ht of enums */
 473         uint64_t id;                    /* Enumeration ID in sessiond */
 474 };
 475
 476 struct channel;
 477 struct lttng_ust_shm_handle;
 478
 479 /*
 480  * IMPORTANT: this structure is part of the ABI between the probe and
 481  * UST. Fields need to be only added at the end, never reordered, never
 482  * removed.
 483  */
 484 struct lttng_channel_ops {
 485         struct lttng_channel *(*channel_create)(const char *name,
 486                         void *buf_addr,
 487                         size_t subbuf_size, size_t num_subbuf,
 488                         unsigned int switch_timer_interval,
 489                         unsigned int read_timer_interval,
 490                         unsigned char *uuid,
 491                         uint32_t chan_id,
 492                         const int *stream_fds, int nr_stream_fds,
 493                         int64_t blocking_timeout);
 494         void (*channel_destroy)(struct lttng_channel *chan);
 495         int (*event_reserve)(struct lttng_ust_lib_ring_buffer_ctx *ctx,
 496                              uint32_t event_id);
 497         void (*event_commit)(struct lttng_ust_lib_ring_buffer_ctx *ctx);
 498         void (*event_write)(struct lttng_ust_lib_ring_buffer_ctx *ctx,
 499                         const void *src, size_t len);
 500         /*
 501          * packet_avail_size returns the available size in the current
 502          * packet. Note that the size returned is only a hint, since it
 503          * may change due to concurrent writes.
 504          */
 505         size_t (*packet_avail_size)(struct channel *chan,
 506                                     struct lttng_ust_shm_handle *handle);
 507         int (*is_finalized)(struct channel *chan);
 508         int (*is_disabled)(struct channel *chan);
 509         int (*flush_buffer)(struct channel *chan, struct lttng_ust_shm_handle *handle);
 510         void (*event_strcpy)(struct lttng_ust_lib_ring_buffer_ctx *ctx,
 511                         const char *src, size_t len);
 512 };
 513
 514 /*
 515  * IMPORTANT: this structure is part of the ABI between the probe and
 516  * UST. Fields need to be only added at the end, never reordered, never
 517  * removed.
 518  */
 519 struct lttng_channel {
 520         /*
 521          * The pointers located in this private data are NOT safe to be
 522          * dereferenced by the consumer. The only operations the
 523          * consumer process is designed to be allowed to do is to read
 524          * and perform subbuffer flush.
 525          */
 526         struct channel *chan;           /* Channel buffers */
 527         int enabled;
 528         struct lttng_ctx *ctx;
 529         /* Event ID management */
 530         struct lttng_session *session;
 531         int objd;                       /* Object associated to channel */
 532         struct cds_list_head node;      /* Channel list in session */
 533         const struct lttng_channel_ops *ops;
 534         int header_type;                /* 0: unset, 1: compact, 2: large */
 535         struct lttng_ust_shm_handle *handle;    /* shared-memory handle */
 536
 537         /* Channel ID */
 538         unsigned int id;
 539         enum lttng_ust_chan_type type;
 540         unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
 541         int tstate:1;                   /* Transient enable state */
 542 };
 543
 544 #define LTTNG_COUNTER_DIMENSION_MAX     8
 545
 546 struct lttng_counter_dimension {
 547         uint64_t size;
 548         uint64_t underflow_index;
 549         uint64_t overflow_index;
 550         uint8_t has_underflow;
 551         uint8_t has_overflow;
 552 };
 553
 554 struct lttng_counter_ops {
 555         struct lib_counter *(*counter_create)(size_t nr_dimensions,
 556                         const struct lttng_counter_dimension *dimensions,
 557                         int64_t global_sum_step,
 558                         int global_counter_fd,
 559                         int nr_counter_cpu_fds,
 560                         const int *counter_cpu_fds,
 561                         bool is_daemon);
 562         void (*counter_destroy)(struct lib_counter *counter);
 563         int (*counter_add)(struct lib_counter *counter,
 564                         const size_t *dimension_indexes, int64_t v);
 565         int (*counter_read)(struct lib_counter *counter,
 566                         const size_t *dimension_indexes, int cpu,
 567                         int64_t *value, bool *overflow, bool *underflow);
 568         int (*counter_aggregate)(struct lib_counter *counter,
 569                         const size_t *dimension_indexes, int64_t *value,
 570                         bool *overflow, bool *underflow);
 571         int (*counter_clear)(struct lib_counter *counter, const size_t *dimension_indexes);
 572 };
 573
 574 #define LTTNG_UST_STACK_CTX_PADDING     32
 575 struct lttng_stack_ctx {
 576         struct lttng_event *event;
 577         struct lttng_ctx *chan_ctx;     /* RCU dereferenced. */
 578         struct lttng_ctx *event_ctx;    /* RCU dereferenced. */
 579         char padding[LTTNG_UST_STACK_CTX_PADDING];
 580 };
 581
 582 #define LTTNG_UST_EVENT_HT_BITS         12
 583 #define LTTNG_UST_EVENT_HT_SIZE         (1U << LTTNG_UST_EVENT_HT_BITS)
 584
 585 struct lttng_ust_event_ht {
 586         struct cds_hlist_head table[LTTNG_UST_EVENT_HT_SIZE];
 587 };
 588
 589 #define LTTNG_UST_EVENT_NOTIFIER_HT_BITS                12
 590 #define LTTNG_UST_EVENT_NOTIFIER_HT_SIZE                (1U << LTTNG_UST_EVENT_NOTIFIER_HT_BITS)
 591 struct lttng_ust_event_notifier_ht {
 592         struct cds_hlist_head table[LTTNG_UST_EVENT_NOTIFIER_HT_SIZE];
 593 };
 594
 595 #define LTTNG_UST_ENUM_HT_BITS          12
 596 #define LTTNG_UST_ENUM_HT_SIZE          (1U << LTTNG_UST_ENUM_HT_BITS)
 597
 598 struct lttng_ust_enum_ht {
 599         struct cds_hlist_head table[LTTNG_UST_ENUM_HT_SIZE];
 600 };
 601
 602 /*
 603  * IMPORTANT: this structure is part of the ABI between the probe and
 604  * UST. Fields need to be only added at the end, never reordered, never
 605  * removed.
 606  */
 607 struct lttng_session {
 608         int active;                             /* Is trace session active ? */
 609         int been_active;                        /* Been active ? */
 610         int objd;                               /* Object associated */
 611         struct cds_list_head chan_head;         /* Channel list head */
 612         struct cds_list_head events_head;       /* list of events */
 613         struct cds_list_head node;              /* Session list */
 614
 615         /* New UST 2.1 */
 616         /* List of enablers */
 617         struct cds_list_head enablers_head;
 618         struct lttng_ust_event_ht events_ht;    /* ht of events */
 619         void *owner;                            /* object owner */
 620         int tstate:1;                           /* Transient enable state */
 621
 622         /* New UST 2.4 */
 623         int statedump_pending:1;
 624
 625         /* New UST 2.8 */
 626         struct lttng_ust_enum_ht enums_ht;      /* ht of enumerations */
 627         struct cds_list_head enums_head;
 628         struct lttng_ctx *ctx;                  /* contexts for filters. */
 629 };
 630
 631 struct lttng_counter {
 632         int objd;
 633         struct lttng_event_notifier_group *event_notifier_group;    /* owner */
 634         struct lttng_counter_transport *transport;
 635         struct lib_counter *counter;
 636         struct lttng_counter_ops *ops;
 637 };
 638
 639 struct lttng_event_notifier_group {
 640         int objd;
 641         void *owner;
 642         int notification_fd;
 643         struct cds_list_head node;              /* Event notifier group handle list */
 644         struct cds_list_head enablers_head;
 645         struct cds_list_head event_notifiers_head;      /* list of event_notifiers */
 646         struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
 647         struct lttng_ctx *ctx;                  /* contexts for filters. */
 648
 649         struct lttng_counter *error_counter;
 650         size_t error_counter_len;
 651 };
 652
 653 struct lttng_transport {
 654         char *name;
 655         struct cds_list_head node;
 656         struct lttng_channel_ops ops;
 657         const struct lttng_ust_lib_ring_buffer_config *client_config;
 658 };
 659
 660 struct lttng_counter_transport {
 661         char *name;
 662         struct cds_list_head node;
 663         struct lttng_counter_ops ops;
 664         const struct lib_counter_config *client_config;
 665 };
 666
 667 int lttng_probe_register(struct lttng_probe_desc *desc);
 668 void lttng_probe_unregister(struct lttng_probe_desc *desc);
 669
 670 /*
 671  * Can be used by applications that change their procname to clear the ust cached value.
 672  */
 673 void lttng_context_procname_reset(void);
 674
 675 struct lttng_transport *lttng_transport_find(const char *name);
 676
 677 int lttng_session_active(void);
 678
 679 typedef int (*t_statedump_func_ptr)(struct lttng_session *session);
 680
 681 void lttng_ust_dl_update(void *ip);
 682
 683 #ifdef __cplusplus
 684 }
 685 #endif
 686
 687 #endif /* _LTTNG_UST_EVENTS_H */