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