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