liblttng-ust/ust-events-internal.h

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2019 (c) Francis Deslauriers <francis.deslauriers@efficios.com>
   5  */
   6
   7 #ifndef _LTTNG_UST_EVENTS_INTERNAL_H
   8 #define _LTTNG_UST_EVENTS_INTERNAL_H
   9
  10 #include <stdint.h>
  11
  12 #include <urcu/list.h>
  13 #include <urcu/hlist.h>
  14
  15 #include <lttng/ust-events.h>
  16
  17 #include <ust-helper.h>
  18 #include "ust-context-provider.h"
  19
  20 struct lttng_ust_abi_obj;
  21 struct lttng_event_notifier_group;
  22
  23 union lttng_ust_abi_args {
  24         struct {
  25                 void *chan_data;
  26                 int wakeup_fd;
  27         } channel;
  28         struct {
  29                 int shm_fd;
  30                 int wakeup_fd;
  31         } stream;
  32         struct {
  33                 struct lttng_ust_abi_field_iter entry;
  34         } field_list;
  35         struct {
  36                 char *ctxname;
  37         } app_context;
  38         struct {
  39                 int event_notifier_notif_fd;
  40         } event_notifier_handle;
  41         struct {
  42                 void *counter_data;
  43         } counter;
  44         struct {
  45                 int shm_fd;
  46         } counter_shm;
  47 };
  48
  49 struct lttng_ust_abi_objd_ops {
  50         long (*cmd)(int objd, unsigned int cmd, unsigned long arg,
  51                 union lttng_ust_abi_args *args, void *owner);
  52         int (*release)(int objd);
  53 };
  54
  55 enum lttng_enabler_format_type {
  56         LTTNG_ENABLER_FORMAT_STAR_GLOB,
  57         LTTNG_ENABLER_FORMAT_EVENT,
  58 };
  59
  60 /*
  61  * Enabler field, within whatever object is enabling an event. Target of
  62  * backward reference.
  63  */
  64 struct lttng_enabler {
  65         enum lttng_enabler_format_type format_type;
  66
  67         /* head list of struct lttng_ust_filter_bytecode_node */
  68         struct cds_list_head filter_bytecode_head;
  69         /* head list of struct lttng_ust_excluder_node */
  70         struct cds_list_head excluder_head;
  71
  72         struct lttng_ust_abi_event event_param;
  73         unsigned int enabled:1;
  74 };
  75
  76 struct lttng_event_enabler {
  77         struct lttng_enabler base;
  78         struct cds_list_head node;      /* per-session list of enablers */
  79         struct lttng_ust_channel_buffer *chan;
  80         /*
  81          * Unused, but kept around to make it explicit that the tracer can do
  82          * it.
  83          */
  84         struct lttng_ust_ctx *ctx;
  85 };
  86
  87 struct lttng_event_notifier_enabler {
  88         struct lttng_enabler base;
  89         uint64_t error_counter_index;
  90         struct cds_list_head node;      /* per-app list of event_notifier enablers */
  91         struct cds_list_head capture_bytecode_head;
  92         struct lttng_event_notifier_group *group; /* weak ref */
  93         uint64_t user_token;            /* User-provided token */
  94         uint64_t num_captures;
  95 };
  96
  97 enum lttng_ust_bytecode_type {
  98         LTTNG_UST_BYTECODE_TYPE_FILTER,
  99         LTTNG_UST_BYTECODE_TYPE_CAPTURE,
 100 };
 101
 102 struct lttng_ust_bytecode_node {
 103         enum lttng_ust_bytecode_type type;
 104         struct cds_list_head node;
 105         struct lttng_enabler *enabler;
 106         struct  {
 107                 uint32_t len;
 108                 uint32_t reloc_offset;
 109                 uint64_t seqnum;
 110                 char data[];
 111         } bc;
 112 };
 113
 114 /*
 115  * Bytecode interpreter return value.
 116  */
 117 enum lttng_ust_bytecode_interpreter_ret {
 118         LTTNG_UST_BYTECODE_INTERPRETER_ERROR = -1,
 119         LTTNG_UST_BYTECODE_INTERPRETER_OK = 0,
 120 };
 121
 122 struct lttng_interpreter_output;
 123 struct lttng_ust_bytecode_runtime_private;
 124
 125 enum lttng_ust_bytecode_filter_result {
 126         LTTNG_UST_BYTECODE_FILTER_ACCEPT = 0,
 127         LTTNG_UST_BYTECODE_FILTER_REJECT = 1,
 128 };
 129
 130 struct lttng_ust_bytecode_filter_ctx {
 131         enum lttng_ust_bytecode_filter_result result;
 132 };
 133
 134 struct lttng_ust_excluder_node {
 135         struct cds_list_head node;
 136         struct lttng_enabler *enabler;
 137         /*
 138          * struct lttng_ust_event_exclusion had variable sized array,
 139          * must be last field.
 140          */
 141         struct lttng_ust_abi_event_exclusion excluder;
 142 };
 143
 144 /* Data structures used by the tracer. */
 145
 146 struct tp_list_entry {
 147         struct lttng_ust_abi_tracepoint_iter tp;
 148         struct cds_list_head head;
 149 };
 150
 151 struct lttng_ust_tracepoint_list {
 152         struct tp_list_entry *iter;
 153         struct cds_list_head head;
 154 };
 155
 156 struct tp_field_list_entry {
 157         struct lttng_ust_abi_field_iter field;
 158         struct cds_list_head head;
 159 };
 160
 161 struct lttng_ust_field_list {
 162         struct tp_field_list_entry *iter;
 163         struct cds_list_head head;
 164 };
 165
 166 /*
 167  * Objects in a linked-list of enablers, owned by an event or event_notifier.
 168  * This is used because an event (or a event_notifier) can be enabled by more
 169  * than one enabler and we want a quick way to iterate over all enablers of an
 170  * object.
 171  *
 172  * For example, event rules "my_app:a*" and "my_app:ab*" will both match the
 173  * event with the name "my_app:abc".
 174  */
 175 struct lttng_enabler_ref {
 176         struct cds_list_head node;              /* enabler ref list */
 177         struct lttng_enabler *ref;              /* backward ref */
 178 };
 179
 180 #define LTTNG_COUNTER_DIMENSION_MAX     8
 181 struct lttng_counter_dimension {
 182         uint64_t size;
 183         uint64_t underflow_index;
 184         uint64_t overflow_index;
 185         uint8_t has_underflow;
 186         uint8_t has_overflow;
 187 };
 188
 189 struct lttng_counter_ops {
 190         struct lib_counter *(*counter_create)(size_t nr_dimensions,
 191                         const struct lttng_counter_dimension *dimensions,
 192                         int64_t global_sum_step,
 193                         int global_counter_fd,
 194                         int nr_counter_cpu_fds,
 195                         const int *counter_cpu_fds,
 196                         bool is_daemon);
 197         void (*counter_destroy)(struct lib_counter *counter);
 198         int (*counter_add)(struct lib_counter *counter,
 199                         const size_t *dimension_indexes, int64_t v);
 200         int (*counter_read)(struct lib_counter *counter,
 201                         const size_t *dimension_indexes, int cpu,
 202                         int64_t *value, bool *overflow, bool *underflow);
 203         int (*counter_aggregate)(struct lib_counter *counter,
 204                         const size_t *dimension_indexes, int64_t *value,
 205                         bool *overflow, bool *underflow);
 206         int (*counter_clear)(struct lib_counter *counter, const size_t *dimension_indexes);
 207 };
 208
 209 struct lttng_counter {
 210         int objd;
 211         struct lttng_event_notifier_group *event_notifier_group;    /* owner */
 212         struct lttng_counter_transport *transport;
 213         struct lib_counter *counter;
 214         struct lttng_counter_ops *ops;
 215 };
 216
 217 #define LTTNG_UST_EVENT_HT_BITS         12
 218 #define LTTNG_UST_EVENT_HT_SIZE         (1U << LTTNG_UST_EVENT_HT_BITS)
 219
 220 struct lttng_ust_event_ht {
 221         struct cds_hlist_head table[LTTNG_UST_EVENT_HT_SIZE];
 222 };
 223
 224 #define LTTNG_UST_EVENT_NOTIFIER_HT_BITS                12
 225 #define LTTNG_UST_EVENT_NOTIFIER_HT_SIZE                (1U << LTTNG_UST_EVENT_NOTIFIER_HT_BITS)
 226 struct lttng_ust_event_notifier_ht {
 227         struct cds_hlist_head table[LTTNG_UST_EVENT_NOTIFIER_HT_SIZE];
 228 };
 229
 230 #define LTTNG_UST_ENUM_HT_BITS          12
 231 #define LTTNG_UST_ENUM_HT_SIZE          (1U << LTTNG_UST_ENUM_HT_BITS)
 232
 233 struct lttng_ust_enum_ht {
 234         struct cds_hlist_head table[LTTNG_UST_ENUM_HT_SIZE];
 235 };
 236
 237 struct lttng_event_notifier_group {
 238         int objd;
 239         void *owner;
 240         int notification_fd;
 241         struct cds_list_head node;              /* Event notifier group handle list */
 242         struct cds_list_head enablers_head;
 243         struct cds_list_head event_notifiers_head; /* list of event_notifiers */
 244         struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
 245         struct lttng_ust_ctx *ctx;              /* contexts for filters. */
 246
 247         struct lttng_counter *error_counter;
 248         size_t error_counter_len;
 249 };
 250
 251 struct lttng_transport {
 252         char *name;
 253         struct cds_list_head node;
 254         struct lttng_ust_channel_buffer_ops ops;
 255         const struct lttng_ust_lib_ring_buffer_config *client_config;
 256 };
 257
 258 struct lttng_counter_transport {
 259         char *name;
 260         struct cds_list_head node;
 261         struct lttng_counter_ops ops;
 262         const struct lib_counter_config *client_config;
 263 };
 264
 265 struct lttng_ust_event_common_private {
 266         struct lttng_ust_event_common *pub;     /* Public event interface */
 267
 268         struct lttng_ust_event_desc *desc;
 269         /* Backward references: list of lttng_enabler_ref (ref to enablers) */
 270         struct cds_list_head enablers_ref_head;
 271         int registered;                         /* has reg'd tracepoint probe */
 272         uint64_t user_token;
 273
 274         int has_enablers_without_filter_bytecode;
 275         /* list of struct lttng_ust_bytecode_runtime, sorted by seqnum */
 276         struct cds_list_head filter_bytecode_runtime_head;
 277 };
 278
 279 struct lttng_ust_event_recorder_private {
 280         struct lttng_ust_event_common_private parent;
 281
 282         struct lttng_ust_event_recorder *pub;   /* Public event interface */
 283         struct cds_list_head node;              /* Event recorder list */
 284         struct cds_hlist_node hlist;            /* Hash table of event recorders */
 285         struct lttng_ust_ctx *ctx;
 286 };
 287
 288 struct lttng_ust_event_notifier_private {
 289         struct lttng_ust_event_common_private parent;
 290
 291         struct lttng_ust_event_notifier *pub;   /* Public event notifier interface */
 292         struct lttng_event_notifier_group *group; /* weak ref */
 293         size_t num_captures;                    /* Needed to allocate the msgpack array. */
 294         uint64_t error_counter_index;
 295         struct cds_list_head node;              /* Event notifier list */
 296         struct cds_hlist_node hlist;            /* Hash table of event notifiers */
 297         struct cds_list_head capture_bytecode_runtime_head;
 298 };
 299
 300 struct lttng_ust_bytecode_runtime {
 301         enum lttng_ust_bytecode_type type;
 302         struct lttng_ust_bytecode_node *bc;
 303         int link_failed;
 304         int (*interpreter_func)(struct lttng_ust_bytecode_runtime *bytecode_runtime,
 305                         const char *interpreter_stack_data,
 306                         void *ctx);
 307         struct cds_list_head node;              /* list of bytecode runtime in event */
 308         /*
 309          * Pointer to a URCU-protected pointer owned by an `struct
 310          * lttng_session`or `struct lttng_event_notifier_group`.
 311          */
 312         struct lttng_ust_ctx **pctx;
 313 };
 314
 315 struct lttng_ust_session_private {
 316         struct lttng_ust_session *pub;          /* Public session interface */
 317
 318         int been_active;                        /* Been active ? */
 319         int objd;                               /* Object associated */
 320         struct cds_list_head chan_head;         /* Channel list head */
 321         struct cds_list_head events_head;       /* list of events */
 322         struct cds_list_head node;              /* Session list */
 323
 324         /* List of enablers */
 325         struct cds_list_head enablers_head;
 326         struct lttng_ust_event_ht events_ht;    /* ht of events */
 327         void *owner;                            /* object owner */
 328         int tstate:1;                           /* Transient enable state */
 329
 330         int statedump_pending:1;
 331
 332         struct lttng_ust_enum_ht enums_ht;      /* ht of enumerations */
 333         struct cds_list_head enums_head;
 334         struct lttng_ust_ctx *ctx;              /* contexts for filters. */
 335
 336         unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
 337         bool uuid_set;                          /* Is uuid set ? */
 338 };
 339
 340 struct lttng_enum {
 341         struct lttng_ust_enum_desc *desc;
 342         struct lttng_ust_session *session;
 343         struct cds_list_head node;              /* Enum list in session */
 344         struct cds_hlist_node hlist;            /* Session ht of enums */
 345         uint64_t id;                            /* Enumeration ID in sessiond */
 346 };
 347
 348 struct lttng_ust_shm_handle;
 349
 350 struct lttng_ust_channel_buffer_ops_private {
 351         struct lttng_ust_channel_buffer_ops *pub;       /* Public channel buffer ops interface */
 352
 353         struct lttng_ust_channel_buffer *(*channel_create)(const char *name,
 354                         void *buf_addr,
 355                         size_t subbuf_size, size_t num_subbuf,
 356                         unsigned int switch_timer_interval,
 357                         unsigned int read_timer_interval,
 358                         unsigned char *uuid,
 359                         uint32_t chan_id,
 360                         const int *stream_fds, int nr_stream_fds,
 361                         int64_t blocking_timeout);
 362         void (*channel_destroy)(struct lttng_ust_channel_buffer *chan);
 363         /*
 364          * packet_avail_size returns the available size in the current
 365          * packet. Note that the size returned is only a hint, since it
 366          * may change due to concurrent writes.
 367          */
 368         size_t (*packet_avail_size)(struct lttng_ust_channel_buffer *chan);
 369         int (*is_finalized)(struct lttng_ust_channel_buffer *chan);
 370         int (*is_disabled)(struct lttng_ust_channel_buffer *chan);
 371         int (*flush_buffer)(struct lttng_ust_channel_buffer *chan);
 372 };
 373
 374 struct lttng_ust_channel_common_private {
 375         struct lttng_ust_channel_common *pub;   /* Public channel interface */
 376
 377         int objd;                               /* Object associated with channel. */
 378         int tstate:1;                           /* Transient enable state */
 379 };
 380
 381 struct lttng_ust_channel_buffer_private {
 382         struct lttng_ust_channel_common_private parent;
 383
 384         struct lttng_ust_channel_buffer *pub;   /* Public channel buffer interface */
 385         struct cds_list_head node;              /* Channel list in session */
 386         int header_type;                        /* 0: unset, 1: compact, 2: large */
 387         unsigned int id;                        /* Channel ID */
 388         enum lttng_ust_abi_chan_type type;
 389         struct lttng_ust_ctx *ctx;
 390         struct lttng_ust_lib_ring_buffer_channel *rb_chan;      /* Ring buffer channel */
 391         unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
 392 };
 393
 394 /*
 395  * IMPORTANT: this structure is part of the ABI between the consumer
 396  * daemon and the UST library within traced applications. Changing it
 397  * breaks the UST communication protocol.
 398  *
 399  * TODO: remove unused fields on next UST communication protocol
 400  * breaking update.
 401  */
 402 struct lttng_ust_abi_channel_config {
 403         void *unused1;
 404         int unused2;
 405         void *unused3;
 406         void *unused4;
 407         int unused5;
 408         struct cds_list_head unused6;
 409         void *unused7;
 410         int unused8;
 411         void *unused9;
 412
 413         /* Channel ID */
 414         unsigned int id;
 415         enum lttng_ust_abi_chan_type unused10;
 416         unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
 417         int unused11:1;
 418 };
 419
 420 static inline
 421 struct lttng_ust_type_integer *lttng_ust_get_type_integer(struct lttng_ust_type_common *type)
 422 {
 423         if (type->type != lttng_ust_type_integer)
 424                 return NULL;
 425         return caa_container_of(type, struct lttng_ust_type_integer, parent);
 426 }
 427
 428 static inline
 429 struct lttng_ust_type_float *lttng_ust_get_type_float(struct lttng_ust_type_common *type)
 430 {
 431         if (type->type != lttng_ust_type_float)
 432                 return NULL;
 433         return caa_container_of(type, struct lttng_ust_type_float, parent);
 434 }
 435
 436 static inline
 437 struct lttng_ust_type_string *lttng_ust_get_type_string(struct lttng_ust_type_common *type)
 438 {
 439         if (type->type != lttng_ust_type_string)
 440                 return NULL;
 441         return caa_container_of(type, struct lttng_ust_type_string, parent);
 442 }
 443
 444 static inline
 445 struct lttng_ust_type_enum *lttng_ust_get_type_enum(struct lttng_ust_type_common *type)
 446 {
 447         if (type->type != lttng_ust_type_enum)
 448                 return NULL;
 449         return caa_container_of(type, struct lttng_ust_type_enum, parent);
 450 }
 451
 452 static inline
 453 struct lttng_ust_type_array *lttng_ust_get_type_array(struct lttng_ust_type_common *type)
 454 {
 455         if (type->type != lttng_ust_type_array)
 456                 return NULL;
 457         return caa_container_of(type, struct lttng_ust_type_array, parent);
 458 }
 459
 460 static inline
 461 struct lttng_ust_type_sequence *lttng_ust_get_type_sequence(struct lttng_ust_type_common *type)
 462 {
 463         if (type->type != lttng_ust_type_sequence)
 464                 return NULL;
 465         return caa_container_of(type, struct lttng_ust_type_sequence, parent);
 466 }
 467
 468 static inline
 469 struct lttng_ust_type_struct *lttng_ust_get_type_struct(struct lttng_ust_type_common *type)
 470 {
 471         if (type->type != lttng_ust_type_struct)
 472                 return NULL;
 473         return caa_container_of(type, struct lttng_ust_type_struct, parent);
 474 }
 475
 476 /* Create dynamically allocated types. */
 477 static inline
 478 struct lttng_ust_type_common *lttng_ust_create_type_integer(unsigned int size,
 479                 unsigned short alignment, bool signedness, unsigned int byte_order,
 480                 unsigned int base)
 481 {
 482         struct lttng_ust_type_integer *integer_type;
 483
 484         integer_type = zmalloc(sizeof(struct lttng_ust_type_integer));
 485         if (!integer_type)
 486                 return NULL;
 487         integer_type->parent.type = lttng_ust_type_integer;
 488         integer_type->struct_size = sizeof(struct lttng_ust_type_integer);
 489         integer_type->size = size;
 490         integer_type->alignment = alignment;
 491         integer_type->signedness = signedness;
 492         integer_type->reverse_byte_order = byte_order != BYTE_ORDER;
 493         integer_type->base = base;
 494         return (struct lttng_ust_type_common *) integer_type;
 495 }
 496
 497 static inline
 498 struct lttng_ust_type_common *lttng_ust_create_type_array_text(unsigned int length)
 499 {
 500         struct lttng_ust_type_array *array_type;
 501
 502         array_type = zmalloc(sizeof(struct lttng_ust_type_array));
 503         if (!array_type)
 504                 return NULL;
 505         array_type->parent.type = lttng_ust_type_array;
 506         array_type->struct_size = sizeof(struct lttng_ust_type_array);
 507         array_type->length = length;
 508         array_type->alignment = 0;
 509         array_type->encoding = lttng_ust_string_encoding_UTF8;
 510         array_type->elem_type = lttng_ust_create_type_integer(sizeof(char) * CHAR_BIT,
 511                         lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char),
 512                         BYTE_ORDER, 10);
 513         if (!array_type->elem_type)
 514                 goto error_elem;
 515         return (struct lttng_ust_type_common *) array_type;
 516
 517 error_elem:
 518         free(array_type);
 519         return NULL;
 520 }
 521
 522 /*
 523  * Destroy dynamically allocated types, including nested types.
 524  * For enumerations, it does not free the enumeration mapping description.
 525  */
 526 static inline
 527 void lttng_ust_destroy_type(struct lttng_ust_type_common *type)
 528 {
 529         if (!type)
 530                 return;
 531
 532         switch (type->type) {
 533         case lttng_ust_type_integer:
 534         case lttng_ust_type_string:
 535         case lttng_ust_type_float:
 536         case lttng_ust_type_dynamic:
 537                 free(type);
 538                 break;
 539         case lttng_ust_type_enum:
 540         {
 541                 struct lttng_ust_type_enum *enum_type = (struct lttng_ust_type_enum *) type;
 542
 543                 lttng_ust_destroy_type(enum_type->container_type);
 544                 free(enum_type);
 545                 break;
 546         }
 547         case lttng_ust_type_array:
 548         {
 549                 struct lttng_ust_type_array *array_type = (struct lttng_ust_type_array *) type;
 550
 551                 lttng_ust_destroy_type(array_type->elem_type);
 552                 free(array_type);
 553                 break;
 554         }
 555         case lttng_ust_type_sequence:
 556         {
 557                 struct lttng_ust_type_sequence *sequence_type = (struct lttng_ust_type_sequence *) type;
 558
 559                 lttng_ust_destroy_type(sequence_type->elem_type);
 560                 free(sequence_type);
 561                 break;
 562         }
 563         case lttng_ust_type_struct:
 564         {
 565                 struct lttng_ust_type_struct *struct_type = (struct lttng_ust_type_struct *) type;
 566                 unsigned int i;
 567
 568                 for (i = 0; i < struct_type->nr_fields; i++)
 569                         lttng_ust_destroy_type(struct_type->fields[i]->type);
 570                 free(struct_type);
 571                 break;
 572         }
 573         default:
 574                 abort();
 575         }
 576 }
 577
 578 static inline
 579 struct lttng_enabler *lttng_event_enabler_as_enabler(
 580                 struct lttng_event_enabler *event_enabler)
 581 {
 582         return &event_enabler->base;
 583 }
 584
 585 static inline
 586 struct lttng_enabler *lttng_event_notifier_enabler_as_enabler(
 587                 struct lttng_event_notifier_enabler *event_notifier_enabler)
 588 {
 589         return &event_notifier_enabler->base;
 590 }
 591
 592 /*
 593  * Allocate and initialize a `struct lttng_event_enabler` object.
 594  *
 595  * On success, returns a `struct lttng_event_enabler`,
 596  * On memory error, returns NULL.
 597  */
 598 __attribute__((visibility("hidden")))
 599 struct lttng_event_enabler *lttng_event_enabler_create(
 600                 enum lttng_enabler_format_type format_type,
 601                 struct lttng_ust_abi_event *event_param,
 602                 struct lttng_ust_channel_buffer *chan);
 603
 604 /*
 605  * Destroy a `struct lttng_event_enabler` object.
 606  */
 607 __attribute__((visibility("hidden")))
 608 void lttng_event_enabler_destroy(struct lttng_event_enabler *enabler);
 609
 610 /*
 611  * Enable a `struct lttng_event_enabler` object and all events related to this
 612  * enabler.
 613  */
 614 __attribute__((visibility("hidden")))
 615 int lttng_event_enabler_enable(struct lttng_event_enabler *enabler);
 616
 617 /*
 618  * Disable a `struct lttng_event_enabler` object and all events related to this
 619  * enabler.
 620  */
 621 __attribute__((visibility("hidden")))
 622 int lttng_event_enabler_disable(struct lttng_event_enabler *enabler);
 623
 624 /*
 625  * Attach filter bytecode program to `struct lttng_event_enabler` and all
 626  * events related to this enabler.
 627  */
 628 __attribute__((visibility("hidden")))
 629 int lttng_event_enabler_attach_filter_bytecode(
 630                 struct lttng_event_enabler *enabler,
 631                 struct lttng_ust_bytecode_node **bytecode);
 632
 633 /*
 634  * Attach an application context to an event enabler.
 635  *
 636  * Not implemented.
 637  */
 638 __attribute__((visibility("hidden")))
 639 int lttng_event_enabler_attach_context(struct lttng_event_enabler *enabler,
 640                 struct lttng_ust_abi_context *ctx);
 641
 642 /*
 643  * Attach exclusion list to `struct lttng_event_enabler` and all
 644  * events related to this enabler.
 645  */
 646 __attribute__((visibility("hidden")))
 647 int lttng_event_enabler_attach_exclusion(struct lttng_event_enabler *enabler,
 648                 struct lttng_ust_excluder_node **excluder);
 649
 650 /*
 651  * Synchronize bytecodes for the enabler and the instance (event or
 652  * event_notifier).
 653  *
 654  * This function goes over all bytecode programs of the enabler (event or
 655  * event_notifier enabler) to ensure each is linked to the provided instance.
 656  */
 657 __attribute__((visibility("hidden")))
 658 void lttng_enabler_link_bytecode(struct lttng_ust_event_desc *event_desc,
 659                 struct lttng_ust_ctx **ctx,
 660                 struct cds_list_head *instance_bytecode_runtime_head,
 661                 struct cds_list_head *enabler_bytecode_runtime_head);
 662
 663 /*
 664  * Allocate and initialize a `struct lttng_event_notifier_group` object.
 665  *
 666  * On success, returns a `struct lttng_triggre_group`,
 667  * on memory error, returns NULL.
 668  */
 669 __attribute__((visibility("hidden")))
 670 struct lttng_event_notifier_group *lttng_event_notifier_group_create(void);
 671
 672 /*
 673  * Destroy a `struct lttng_event_notifier_group` object.
 674  */
 675 __attribute__((visibility("hidden")))
 676 void lttng_event_notifier_group_destroy(
 677                 struct lttng_event_notifier_group *event_notifier_group);
 678
 679 /*
 680  * Allocate and initialize a `struct lttng_event_notifier_enabler` object.
 681  *
 682  * On success, returns a `struct lttng_event_notifier_enabler`,
 683  * On memory error, returns NULL.
 684  */
 685 __attribute__((visibility("hidden")))
 686 struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
 687                 struct lttng_event_notifier_group *event_notifier_group,
 688                 enum lttng_enabler_format_type format_type,
 689                 struct lttng_ust_abi_event_notifier *event_notifier_param);
 690
 691 /*
 692  * Destroy a `struct lttng_event_notifier_enabler` object.
 693  */
 694 __attribute__((visibility("hidden")))
 695 void lttng_event_notifier_enabler_destroy(
 696                 struct lttng_event_notifier_enabler *event_notifier_enabler);
 697
 698 /*
 699  * Enable a `struct lttng_event_notifier_enabler` object and all event
 700  * notifiers related to this enabler.
 701  */
 702 __attribute__((visibility("hidden")))
 703 int lttng_event_notifier_enabler_enable(
 704                 struct lttng_event_notifier_enabler *event_notifier_enabler);
 705
 706 /*
 707  * Disable a `struct lttng_event_notifier_enabler` object and all event
 708  * notifiers related to this enabler.
 709  */
 710 __attribute__((visibility("hidden")))
 711 int lttng_event_notifier_enabler_disable(
 712                 struct lttng_event_notifier_enabler *event_notifier_enabler);
 713
 714 /*
 715  * Attach filter bytecode program to `struct lttng_event_notifier_enabler` and
 716  * all event notifiers related to this enabler.
 717  */
 718 __attribute__((visibility("hidden")))
 719 int lttng_event_notifier_enabler_attach_filter_bytecode(
 720                 struct lttng_event_notifier_enabler *event_notifier_enabler,
 721                 struct lttng_ust_bytecode_node **bytecode);
 722
 723 /*
 724  * Attach capture bytecode program to `struct lttng_event_notifier_enabler` and
 725  * all event_notifiers related to this enabler.
 726  */
 727 __attribute__((visibility("hidden")))
 728 int lttng_event_notifier_enabler_attach_capture_bytecode(
 729                 struct lttng_event_notifier_enabler *event_notifier_enabler,
 730                 struct lttng_ust_bytecode_node **bytecode);
 731
 732 /*
 733  * Attach exclusion list to `struct lttng_event_notifier_enabler` and all
 734  * event notifiers related to this enabler.
 735  */
 736 __attribute__((visibility("hidden")))
 737 int lttng_event_notifier_enabler_attach_exclusion(
 738                 struct lttng_event_notifier_enabler *event_notifier_enabler,
 739                 struct lttng_ust_excluder_node **excluder);
 740
 741 __attribute__((visibility("hidden")))
 742 void lttng_free_event_filter_runtime(struct lttng_ust_event_common *event);
 743
 744 /*
 745  * Connect the probe on all enablers matching this event description.
 746  * Called on library load.
 747  */
 748 __attribute__((visibility("hidden")))
 749 int lttng_fix_pending_event_notifiers(void);
 750
 751 __attribute__((visibility("hidden")))
 752 struct lttng_counter *lttng_ust_counter_create(
 753                 const char *counter_transport_name,
 754                 size_t number_dimensions, const struct lttng_counter_dimension *dimensions);
 755
 756 #ifdef HAVE_LINUX_PERF_EVENT_H
 757
 758 __attribute__((visibility("hidden")))
 759 int lttng_add_perf_counter_to_ctx(uint32_t type,
 760                                   uint64_t config,
 761                                   const char *name,
 762                                   struct lttng_ust_ctx **ctx);
 763
 764 __attribute__((visibility("hidden")))
 765 int lttng_perf_counter_init(void);
 766
 767 __attribute__((visibility("hidden")))
 768 void lttng_perf_counter_exit(void);
 769
 770 #else /* #ifdef HAVE_LINUX_PERF_EVENT_H */
 771
 772 static inline
 773 int lttng_add_perf_counter_to_ctx(uint32_t type,
 774                                   uint64_t config,
 775                                   const char *name,
 776                                   struct lttng_ust_ctx **ctx)
 777 {
 778         return -ENOSYS;
 779 }
 780 static inline
 781 int lttng_perf_counter_init(void)
 782 {
 783         return 0;
 784 }
 785 static inline
 786 void lttng_perf_counter_exit(void)
 787 {
 788 }
 789 #endif /* #else #ifdef HAVE_LINUX_PERF_EVENT_H */
 790
 791 __attribute__((visibility("hidden")))
 792 int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list *list);
 793
 794 __attribute__((visibility("hidden")))
 795 void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list *list);
 796
 797 __attribute__((visibility("hidden")))
 798 int lttng_probes_get_field_list(struct lttng_ust_field_list *list);
 799
 800 __attribute__((visibility("hidden")))
 801 void lttng_probes_prune_field_list(struct lttng_ust_field_list *list);
 802
 803 __attribute__((visibility("hidden")))
 804 struct lttng_ust_abi_tracepoint_iter *
 805         lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list);
 806
 807 __attribute__((visibility("hidden")))
 808 struct lttng_ust_abi_field_iter *
 809         lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list);
 810
 811 __attribute__((visibility("hidden")))
 812 struct lttng_ust_session *lttng_session_create(void);
 813
 814 __attribute__((visibility("hidden")))
 815 int lttng_session_enable(struct lttng_ust_session *session);
 816
 817 __attribute__((visibility("hidden")))
 818 int lttng_session_disable(struct lttng_ust_session *session);
 819
 820 __attribute__((visibility("hidden")))
 821 int lttng_session_statedump(struct lttng_ust_session *session);
 822
 823 __attribute__((visibility("hidden")))
 824 void lttng_session_destroy(struct lttng_ust_session *session);
 825
 826 /*
 827  * Called with ust lock held.
 828  */
 829 __attribute__((visibility("hidden")))
 830 int lttng_session_active(void);
 831
 832 __attribute__((visibility("hidden")))
 833 struct cds_list_head *lttng_get_sessions(void);
 834
 835 __attribute__((visibility("hidden")))
 836 void lttng_handle_pending_statedump(void *owner);
 837
 838 __attribute__((visibility("hidden")))
 839 int lttng_channel_enable(struct lttng_ust_channel_common *lttng_channel);
 840
 841 __attribute__((visibility("hidden")))
 842 int lttng_channel_disable(struct lttng_ust_channel_common *lttng_channel);
 843
 844 __attribute__((visibility("hidden")))
 845 void lttng_transport_register(struct lttng_transport *transport);
 846
 847 __attribute__((visibility("hidden")))
 848 void lttng_transport_unregister(struct lttng_transport *transport);
 849
 850 /* This is ABI between liblttng-ust and liblttng-ust-ctl */
 851 struct lttng_transport *lttng_ust_transport_find(const char *name);
 852
 853 /* This is ABI between liblttng-ust and liblttng-ust-dl */
 854 void lttng_ust_dl_update(void *ip);
 855
 856 __attribute__((visibility("hidden")))
 857 void lttng_probe_provider_unregister_events(struct lttng_ust_probe_desc *desc);
 858
 859 __attribute__((visibility("hidden")))
 860 int lttng_fix_pending_events(void);
 861
 862 __attribute__((visibility("hidden")))
 863 struct cds_list_head *lttng_get_probe_list_head(void);
 864
 865 __attribute__((visibility("hidden")))
 866 struct lttng_enum *lttng_ust_enum_get_from_desc(struct lttng_ust_session *session,
 867                 struct lttng_ust_enum_desc *enum_desc);
 868
 869 __attribute__((visibility("hidden")))
 870 int lttng_abi_create_root_handle(void);
 871
 872 __attribute__((visibility("hidden")))
 873 const struct lttng_ust_abi_objd_ops *lttng_ust_abi_objd_ops(int id);
 874
 875 __attribute__((visibility("hidden")))
 876 int lttng_ust_abi_objd_unref(int id, int is_owner);
 877
 878 __attribute__((visibility("hidden")))
 879 void lttng_ust_abi_exit(void);
 880
 881 __attribute__((visibility("hidden")))
 882 void lttng_ust_abi_events_exit(void);
 883
 884 __attribute__((visibility("hidden")))
 885 void lttng_ust_abi_objd_table_owner_cleanup(void *owner);
 886
 887 __attribute__((visibility("hidden")))
 888 struct lttng_ust_channel_buffer *lttng_ust_alloc_channel_buffer(void);
 889
 890 __attribute__((visibility("hidden")))
 891 void lttng_ust_free_channel_common(struct lttng_ust_channel_common *chan);
 892
 893 __attribute__((visibility("hidden")))
 894 int lttng_ust_interpret_event_filter(struct lttng_ust_event_common *event,
 895                 const char *interpreter_stack_data,
 896                 void *filter_ctx);
 897
 898 __attribute__((visibility("hidden")))
 899 int lttng_ust_session_uuid_validate(struct lttng_ust_session *session,
 900                 unsigned char *uuid);
 901
 902 __attribute__((visibility("hidden")))
 903 bool lttng_ust_validate_event_name(const struct lttng_ust_event_desc *desc);
 904
 905 __attribute__((visibility("hidden")))
 906 void lttng_ust_format_event_name(const struct lttng_ust_event_desc *desc,
 907                 char *name);
 908
 909 #endif /* _LTTNG_UST_EVENTS_INTERNAL_H */