liblttng-ust/lttng-events.c

   1 /*
   2  * SPDX-License-Identifier: LGPL-2.1-only
   3  *
   4  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Holds LTTng per-session event registry.
   7  */
   8
   9 #define _LGPL_SOURCE
  10 #include <stdio.h>
  11 #include <assert.h>
  12 #include <errno.h>
  13 #include <limits.h>
  14 #include <pthread.h>
  15 #include <sys/shm.h>
  16 #include <sys/ipc.h>
  17 #include <stdint.h>
  18 #include <stddef.h>
  19 #include <inttypes.h>
  20 #include <time.h>
  21 #include <stdbool.h>
  22 #include <unistd.h>
  23 #include <dlfcn.h>
  24 #include <lttng/ust-endian.h>
  25
  26 #include <urcu/arch.h>
  27 #include <urcu/compiler.h>
  28 #include <urcu/hlist.h>
  29 #include <urcu/list.h>
  30 #include <urcu/uatomic.h>
  31
  32 #include <lttng/tracepoint.h>
  33 #include <lttng/ust-events.h>
  34
  35 #include <usterr-signal-safe.h>
  36 #include <helper.h>
  37 #include <lttng/ust-ctl.h>
  38 #include <ust-comm.h>
  39 #include <ust-fd.h>
  40 #include <lttng/ust-dynamic-type.h>
  41 #include <lttng/ust-context-provider.h>
  42 #include "error.h"
  43 #include "compat.h"
  44 #include "lttng-ust-uuid.h"
  45
  46 #include "tracepoint-internal.h"
  47 #include "string-utils.h"
  48 #include "lttng-bytecode.h"
  49 #include "lttng-tracer.h"
  50 #include "lttng-tracer-core.h"
  51 #include "lttng-ust-statedump.h"
  52 #include "context-internal.h"
  53 #include "ust-events-internal.h"
  54 #include "wait.h"
  55 #include "../libringbuffer/shm.h"
  56 #include "../libcounter/counter.h"
  57 #include "jhash.h"
  58 #include <lttng/ust-abi.h>
  59
  60 /*
  61  * All operations within this file are called by the communication
  62  * thread, under ust_lock protection.
  63  */
  64
  65 static CDS_LIST_HEAD(sessions);
  66 static CDS_LIST_HEAD(event_notifier_groups);
  67
  68 struct cds_list_head *_lttng_get_sessions(void)
  69 {
  70         return &sessions;
  71 }
  72
  73 static void _lttng_event_destroy(struct lttng_event *event);
  74 static void _lttng_event_notifier_destroy(
  75                 struct lttng_event_notifier *event_notifier);
  76 static void _lttng_enum_destroy(struct lttng_enum *_enum);
  77
  78 static
  79 void lttng_session_lazy_sync_event_enablers(struct lttng_session *session);
  80 static
  81 void lttng_session_sync_event_enablers(struct lttng_session *session);
  82 static
  83 void lttng_event_notifier_group_sync_enablers(
  84                 struct lttng_event_notifier_group *event_notifier_group);
  85 static
  86 void lttng_enabler_destroy(struct lttng_enabler *enabler);
  87
  88 /*
  89  * @buf must hold at least LTTNG_UST_SYM_NAME_LEN bytes.
  90  */
  91 static
  92 int lttng_split_provider_event_name(const char *full_name,
  93                 char *buf, const char **event_name,
  94                 const char **provider_name)
  95 {
  96         char *saveptr;
  97
  98         if (strlen(full_name) >= LTTNG_UST_SYM_NAME_LEN)
  99                 return -1;
 100         strcpy(buf, full_name);
 101         *provider_name = strtok_r(buf, ":", &saveptr);  /* Stops at ':' or '\0'. */
 102         if (!provider_name)
 103                 return -1;
 104         *event_name = strtok_r(NULL, ":", &saveptr);    /* Stops at ':' or '\0'. */
 105         if (!event_name)
 106                 return -1;
 107         /*
 108          * Ensure we don't have leftover characters. Stops at '\0'. It validates
 109          * that neither the provider nor event name contain ':'.
 110          */
 111         if (strtok_r(NULL, "", &saveptr))
 112                 return -1;
 113         return 0;
 114 }
 115
 116 /*
 117  * Called with ust lock held.
 118  */
 119 int lttng_session_active(void)
 120 {
 121         struct lttng_session *iter;
 122
 123         cds_list_for_each_entry(iter, &sessions, node) {
 124                 if (iter->active)
 125                         return 1;
 126         }
 127         return 0;
 128 }
 129
 130 static
 131 int lttng_loglevel_match(int loglevel,
 132                 unsigned int has_loglevel,
 133                 enum lttng_ust_loglevel_type req_type,
 134                 int req_loglevel)
 135 {
 136         if (!has_loglevel)
 137                 loglevel = TRACE_DEFAULT;
 138         switch (req_type) {
 139         case LTTNG_UST_LOGLEVEL_RANGE:
 140                 if (loglevel <= req_loglevel
 141                                 || (req_loglevel == -1 && loglevel <= TRACE_DEBUG))
 142                         return 1;
 143                 else
 144                         return 0;
 145         case LTTNG_UST_LOGLEVEL_SINGLE:
 146                 if (loglevel == req_loglevel
 147                                 || (req_loglevel == -1 && loglevel <= TRACE_DEBUG))
 148                         return 1;
 149                 else
 150                         return 0;
 151         case LTTNG_UST_LOGLEVEL_ALL:
 152         default:
 153                 if (loglevel <= TRACE_DEBUG)
 154                         return 1;
 155                 else
 156                         return 0;
 157         }
 158 }
 159
 160 struct lttng_session *lttng_session_create(void)
 161 {
 162         struct lttng_session *session;
 163         int i;
 164
 165         session = zmalloc(sizeof(struct lttng_session));
 166         if (!session)
 167                 return NULL;
 168         if (lttng_context_init_all(&session->ctx)) {
 169                 free(session);
 170                 return NULL;
 171         }
 172         CDS_INIT_LIST_HEAD(&session->chan_head);
 173         CDS_INIT_LIST_HEAD(&session->events_head);
 174         CDS_INIT_LIST_HEAD(&session->enums_head);
 175         CDS_INIT_LIST_HEAD(&session->enablers_head);
 176         CDS_INIT_LIST_HEAD(&session->counters);
 177         for (i = 0; i < LTTNG_UST_EVENT_HT_SIZE; i++)
 178                 CDS_INIT_HLIST_HEAD(&session->events_name_ht.table[i]);
 179         for (i = 0; i < LTTNG_UST_EVENT_HT_SIZE; i++)
 180                 CDS_INIT_HLIST_HEAD(&session->enums_ht.table[i]);
 181         cds_list_add(&session->node, &sessions);
 182         return session;
 183 }
 184
 185 struct lttng_counter *lttng_ust_counter_create(
 186                 const char *counter_transport_name,
 187                 size_t number_dimensions,
 188                 const size_t *max_nr_elem,
 189                 int64_t global_sum_step,
 190                 bool coalesce_hits)
 191 {
 192         struct lttng_counter_transport *counter_transport = NULL;
 193         struct lttng_counter *counter = NULL;
 194
 195         counter_transport = lttng_counter_transport_find(counter_transport_name);
 196         if (!counter_transport)
 197                 goto notransport;
 198         counter = zmalloc(sizeof(struct lttng_counter));
 199         if (!counter)
 200                 goto nomem;
 201
 202         counter->ops = &counter_transport->ops;
 203         counter->transport = counter_transport;
 204
 205         counter->counter = counter->ops->counter_create(
 206                         number_dimensions, max_nr_elem, global_sum_step,
 207                         -1, 0, NULL, false);
 208         if (!counter->counter) {
 209                 goto create_error;
 210         }
 211         counter->parent.coalesce_hits = coalesce_hits;
 212
 213         return counter;
 214
 215 create_error:
 216         free(counter);
 217 nomem:
 218 notransport:
 219         return NULL;
 220 }
 221
 222 static
 223 void lttng_ust_counter_destroy(struct lttng_counter *counter)
 224 {
 225         counter->ops->counter_destroy(counter->counter);
 226         free(counter);
 227 }
 228
 229 struct lttng_counter *lttng_session_create_counter(
 230         struct lttng_session *session,
 231         const char *counter_transport_name,
 232         size_t number_dimensions, const size_t *dimensions_sizes,
 233         int64_t global_sum_step, bool coalesce_hits)
 234 {
 235         struct lttng_counter *counter;
 236         struct lttng_event_container *container;
 237
 238         counter = lttng_ust_counter_create(counter_transport_name,
 239                         number_dimensions, dimensions_sizes, global_sum_step,
 240                         coalesce_hits);
 241         if (!counter) {
 242                 goto counter_error;
 243         }
 244         container = lttng_counter_get_event_container(counter);
 245         container->type = LTTNG_EVENT_CONTAINER_COUNTER;
 246
 247         container->session = session;
 248         cds_list_add(&counter->node, &session->counters);
 249
 250         return counter;
 251
 252 counter_error:
 253         return NULL;
 254 }
 255
 256 struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
 257 {
 258         struct lttng_event_notifier_group *event_notifier_group;
 259         int i;
 260
 261         event_notifier_group = zmalloc(sizeof(struct lttng_event_notifier_group));
 262         if (!event_notifier_group)
 263                 return NULL;
 264
 265         /* Add all contexts. */
 266         if (lttng_context_init_all(&event_notifier_group->ctx)) {
 267                 free(event_notifier_group);
 268                 return NULL;
 269         }
 270
 271         CDS_INIT_LIST_HEAD(&event_notifier_group->enablers_head);
 272         CDS_INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
 273         for (i = 0; i < LTTNG_UST_EVENT_NOTIFIER_HT_SIZE; i++)
 274                 CDS_INIT_HLIST_HEAD(&event_notifier_group->event_notifiers_ht.table[i]);
 275
 276         cds_list_add(&event_notifier_group->node, &event_notifier_groups);
 277
 278         return event_notifier_group;
 279 }
 280
 281 /*
 282  * Only used internally at session destruction.
 283  */
 284 static
 285 void _lttng_channel_unmap(struct lttng_channel *lttng_chan)
 286 {
 287         struct channel *chan;
 288         struct lttng_ust_shm_handle *handle;
 289
 290         cds_list_del(&lttng_chan->node);
 291         lttng_destroy_context(lttng_chan->ctx);
 292         chan = lttng_chan->chan;
 293         handle = lttng_chan->handle;
 294         /*
 295          * note: lttng_chan is private data contained within handle. It
 296          * will be freed along with the handle.
 297          */
 298         channel_destroy(chan, handle, 0);
 299 }
 300
 301 static
 302 void register_event(struct lttng_event *event)
 303 {
 304         int ret;
 305         const struct lttng_event_desc *desc;
 306
 307         assert(event->registered == 0);
 308         desc = event->desc;
 309         ret = __tracepoint_probe_register_queue_release(desc->name,
 310                         desc->probe_callback,
 311                         event, desc->signature);
 312         WARN_ON_ONCE(ret);
 313         if (!ret)
 314                 event->registered = 1;
 315 }
 316
 317 static
 318 void register_event_notifier(struct lttng_event_notifier *event_notifier)
 319 {
 320         int ret;
 321         const struct lttng_event_desc *desc;
 322
 323         assert(event_notifier->registered == 0);
 324         desc = event_notifier->desc;
 325         ret = __tracepoint_probe_register_queue_release(desc->name,
 326                 desc->u.ext.event_notifier_callback, event_notifier, desc->signature);
 327         WARN_ON_ONCE(ret);
 328         if (!ret)
 329                 event_notifier->registered = 1;
 330 }
 331
 332 static
 333 void unregister_event(struct lttng_event *event)
 334 {
 335         int ret;
 336         const struct lttng_event_desc *desc;
 337
 338         assert(event->registered == 1);
 339         desc = event->desc;
 340         ret = __tracepoint_probe_unregister_queue_release(desc->name,
 341                         desc->probe_callback,
 342                         event);
 343         WARN_ON_ONCE(ret);
 344         if (!ret)
 345                 event->registered = 0;
 346 }
 347
 348 static
 349 void unregister_event_notifier(struct lttng_event_notifier *event_notifier)
 350 {
 351         int ret;
 352         const struct lttng_event_desc *desc;
 353
 354         assert(event_notifier->registered == 1);
 355         desc = event_notifier->desc;
 356         ret = __tracepoint_probe_unregister_queue_release(desc->name,
 357                 desc->u.ext.event_notifier_callback, event_notifier);
 358         WARN_ON_ONCE(ret);
 359         if (!ret)
 360                 event_notifier->registered = 0;
 361 }
 362
 363 /*
 364  * Only used internally at session destruction.
 365  */
 366 static
 367 void _lttng_event_unregister(struct lttng_event *event)
 368 {
 369         if (event->registered)
 370                 unregister_event(event);
 371 }
 372
 373 /*
 374  * Only used internally at session destruction.
 375  */
 376 static
 377 void _lttng_event_notifier_unregister(struct lttng_event_notifier *event_notifier)
 378 {
 379         if (event_notifier->registered)
 380                 unregister_event_notifier(event_notifier);
 381 }
 382
 383 void lttng_session_destroy(struct lttng_session *session)
 384 {
 385         struct lttng_channel *chan, *tmpchan;
 386         struct lttng_event *event, *tmpevent;
 387         struct lttng_enum *_enum, *tmp_enum;
 388         struct lttng_event_enabler *event_enabler, *event_tmpenabler;
 389
 390         CMM_ACCESS_ONCE(session->active) = 0;
 391         cds_list_for_each_entry(event, &session->events_head, node) {
 392                 _lttng_event_unregister(event);
 393         }
 394         lttng_ust_synchronize_trace();  /* Wait for in-flight events to complete */
 395         __tracepoint_probe_prune_release_queue();
 396         cds_list_for_each_entry_safe(event_enabler, event_tmpenabler,
 397                         &session->enablers_head, node)
 398                 lttng_event_enabler_destroy(event_enabler);
 399         cds_list_for_each_entry_safe(event, tmpevent,
 400                         &session->events_head, node)
 401                 _lttng_event_destroy(event);
 402         cds_list_for_each_entry_safe(_enum, tmp_enum,
 403                         &session->enums_head, node)
 404                 _lttng_enum_destroy(_enum);
 405         cds_list_for_each_entry_safe(chan, tmpchan, &session->chan_head, node)
 406                 _lttng_channel_unmap(chan);
 407         cds_list_del(&session->node);
 408         lttng_destroy_context(session->ctx);
 409         free(session);
 410 }
 411
 412 void lttng_event_notifier_group_destroy(
 413                 struct lttng_event_notifier_group *event_notifier_group)
 414 {
 415         int close_ret;
 416         struct lttng_event_notifier_enabler *notifier_enabler, *tmpnotifier_enabler;
 417         struct lttng_event_notifier *notifier, *tmpnotifier;
 418
 419         if (!event_notifier_group) {
 420                 return;
 421         }
 422
 423         cds_list_for_each_entry(notifier,
 424                         &event_notifier_group->event_notifiers_head, node)
 425                 _lttng_event_notifier_unregister(notifier);
 426
 427         lttng_ust_synchronize_trace();
 428
 429         cds_list_for_each_entry_safe(notifier_enabler, tmpnotifier_enabler,
 430                         &event_notifier_group->enablers_head, node)
 431                 lttng_event_notifier_enabler_destroy(notifier_enabler);
 432
 433         cds_list_for_each_entry_safe(notifier, tmpnotifier,
 434                         &event_notifier_group->event_notifiers_head, node)
 435                 _lttng_event_notifier_destroy(notifier);
 436
 437         if (event_notifier_group->error_counter)
 438                 lttng_ust_counter_destroy(event_notifier_group->error_counter);
 439
 440         /* Close the notification fd to the listener of event_notifiers. */
 441
 442         lttng_ust_lock_fd_tracker();
 443         close_ret = close(event_notifier_group->notification_fd);
 444         if (!close_ret) {
 445                 lttng_ust_delete_fd_from_tracker(
 446                                 event_notifier_group->notification_fd);
 447         } else {
 448                 PERROR("close");
 449                 abort();
 450         }
 451         lttng_ust_unlock_fd_tracker();
 452
 453         cds_list_del(&event_notifier_group->node);
 454
 455         free(event_notifier_group);
 456 }
 457
 458 static
 459 void lttng_enabler_destroy(struct lttng_enabler *enabler)
 460 {
 461         struct lttng_ust_bytecode_node *filter_node, *tmp_filter_node;
 462         struct lttng_ust_excluder_node *excluder_node, *tmp_excluder_node;
 463
 464         if (!enabler) {
 465                 return;
 466         }
 467
 468         /* Destroy filter bytecode */
 469         cds_list_for_each_entry_safe(filter_node, tmp_filter_node,
 470                         &enabler->filter_bytecode_head, node) {
 471                 free(filter_node);
 472         }
 473
 474         /* Destroy excluders */
 475         cds_list_for_each_entry_safe(excluder_node, tmp_excluder_node,
 476                         &enabler->excluder_head, node) {
 477                 free(excluder_node);
 478         }
 479 }
 480
 481  void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler)
 482 {
 483         if (!event_notifier_enabler) {
 484                 return;
 485         }
 486
 487         cds_list_del(&event_notifier_enabler->node);
 488
 489         lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
 490
 491         free(event_notifier_enabler);
 492 }
 493
 494 static
 495 int lttng_enum_create(const struct lttng_enum_desc *desc,
 496                 struct lttng_session *session)
 497 {
 498         const char *enum_name = desc->name;
 499         struct lttng_enum *_enum;
 500         struct cds_hlist_head *head;
 501         int ret = 0;
 502         size_t name_len = strlen(enum_name);
 503         uint32_t hash;
 504         int notify_socket;
 505
 506         /* Check if this enum is already registered for this session. */
 507         hash = jhash(enum_name, name_len, 0);
 508         head = &session->enums_ht.table[hash & (LTTNG_UST_ENUM_HT_SIZE - 1)];
 509
 510         _enum = lttng_ust_enum_get_from_desc(session, desc);
 511         if (_enum) {
 512                 ret = -EEXIST;
 513                 goto exist;
 514         }
 515
 516         notify_socket = lttng_get_notify_socket(session->owner);
 517         if (notify_socket < 0) {
 518                 ret = notify_socket;
 519                 goto socket_error;
 520         }
 521
 522         _enum = zmalloc(sizeof(*_enum));
 523         if (!_enum) {
 524                 ret = -ENOMEM;
 525                 goto cache_error;
 526         }
 527         _enum->session = session;
 528         _enum->desc = desc;
 529
 530         ret = ustcomm_register_enum(notify_socket,
 531                 session->objd,
 532                 enum_name,
 533                 desc->nr_entries,
 534                 desc->entries,
 535                 &_enum->id);
 536         if (ret < 0) {
 537                 DBG("Error (%d) registering enumeration to sessiond", ret);
 538                 goto sessiond_register_error;
 539         }
 540         cds_list_add(&_enum->node, &session->enums_head);
 541         cds_hlist_add_head(&_enum->hlist, head);
 542         return 0;
 543
 544 sessiond_register_error:
 545         free(_enum);
 546 cache_error:
 547 socket_error:
 548 exist:
 549         return ret;
 550 }
 551
 552 static
 553 int lttng_create_enum_check(const struct lttng_type *type,
 554                 struct lttng_session *session)
 555 {
 556         switch (type->atype) {
 557         case atype_enum:
 558         {
 559                 const struct lttng_enum_desc *enum_desc;
 560                 int ret;
 561
 562                 enum_desc = type->u.legacy.basic.enumeration.desc;
 563                 ret = lttng_enum_create(enum_desc, session);
 564                 if (ret && ret != -EEXIST) {
 565                         DBG("Unable to create enum error: (%d)", ret);
 566                         return ret;
 567                 }
 568                 break;
 569         }
 570         case atype_enum_nestable:
 571         {
 572                 const struct lttng_enum_desc *enum_desc;
 573                 int ret;
 574
 575                 enum_desc = type->u.enum_nestable.desc;
 576                 ret = lttng_enum_create(enum_desc, session);
 577                 if (ret && ret != -EEXIST) {
 578                         DBG("Unable to create enum error: (%d)", ret);
 579                         return ret;
 580                 }
 581                 break;
 582         }
 583         case atype_dynamic:
 584         {
 585                 const struct lttng_event_field *tag_field_generic;
 586                 const struct lttng_enum_desc *enum_desc;
 587                 int ret;
 588
 589                 tag_field_generic = lttng_ust_dynamic_type_tag_field();
 590                 enum_desc = tag_field_generic->type.u.enum_nestable.desc;
 591                 ret = lttng_enum_create(enum_desc, session);
 592                 if (ret && ret != -EEXIST) {
 593                         DBG("Unable to create enum error: (%d)", ret);
 594                         return ret;
 595                 }
 596                 break;
 597         }
 598         default:
 599                 /* TODO: nested types when they become supported. */
 600                 break;
 601         }
 602         return 0;
 603 }
 604
 605 static
 606 int lttng_create_all_event_enums(size_t nr_fields,
 607                 const struct lttng_event_field *event_fields,
 608                 struct lttng_session *session)
 609 {
 610         size_t i;
 611         int ret;
 612
 613         /* For each field, ensure enum is part of the session. */
 614         for (i = 0; i < nr_fields; i++) {
 615                 const struct lttng_type *type = &event_fields[i].type;
 616
 617                 ret = lttng_create_enum_check(type, session);
 618                 if (ret)
 619                         return ret;
 620         }
 621         return 0;
 622 }
 623
 624 static
 625 int lttng_create_all_ctx_enums(size_t nr_fields,
 626                 const struct lttng_ctx_field *ctx_fields,
 627                 struct lttng_session *session)
 628 {
 629         size_t i;
 630         int ret;
 631
 632         /* For each field, ensure enum is part of the session. */
 633         for (i = 0; i < nr_fields; i++) {
 634                 const struct lttng_type *type = &ctx_fields[i].event_field.type;
 635
 636                 ret = lttng_create_enum_check(type, session);
 637                 if (ret)
 638                         return ret;
 639         }
 640         return 0;
 641 }
 642
 643 /*
 644  * Ensure that a state-dump will be performed for this session at the end
 645  * of the current handle_message().
 646  */
 647 int lttng_session_statedump(struct lttng_session *session)
 648 {
 649         session->statedump_pending = 1;
 650         lttng_ust_sockinfo_session_enabled(session->owner);
 651         return 0;
 652 }
 653
 654 int lttng_session_enable(struct lttng_session *session)
 655 {
 656         int ret = 0;
 657         struct lttng_channel *chan;
 658         int notify_socket;
 659
 660         if (session->active) {
 661                 ret = -EBUSY;
 662                 goto end;
 663         }
 664
 665         notify_socket = lttng_get_notify_socket(session->owner);
 666         if (notify_socket < 0)
 667                 return notify_socket;
 668
 669         /* Set transient enabler state to "enabled" */
 670         session->tstate = 1;
 671
 672         /* We need to sync enablers with session before activation. */
 673         lttng_session_sync_event_enablers(session);
 674
 675         /*
 676          * Snapshot the number of events per channel to know the type of header
 677          * we need to use.
 678          */
 679         cds_list_for_each_entry(chan, &session->chan_head, node) {
 680                 const struct lttng_ctx *ctx;
 681                 const struct lttng_ctx_field *fields = NULL;
 682                 size_t nr_fields = 0;
 683                 uint32_t chan_id;
 684
 685                 /* don't change it if session stop/restart */
 686                 if (chan->header_type)
 687                         continue;
 688                 ctx = chan->ctx;
 689                 if (ctx) {
 690                         nr_fields = ctx->nr_fields;
 691                         fields = ctx->fields;
 692                         ret = lttng_create_all_ctx_enums(nr_fields, fields,
 693                                 session);
 694                         if (ret < 0) {
 695                                 DBG("Error (%d) adding enum to session", ret);
 696                                 return ret;
 697                         }
 698                 }
 699                 ret = ustcomm_register_channel(notify_socket,
 700                         session,
 701                         session->objd,
 702                         chan->parent.objd,
 703                         nr_fields,
 704                         fields,
 705                         &chan_id,
 706                         &chan->header_type);
 707                 if (ret) {
 708                         DBG("Error (%d) registering channel to sessiond", ret);
 709                         return ret;
 710                 }
 711                 if (chan_id != chan->id) {
 712                         DBG("Error: channel registration id (%u) does not match id assigned at creation (%u)",
 713                                 chan_id, chan->id);
 714                         return -EINVAL;
 715                 }
 716         }
 717
 718         /* Set atomically the state to "active" */
 719         CMM_ACCESS_ONCE(session->active) = 1;
 720         CMM_ACCESS_ONCE(session->been_active) = 1;
 721
 722         ret = lttng_session_statedump(session);
 723         if (ret)
 724                 return ret;
 725 end:
 726         return ret;
 727 }
 728
 729 int lttng_session_disable(struct lttng_session *session)
 730 {
 731         int ret = 0;
 732
 733         if (!session->active) {
 734                 ret = -EBUSY;
 735                 goto end;
 736         }
 737         /* Set atomically the state to "inactive" */
 738         CMM_ACCESS_ONCE(session->active) = 0;
 739
 740         /* Set transient enabler state to "disabled" */
 741         session->tstate = 0;
 742         lttng_session_sync_event_enablers(session);
 743 end:
 744         return ret;
 745 }
 746
 747 int lttng_event_container_enable(struct lttng_event_container *container)
 748 {
 749         int ret = 0;
 750
 751         if (container->enabled) {
 752                 ret = -EBUSY;
 753                 goto end;
 754         }
 755         /* Set transient enabler state to "enabled" */
 756         container->tstate = 1;
 757         lttng_session_sync_event_enablers(container->session);
 758         /* Atomically set the state to "enabled" */
 759         switch (container->type) {
 760         case LTTNG_EVENT_CONTAINER_CHANNEL:
 761         {
 762                 struct lttng_channel *channel = caa_container_of(container,
 763                         struct lttng_channel, parent);
 764
 765                 CMM_ACCESS_ONCE(channel->enabled) = 1;  /* Backward compatibility */
 766                 break;
 767         }
 768         default:
 769                 break;
 770         }
 771         CMM_ACCESS_ONCE(container->enabled) = 1;
 772 end:
 773         return ret;
 774 }
 775
 776 int lttng_event_container_disable(struct lttng_event_container *container)
 777 {
 778         int ret = 0;
 779
 780         if (!container->enabled) {
 781                 ret = -EBUSY;
 782                 goto end;
 783         }
 784         /* Atomically set the state to "disabled" */
 785         CMM_ACCESS_ONCE(container->enabled) = 0;
 786         switch (container->type) {
 787         case LTTNG_EVENT_CONTAINER_CHANNEL:
 788         {
 789                 struct lttng_channel *channel = caa_container_of(container,
 790                         struct lttng_channel, parent);
 791
 792                 CMM_ACCESS_ONCE(channel->enabled) = 0;  /* Backward compatibility */
 793                 break;
 794         }
 795         default:
 796                 break;
 797         }
 798         /* Set transient enabler state to "enabled" */
 799         container->tstate = 0;
 800         lttng_session_sync_event_enablers(container->session);
 801 end:
 802         return ret;
 803 }
 804
 805 static inline
 806 struct cds_hlist_head *borrow_hash_table_bucket(
 807                 struct cds_hlist_head *hash_table,
 808                 unsigned int hash_table_size,
 809                 const char *name)
 810 {
 811         size_t name_len;
 812         uint32_t hash;
 813
 814         name_len = strlen(name);
 815
 816         hash = jhash(name, name_len, 0);
 817         return &hash_table[hash & (hash_table_size - 1)];
 818 }
 819
 820 static
 821 int format_event_key(char *key_string, const struct lttng_counter_key *key,
 822                      const char *full_name)
 823 {
 824         const struct lttng_counter_key_dimension *dim;
 825         size_t i, left = LTTNG_KEY_TOKEN_STRING_LEN_MAX;
 826         char buf[LTTNG_UST_SYM_NAME_LEN];
 827         const char *provider_name, *event_name;
 828
 829         if (lttng_split_provider_event_name(full_name, buf, &provider_name, &event_name))
 830                 return -EINVAL;
 831         key_string[0] = '\0';
 832         if (!key || !key->nr_dimensions)
 833                 return 0;
 834         /* Currently event keys can only be specified on a single dimension. */
 835         if (key->nr_dimensions != 1)
 836                 return -EINVAL;
 837         dim = &key->key_dimensions[0];
 838         for (i = 0; i < dim->nr_key_tokens; i++) {
 839                 const struct lttng_key_token *token = &dim->key_tokens[i];
 840                 size_t token_len;
 841                 const char *str;
 842
 843                 switch (token->type) {
 844                 case LTTNG_KEY_TOKEN_STRING:
 845                         str = token->arg.string;
 846                         break;
 847                 case LTTNG_KEY_TOKEN_EVENT_NAME:
 848                         str = event_name;
 849                         break;
 850                 case LTTNG_KEY_TOKEN_PROVIDER_NAME:
 851                         str = provider_name;
 852                         break;
 853                 default:
 854                         return -EINVAL;
 855                 }
 856                 token_len = strlen(str);
 857                 if (token_len >= left)
 858                         return -EINVAL;
 859                 strcat(key_string, str);
 860                 left -= token_len;
 861         }
 862         return 0;
 863 }
 864
 865 static
 866 bool match_event_token(struct lttng_event_container *container,
 867                 struct lttng_event *event, uint64_t token)
 868 {
 869         if (container->coalesce_hits)
 870                 return true;
 871         if (event->user_token == token)
 872                 return true;
 873         return false;
 874 }
 875
 876 /*
 877  * Supports event creation while tracing session is active.
 878  */
 879 static
 880 int lttng_event_create(struct lttng_event_enabler *event_enabler,
 881                 const struct lttng_event_desc *event_desc,
 882                 const struct lttng_counter_key *key)
 883 {
 884         struct lttng_event_container *container = event_enabler->container;
 885         struct lttng_event *event;
 886         struct lttng_session *session = container->session;
 887         const char *event_name;
 888         struct cds_hlist_head *name_head;
 889         char key_string[LTTNG_KEY_TOKEN_STRING_LEN_MAX];
 890         int ret = 0;
 891         int notify_socket, loglevel;
 892         const char *uri;
 893
 894         event_name = event_desc->name;
 895         if (format_event_key(key_string, key, event_name)) {
 896                 ret = -EINVAL;
 897                 goto type_error;
 898         }
 899
 900         name_head = borrow_hash_table_bucket(session->events_name_ht.table,
 901                 LTTNG_UST_EVENT_HT_SIZE, event_name);
 902         cds_hlist_for_each_entry_2(event, name_head, name_hlist) {
 903                 bool same_event = false, same_container = false, same_key = false,
 904                                 same_token = false;
 905
 906                 WARN_ON_ONCE(!event->desc);
 907                 if (event_desc) {
 908                         if (event->desc == event_desc)
 909                                 same_event = true;
 910                 } else {
 911                         if (!strcmp(event_name, event->desc->name))
 912                                 same_event = true;
 913                 }
 914                 if (container == event->container) {
 915                         same_container = true;
 916                         if (match_event_token(container, event,
 917                                         event_enabler->base.user_token))
 918                                 same_token = true;
 919                 }
 920                 if (key_string[0] == '\0' || !strcmp(key_string, event->key))
 921                         same_key = true;
 922                 if (same_event && same_container && same_key && same_token) {
 923                         ret = -EEXIST;
 924                         goto exist;
 925                 }
 926         }
 927
 928         notify_socket = lttng_get_notify_socket(session->owner);
 929         if (notify_socket < 0) {
 930                 ret = notify_socket;
 931                 goto socket_error;
 932         }
 933
 934         ret = lttng_create_all_event_enums(event_desc->nr_fields, event_desc->fields,
 935                         session);
 936         if (ret < 0) {
 937                 DBG("Error (%d) adding enum to session", ret);
 938                 goto create_enum_error;
 939         }
 940
 941         /*
 942          * Check if loglevel match. Refuse to connect event if not.
 943          */
 944         event = zmalloc(sizeof(struct lttng_event));
 945         if (!event) {
 946                 ret = -ENOMEM;
 947                 goto cache_error;
 948         }
 949         /* for backward compatibility */
 950         event->chan = lttng_event_container_get_channel(container);
 951
 952         /* Event will be enabled by enabler sync. */
 953         event->enabled = 0;
 954         event->registered = 0;
 955         CDS_INIT_LIST_HEAD(&event->filter_bytecode_runtime_head);
 956         CDS_INIT_LIST_HEAD(&event->enablers_ref_head);
 957         event->desc = event_desc;
 958         event->container = container;
 959         strcpy(event->key, key_string);
 960         if (!container->coalesce_hits)
 961                 event->user_token = event_enabler->base.user_token;
 962
 963         if (event_desc->loglevel)
 964                 loglevel = *(*event->desc->loglevel);
 965         else
 966                 loglevel = TRACE_DEFAULT;
 967         if (event_desc->u.ext.model_emf_uri)
 968                 uri = *(event_desc->u.ext.model_emf_uri);
 969         else
 970                 uri = NULL;
 971
 972         /* Fetch event ID from sessiond */
 973         ret = ustcomm_register_event(notify_socket,
 974                 session,
 975                 session->objd,
 976                 container->objd,
 977                 event_desc->name,
 978                 loglevel,
 979                 event_desc->signature,
 980                 event_desc->nr_fields,
 981                 event_desc->fields,
 982                 uri,
 983                 event_enabler->base.user_token,
 984                 &event->id,
 985                 &event->counter_index);
 986         if (ret < 0) {
 987                 DBG("Error (%d) registering event to sessiond", ret);
 988                 goto sessiond_register_error;
 989         }
 990
 991         cds_list_add(&event->node, &session->events_head);
 992         cds_hlist_add_head(&event->name_hlist, name_head);
 993         return 0;
 994
 995 sessiond_register_error:
 996         free(event);
 997 cache_error:
 998 create_enum_error:
 999 socket_error:
1000 exist:
1001 type_error:
1002         return ret;
1003 }
1004
1005 static
1006 int lttng_event_notifier_create(const struct lttng_event_desc *desc,
1007                 uint64_t token, uint64_t error_counter_index,
1008                 struct lttng_event_notifier_group *event_notifier_group)
1009 {
1010         struct lttng_event_notifier *event_notifier;
1011         struct cds_hlist_head *head;
1012         int ret = 0;
1013
1014         /*
1015          * Get the hashtable bucket the created lttng_event_notifier object
1016          * should be inserted.
1017          */
1018         head = borrow_hash_table_bucket(
1019                 event_notifier_group->event_notifiers_ht.table,
1020                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, desc->name);
1021
1022         event_notifier = zmalloc(sizeof(struct lttng_event_notifier));
1023         if (!event_notifier) {
1024                 ret = -ENOMEM;
1025                 goto error;
1026         }
1027
1028         event_notifier->group = event_notifier_group;
1029         event_notifier->user_token = token;
1030         event_notifier->error_counter_index = error_counter_index;
1031
1032         /* Event notifier will be enabled by enabler sync. */
1033         event_notifier->enabled = 0;
1034         event_notifier->registered = 0;
1035
1036         CDS_INIT_LIST_HEAD(&event_notifier->filter_bytecode_runtime_head);
1037         CDS_INIT_LIST_HEAD(&event_notifier->capture_bytecode_runtime_head);
1038         CDS_INIT_LIST_HEAD(&event_notifier->enablers_ref_head);
1039         event_notifier->desc = desc;
1040         event_notifier->notification_send = lttng_event_notifier_notification_send;
1041
1042         cds_list_add(&event_notifier->node,
1043                         &event_notifier_group->event_notifiers_head);
1044         cds_hlist_add_head(&event_notifier->hlist, head);
1045
1046         return 0;
1047
1048 error:
1049         return ret;
1050 }
1051
1052 static
1053 void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier)
1054 {
1055         struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
1056
1057         /* Remove from event_notifier list. */
1058         cds_list_del(&event_notifier->node);
1059         /* Remove from event_notifier hash table. */
1060         cds_hlist_del(&event_notifier->hlist);
1061
1062         lttng_free_event_notifier_filter_runtime(event_notifier);
1063
1064         /* Free event_notifier enabler refs */
1065         cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
1066                         &event_notifier->enablers_ref_head, node)
1067                 free(enabler_ref);
1068         free(event_notifier);
1069 }
1070
1071 static
1072 int lttng_desc_match_star_glob_enabler(const struct lttng_event_desc *desc,
1073                 struct lttng_enabler *enabler)
1074 {
1075         int loglevel = 0;
1076         unsigned int has_loglevel = 0;
1077
1078         assert(enabler->format_type == LTTNG_ENABLER_FORMAT_STAR_GLOB);
1079         if (!strutils_star_glob_match(enabler->event_param.name, SIZE_MAX,
1080                         desc->name, SIZE_MAX))
1081                 return 0;
1082         if (desc->loglevel) {
1083                 loglevel = *(*desc->loglevel);
1084                 has_loglevel = 1;
1085         }
1086         if (!lttng_loglevel_match(loglevel,
1087                         has_loglevel,
1088                         enabler->event_param.loglevel_type,
1089                         enabler->event_param.loglevel))
1090                 return 0;
1091         return 1;
1092 }
1093
1094 static
1095 int lttng_desc_match_event_enabler(const struct lttng_event_desc *desc,
1096                 struct lttng_enabler *enabler)
1097 {
1098         int loglevel = 0;
1099         unsigned int has_loglevel = 0;
1100
1101         assert(enabler->format_type == LTTNG_ENABLER_FORMAT_EVENT);
1102         if (strcmp(desc->name, enabler->event_param.name))
1103                 return 0;
1104         if (desc->loglevel) {
1105                 loglevel = *(*desc->loglevel);
1106                 has_loglevel = 1;
1107         }
1108         if (!lttng_loglevel_match(loglevel,
1109                         has_loglevel,
1110                         enabler->event_param.loglevel_type,
1111                         enabler->event_param.loglevel))
1112                 return 0;
1113         return 1;
1114 }
1115
1116 static
1117 int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
1118                 struct lttng_enabler *enabler)
1119 {
1120         switch (enabler->format_type) {
1121         case LTTNG_ENABLER_FORMAT_STAR_GLOB:
1122         {
1123                 struct lttng_ust_excluder_node *excluder;
1124
1125                 if (!lttng_desc_match_star_glob_enabler(desc, enabler)) {
1126                         return 0;
1127                 }
1128
1129                 /*
1130                  * If the matching event matches with an excluder,
1131                  * return 'does not match'
1132                  */
1133                 cds_list_for_each_entry(excluder, &enabler->excluder_head, node) {
1134                         int count;
1135
1136                         for (count = 0; count < excluder->excluder.count; count++) {
1137                                 int len;
1138                                 char *excluder_name;
1139
1140                                 excluder_name = (char *) (excluder->excluder.names)
1141                                                 + count * LTTNG_UST_SYM_NAME_LEN;
1142                                 len = strnlen(excluder_name, LTTNG_UST_SYM_NAME_LEN);
1143                                 if (len > 0 && strutils_star_glob_match(excluder_name, len, desc->name, SIZE_MAX))
1144                                         return 0;
1145                         }
1146                 }
1147                 return 1;
1148         }
1149         case LTTNG_ENABLER_FORMAT_EVENT:
1150                 return lttng_desc_match_event_enabler(desc, enabler);
1151         default:
1152                 return -EINVAL;
1153         }
1154 }
1155
1156 static
1157 bool lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler,
1158                 struct lttng_event *event)
1159 {
1160         if (lttng_desc_match_enabler(event->desc,
1161                         lttng_event_enabler_as_enabler(event_enabler)) > 0
1162                         && event->container == event_enabler->container
1163                         && match_event_token(event->container, event, event_enabler->base.user_token))
1164                 return true;
1165         else
1166                 return false;
1167 }
1168
1169 static
1170 int lttng_event_notifier_enabler_match_event_notifier(
1171                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1172                 struct lttng_event_notifier *event_notifier)
1173 {
1174         bool desc_matches = lttng_desc_match_enabler(event_notifier->desc,
1175                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)) > 0;
1176
1177         if (desc_matches && event_notifier->group == event_notifier_enabler->group &&
1178                         event_notifier->user_token == event_notifier_enabler->base.user_token)
1179                 return 1;
1180         else
1181                 return 0;
1182 }
1183
1184 static
1185 struct lttng_enabler_ref *lttng_enabler_ref(
1186                 struct cds_list_head *enabler_ref_list,
1187                 struct lttng_enabler *enabler)
1188 {
1189         struct lttng_enabler_ref *enabler_ref;
1190
1191         cds_list_for_each_entry(enabler_ref, enabler_ref_list, node) {
1192                 if (enabler_ref->ref == enabler)
1193                         return enabler_ref;
1194         }
1195         return NULL;
1196 }
1197
1198 /*
1199  * Create struct lttng_event if it is missing and present in the list of
1200  * tracepoint probes.
1201  */
1202 static
1203 void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
1204 {
1205         struct lttng_probe_desc *probe_desc;
1206         const struct lttng_event_desc *desc;
1207         int i;
1208         struct cds_list_head *probe_list;
1209
1210         probe_list = lttng_get_probe_list_head();
1211         /*
1212          * For each probe event, if we find that a probe event matches
1213          * our enabler, create an associated lttng_event if not
1214          * already present.
1215          */
1216         cds_list_for_each_entry(probe_desc, probe_list, head) {
1217                 for (i = 0; i < probe_desc->nr_events; i++) {
1218                         int ret;
1219
1220                         desc = probe_desc->event_desc[i];
1221                         if (lttng_desc_match_enabler(desc,
1222                                         lttng_event_enabler_as_enabler(event_enabler)) <= 0)
1223                                 continue;
1224
1225                         /* Try to create an event for this event probe. */
1226                         ret = lttng_event_create(event_enabler,
1227                                         probe_desc->event_desc[i],
1228                                         &event_enabler->key);
1229                         /* Skip if event is already found. */
1230                         if (ret == -EEXIST)
1231                                 continue;
1232                         if (ret) {
1233                                 DBG("Unable to create event %s, error %d\n",
1234                                         probe_desc->event_desc[i]->name, ret);
1235                         }
1236                 }
1237         }
1238 }
1239
1240 static
1241 void probe_provider_event_for_each(struct lttng_probe_desc *provider_desc,
1242                 void (*event_func)(struct lttng_session *session,
1243                         struct lttng_event *event),
1244                 void (*event_notifier_func)(struct lttng_event_notifier *event_notifier))
1245 {
1246         struct cds_hlist_node *node, *tmp_node;
1247         struct cds_list_head *sessionsp;
1248         unsigned int i;
1249
1250         /* Get handle on list of sessions. */
1251         sessionsp = _lttng_get_sessions();
1252
1253         /*
1254          * Iterate over all events in the probe provider descriptions and
1255          * sessions to queue the unregistration of the events.
1256          */
1257         for (i = 0; i < provider_desc->nr_events; i++) {
1258                 const struct lttng_event_desc *event_desc;
1259                 struct lttng_event_notifier_group *event_notifier_group;
1260                 struct lttng_event_notifier *event_notifier;
1261                 struct lttng_session *session;
1262                 struct cds_hlist_head *head;
1263                 struct lttng_event *event;
1264
1265                 event_desc = provider_desc->event_desc[i];
1266
1267                 /*
1268                  * Iterate over all session to find the current event
1269                  * description.
1270                  */
1271                 cds_list_for_each_entry(session, sessionsp, node) {
1272                         /*
1273                          * Get the list of events in the hashtable bucket and
1274                          * iterate to find the event matching this descriptor.
1275                          */
1276                         head = borrow_hash_table_bucket(
1277                                 session->events_name_ht.table,
1278                                 LTTNG_UST_EVENT_HT_SIZE, event_desc->name);
1279
1280                         cds_hlist_for_each_entry_safe(event, node, tmp_node, head, name_hlist) {
1281                                 if (event_desc == event->desc) {
1282                                         event_func(session, event);
1283                                         break;
1284                                 }
1285                         }
1286                 }
1287
1288                 /*
1289                  * Iterate over all event_notifier groups to find the current event
1290                  * description.
1291                  */
1292                 cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
1293                         /*
1294                          * Get the list of event_notifiers in the hashtable bucket and
1295                          * iterate to find the event_notifier matching this
1296                          * descriptor.
1297                          */
1298                         head = borrow_hash_table_bucket(
1299                                 event_notifier_group->event_notifiers_ht.table,
1300                                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, event_desc->name);
1301
1302                         cds_hlist_for_each_entry_safe(event_notifier, node, tmp_node, head, hlist) {
1303                                 if (event_desc == event_notifier->desc) {
1304                                         event_notifier_func(event_notifier);
1305                                         break;
1306                                 }
1307                         }
1308                 }
1309         }
1310 }
1311
1312 static
1313 void _unregister_event(struct lttng_session *session,
1314                 struct lttng_event *event)
1315 {
1316         _lttng_event_unregister(event);
1317 }
1318
1319 static
1320 void _event_enum_destroy(struct lttng_session *session,
1321                 struct lttng_event *event)
1322 {
1323         unsigned int i;
1324
1325         /* Destroy enums of the current event. */
1326         for (i = 0; i < event->desc->nr_fields; i++) {
1327                 const struct lttng_enum_desc *enum_desc;
1328                 const struct lttng_event_field *field;
1329                 struct lttng_enum *curr_enum;
1330
1331                 field = &(event->desc->fields[i]);
1332                 switch (field->type.atype) {
1333                 case atype_enum:
1334                         enum_desc = field->type.u.legacy.basic.enumeration.desc;
1335                         break;
1336                 case atype_enum_nestable:
1337                         enum_desc = field->type.u.enum_nestable.desc;
1338                         break;
1339                 default:
1340                         continue;
1341                 }
1342
1343                 curr_enum = lttng_ust_enum_get_from_desc(session, enum_desc);
1344                 if (curr_enum) {
1345                         _lttng_enum_destroy(curr_enum);
1346                 }
1347         }
1348
1349         /* Destroy event. */
1350         _lttng_event_destroy(event);
1351 }
1352
1353 /*
1354  * Iterate over all the UST sessions to unregister and destroy all probes from
1355  * the probe provider descriptor received as argument. Must me called with the
1356  * ust_lock held.
1357  */
1358 void lttng_probe_provider_unregister_events(
1359                 struct lttng_probe_desc *provider_desc)
1360 {
1361         /*
1362          * Iterate over all events in the probe provider descriptions and sessions
1363          * to queue the unregistration of the events.
1364          */
1365         probe_provider_event_for_each(provider_desc, _unregister_event,
1366                 _lttng_event_notifier_unregister);
1367
1368         /* Wait for grace period. */
1369         lttng_ust_synchronize_trace();
1370         /* Prune the unregistration queue. */
1371         __tracepoint_probe_prune_release_queue();
1372
1373         /*
1374          * It is now safe to destroy the events and remove them from the event list
1375          * and hashtables.
1376          */
1377         probe_provider_event_for_each(provider_desc, _event_enum_destroy,
1378                 _lttng_event_notifier_destroy);
1379 }
1380
1381 /*
1382  * Create events associated with an event enabler (if not already present),
1383  * and add backward reference from the event to the enabler.
1384  */
1385 static
1386 int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
1387 {
1388         struct lttng_session *session = event_enabler->container->session;
1389         struct lttng_event *event;
1390
1391         if (!lttng_event_enabler_as_enabler(event_enabler)->enabled)
1392                 goto end;
1393
1394         /* First ensure that probe events are created for this enabler. */
1395         lttng_create_event_if_missing(event_enabler);
1396
1397         /* For each event matching enabler in session event list. */
1398         cds_list_for_each_entry(event, &session->events_head, node) {
1399                 struct lttng_enabler_ref *enabler_ref;
1400
1401                 if (!lttng_event_enabler_match_event(event_enabler, event))
1402                         continue;
1403
1404                 enabler_ref = lttng_enabler_ref(&event->enablers_ref_head,
1405                         lttng_event_enabler_as_enabler(event_enabler));
1406                 if (!enabler_ref) {
1407                         /*
1408                          * If no backward ref, create it.
1409                          * Add backward ref from event to enabler.
1410                          */
1411                         enabler_ref = zmalloc(sizeof(*enabler_ref));
1412                         if (!enabler_ref)
1413                                 return -ENOMEM;
1414                         enabler_ref->ref = lttng_event_enabler_as_enabler(
1415                                 event_enabler);
1416                         cds_list_add(&enabler_ref->node,
1417                                 &event->enablers_ref_head);
1418                 }
1419
1420                 /*
1421                  * Link filter bytecodes if not linked yet.
1422                  */
1423                 lttng_enabler_link_bytecode(event->desc,
1424                         &session->ctx,
1425                         &event->filter_bytecode_runtime_head,
1426                         &lttng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head);
1427
1428                 /* TODO: merge event context. */
1429         }
1430 end:
1431         return 0;
1432 }
1433
1434 /*
1435  * Called at library load: connect the probe on all enablers matching
1436  * this event.
1437  * Called with session mutex held.
1438  */
1439 int lttng_fix_pending_events(void)
1440 {
1441         struct lttng_session *session;
1442
1443         cds_list_for_each_entry(session, &sessions, node) {
1444                 lttng_session_lazy_sync_event_enablers(session);
1445         }
1446         return 0;
1447 }
1448
1449 int lttng_fix_pending_event_notifiers(void)
1450 {
1451         struct lttng_event_notifier_group *event_notifier_group;
1452
1453         cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
1454                 lttng_event_notifier_group_sync_enablers(event_notifier_group);
1455         }
1456         return 0;
1457 }
1458
1459 /*
1460  * For each session of the owner thread, execute pending statedump.
1461  * Only dump state for the sessions owned by the caller thread, because
1462  * we don't keep ust_lock across the entire iteration.
1463  */
1464 void lttng_handle_pending_statedump(void *owner)
1465 {
1466         struct lttng_session *session;
1467
1468         /* Execute state dump */
1469         do_lttng_ust_statedump(owner);
1470
1471         /* Clear pending state dump */
1472         if (ust_lock()) {
1473                 goto end;
1474         }
1475         cds_list_for_each_entry(session, &sessions, node) {
1476                 if (session->owner != owner)
1477                         continue;
1478                 if (!session->statedump_pending)
1479                         continue;
1480                 session->statedump_pending = 0;
1481         }
1482 end:
1483         ust_unlock();
1484         return;
1485 }
1486
1487 /*
1488  * Only used internally at session destruction.
1489  */
1490 static
1491 void _lttng_event_destroy(struct lttng_event *event)
1492 {
1493         struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
1494
1495         /* Remove from event list. */
1496         cds_list_del(&event->node);
1497         /* Remove from event hash table. */
1498         cds_hlist_del(&event->name_hlist);
1499
1500         lttng_destroy_context(event->ctx);
1501         lttng_free_event_filter_runtime(event);
1502         /* Free event enabler refs */
1503         cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
1504                         &event->enablers_ref_head, node)
1505                 free(enabler_ref);
1506         free(event);
1507 }
1508
1509 static
1510 void _lttng_enum_destroy(struct lttng_enum *_enum)
1511 {
1512         cds_list_del(&_enum->node);
1513         cds_hlist_del(&_enum->hlist);
1514         free(_enum);
1515 }
1516
1517 void lttng_ust_events_exit(void)
1518 {
1519         struct lttng_session *session, *tmpsession;
1520
1521         cds_list_for_each_entry_safe(session, tmpsession, &sessions, node)
1522                 lttng_session_destroy(session);
1523 }
1524
1525 static
1526 int copy_counter_key(struct lttng_counter_key *key,
1527                      const struct lttng_ust_counter_key *key_param)
1528 {
1529         size_t i, j, nr_dimensions;
1530
1531         nr_dimensions = key_param->nr_dimensions;
1532         if (nr_dimensions > LTTNG_COUNTER_DIMENSION_MAX)
1533                 return -EINVAL;
1534         key->nr_dimensions = nr_dimensions;
1535         for (i = 0; i < nr_dimensions; i++) {
1536                 const struct lttng_ust_counter_key_dimension *udim =
1537                         &key_param->key_dimensions[i];
1538                 struct lttng_counter_key_dimension *dim =
1539                         &key->key_dimensions[i];
1540                 size_t nr_key_tokens;
1541
1542                 nr_key_tokens = udim->nr_key_tokens;
1543                 if (!nr_key_tokens || nr_key_tokens > LTTNG_NR_KEY_TOKEN)
1544                         return -EINVAL;
1545                 dim->nr_key_tokens = nr_key_tokens;
1546                 for (j = 0; j < nr_key_tokens; j++) {
1547                         const struct lttng_ust_key_token *utoken =
1548                                 &udim->key_tokens[j];
1549                         struct lttng_key_token *token =
1550                                 &dim->key_tokens[j];
1551
1552                         switch (utoken->type) {
1553                         case LTTNG_UST_KEY_TOKEN_STRING:
1554                         {
1555                                 size_t len;
1556
1557                                 token->type = LTTNG_KEY_TOKEN_STRING;
1558                                 len = strnlen(utoken->arg.string, LTTNG_KEY_TOKEN_STRING_LEN_MAX);
1559                                 if (!len || len >= LTTNG_KEY_TOKEN_STRING_LEN_MAX)
1560                                         return -EINVAL;
1561                                 strcpy(token->arg.string, utoken->arg.string);
1562                                 break;
1563                         }
1564                         case LTTNG_UST_KEY_TOKEN_EVENT_NAME:
1565                                 token->type = LTTNG_KEY_TOKEN_EVENT_NAME;
1566                                 break;
1567                         case LTTNG_UST_KEY_TOKEN_PROVIDER_NAME:
1568                                 token->type = LTTNG_KEY_TOKEN_PROVIDER_NAME;
1569                                 break;
1570                         default:
1571                                 return -EINVAL;
1572                         }
1573                 }
1574         }
1575         return 0;
1576 }
1577
1578 /*
1579  * Enabler management.
1580  */
1581 struct lttng_event_enabler *lttng_event_enabler_create(
1582                 enum lttng_enabler_format_type format_type,
1583                 struct lttng_ust_event *event_param,
1584                 const struct lttng_ust_counter_key *key,
1585                 struct lttng_event_container *container)
1586 {
1587         struct lttng_event_enabler *event_enabler;
1588
1589         event_enabler = zmalloc(sizeof(*event_enabler));
1590         if (!event_enabler)
1591                 return NULL;
1592         event_enabler->base.format_type = format_type;
1593         event_enabler->base.user_token = event_param->token;
1594         CDS_INIT_LIST_HEAD(&event_enabler->base.filter_bytecode_head);
1595         CDS_INIT_LIST_HEAD(&event_enabler->base.excluder_head);
1596         memcpy(&event_enabler->base.event_param, event_param,
1597                 sizeof(event_enabler->base.event_param));
1598         event_enabler->container = container;
1599         if (key) {
1600                 if (copy_counter_key(&event_enabler->key, key))
1601                         return NULL;
1602         }
1603         /* ctx left NULL */
1604         event_enabler->base.enabled = 0;
1605         cds_list_add(&event_enabler->node, &event_enabler->container->session->enablers_head);
1606         lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
1607
1608         return event_enabler;
1609 }
1610
1611 struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
1612                 struct lttng_event_notifier_group *event_notifier_group,
1613                 enum lttng_enabler_format_type format_type,
1614                 struct lttng_ust_event_notifier *event_notifier_param)
1615 {
1616         struct lttng_event_notifier_enabler *event_notifier_enabler;
1617
1618         event_notifier_enabler = zmalloc(sizeof(*event_notifier_enabler));
1619         if (!event_notifier_enabler)
1620                 return NULL;
1621         event_notifier_enabler->base.format_type = format_type;
1622         CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head);
1623         CDS_INIT_LIST_HEAD(&event_notifier_enabler->capture_bytecode_head);
1624         CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.excluder_head);
1625
1626         event_notifier_enabler->error_counter_index = event_notifier_param->error_counter_index;
1627         event_notifier_enabler->num_captures = 0;
1628
1629         event_notifier_enabler->base.user_token = event_notifier_param->event.token;
1630         memcpy(&event_notifier_enabler->base.event_param.name,
1631                 event_notifier_param->event.name,
1632                 sizeof(event_notifier_enabler->base.event_param.name));
1633         event_notifier_enabler->base.event_param.instrumentation =
1634                 event_notifier_param->event.instrumentation;
1635         event_notifier_enabler->base.event_param.loglevel =
1636                 event_notifier_param->event.loglevel;
1637         event_notifier_enabler->base.event_param.loglevel_type =
1638                 event_notifier_param->event.loglevel_type;
1639
1640         event_notifier_enabler->base.enabled = 0;
1641         event_notifier_enabler->group = event_notifier_group;
1642
1643         cds_list_add(&event_notifier_enabler->node,
1644                         &event_notifier_group->enablers_head);
1645
1646         lttng_event_notifier_group_sync_enablers(event_notifier_group);
1647
1648         return event_notifier_enabler;
1649 }
1650
1651 int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler)
1652 {
1653         lttng_event_enabler_as_enabler(event_enabler)->enabled = 1;
1654         lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
1655
1656         return 0;
1657 }
1658
1659 int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler)
1660 {
1661         lttng_event_enabler_as_enabler(event_enabler)->enabled = 0;
1662         lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
1663
1664         return 0;
1665 }
1666
1667 static
1668 void _lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler,
1669                 struct lttng_ust_bytecode_node **bytecode)
1670 {
1671         (*bytecode)->enabler = enabler;
1672         cds_list_add_tail(&(*bytecode)->node, &enabler->filter_bytecode_head);
1673         /* Take ownership of bytecode */
1674         *bytecode = NULL;
1675 }
1676
1677 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler,
1678                 struct lttng_ust_bytecode_node **bytecode)
1679 {
1680         _lttng_enabler_attach_filter_bytecode(
1681                 lttng_event_enabler_as_enabler(event_enabler), bytecode);
1682
1683         lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
1684         return 0;
1685 }
1686
1687 static
1688 void _lttng_enabler_attach_exclusion(struct lttng_enabler *enabler,
1689                 struct lttng_ust_excluder_node **excluder)
1690 {
1691         (*excluder)->enabler = enabler;
1692         cds_list_add_tail(&(*excluder)->node, &enabler->excluder_head);
1693         /* Take ownership of excluder */
1694         *excluder = NULL;
1695 }
1696
1697 int lttng_event_enabler_attach_exclusion(struct lttng_event_enabler *event_enabler,
1698                 struct lttng_ust_excluder_node **excluder)
1699 {
1700         _lttng_enabler_attach_exclusion(
1701                 lttng_event_enabler_as_enabler(event_enabler), excluder);
1702
1703         lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
1704         return 0;
1705 }
1706
1707 int lttng_event_notifier_enabler_enable(
1708                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1709 {
1710         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1;
1711         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1712
1713         return 0;
1714 }
1715
1716 int lttng_event_notifier_enabler_disable(
1717                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1718 {
1719         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0;
1720         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1721
1722         return 0;
1723 }
1724
1725 int lttng_event_notifier_enabler_attach_filter_bytecode(
1726                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1727                 struct lttng_ust_bytecode_node **bytecode)
1728 {
1729         _lttng_enabler_attach_filter_bytecode(
1730                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
1731                 bytecode);
1732
1733         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1734         return 0;
1735 }
1736
1737 int lttng_event_notifier_enabler_attach_capture_bytecode(
1738                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1739                 struct lttng_ust_bytecode_node **bytecode)
1740 {
1741         (*bytecode)->enabler = lttng_event_notifier_enabler_as_enabler(
1742                         event_notifier_enabler);
1743         cds_list_add_tail(&(*bytecode)->node,
1744                         &event_notifier_enabler->capture_bytecode_head);
1745         /* Take ownership of bytecode */
1746         *bytecode = NULL;
1747         event_notifier_enabler->num_captures++;
1748
1749         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1750         return 0;
1751 }
1752
1753 int lttng_event_notifier_enabler_attach_exclusion(
1754                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1755                 struct lttng_ust_excluder_node **excluder)
1756 {
1757         _lttng_enabler_attach_exclusion(
1758                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
1759                 excluder);
1760
1761         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1762         return 0;
1763 }
1764
1765 int lttng_attach_context(struct lttng_ust_context *context_param,
1766                 union ust_args *uargs,
1767                 struct lttng_ctx **ctx, struct lttng_session *session)
1768 {
1769         /*
1770          * We cannot attach a context after trace has been started for a
1771          * session because the metadata does not allow expressing this
1772          * information outside of the original channel scope.
1773          */
1774         if (session->been_active)
1775                 return -EPERM;
1776
1777         switch (context_param->ctx) {
1778         case LTTNG_UST_CONTEXT_PTHREAD_ID:
1779                 return lttng_add_pthread_id_to_ctx(ctx);
1780         case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
1781         {
1782                 struct lttng_ust_perf_counter_ctx *perf_ctx_param;
1783
1784                 perf_ctx_param = &context_param->u.perf_counter;
1785                 return lttng_add_perf_counter_to_ctx(
1786                         perf_ctx_param->type,
1787                         perf_ctx_param->config,
1788                         perf_ctx_param->name,
1789                         ctx);
1790         }
1791         case LTTNG_UST_CONTEXT_VTID:
1792                 return lttng_add_vtid_to_ctx(ctx);
1793         case LTTNG_UST_CONTEXT_VPID:
1794                 return lttng_add_vpid_to_ctx(ctx);
1795         case LTTNG_UST_CONTEXT_PROCNAME:
1796                 return lttng_add_procname_to_ctx(ctx);
1797         case LTTNG_UST_CONTEXT_IP:
1798                 return lttng_add_ip_to_ctx(ctx);
1799         case LTTNG_UST_CONTEXT_CPU_ID:
1800                 return lttng_add_cpu_id_to_ctx(ctx);
1801         case LTTNG_UST_CONTEXT_APP_CONTEXT:
1802                 return lttng_ust_add_app_context_to_ctx_rcu(uargs->app_context.ctxname,
1803                         ctx);
1804         case LTTNG_UST_CONTEXT_CGROUP_NS:
1805                 return lttng_add_cgroup_ns_to_ctx(ctx);
1806         case LTTNG_UST_CONTEXT_IPC_NS:
1807                 return lttng_add_ipc_ns_to_ctx(ctx);
1808         case LTTNG_UST_CONTEXT_MNT_NS:
1809                 return lttng_add_mnt_ns_to_ctx(ctx);
1810         case LTTNG_UST_CONTEXT_NET_NS:
1811                 return lttng_add_net_ns_to_ctx(ctx);
1812         case LTTNG_UST_CONTEXT_PID_NS:
1813                 return lttng_add_pid_ns_to_ctx(ctx);
1814         case LTTNG_UST_CONTEXT_TIME_NS:
1815                 return lttng_add_time_ns_to_ctx(ctx);
1816         case LTTNG_UST_CONTEXT_USER_NS:
1817                 return lttng_add_user_ns_to_ctx(ctx);
1818         case LTTNG_UST_CONTEXT_UTS_NS:
1819                 return lttng_add_uts_ns_to_ctx(ctx);
1820         case LTTNG_UST_CONTEXT_VUID:
1821                 return lttng_add_vuid_to_ctx(ctx);
1822         case LTTNG_UST_CONTEXT_VEUID:
1823                 return lttng_add_veuid_to_ctx(ctx);
1824         case LTTNG_UST_CONTEXT_VSUID:
1825                 return lttng_add_vsuid_to_ctx(ctx);
1826         case LTTNG_UST_CONTEXT_VGID:
1827                 return lttng_add_vgid_to_ctx(ctx);
1828         case LTTNG_UST_CONTEXT_VEGID:
1829                 return lttng_add_vegid_to_ctx(ctx);
1830         case LTTNG_UST_CONTEXT_VSGID:
1831                 return lttng_add_vsgid_to_ctx(ctx);
1832         default:
1833                 return -EINVAL;
1834         }
1835 }
1836
1837 int lttng_event_enabler_attach_context(struct lttng_event_enabler *enabler,
1838                 struct lttng_ust_context *context_param)
1839 {
1840         return -ENOSYS;
1841 }
1842
1843 void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
1844 {
1845         if (!event_enabler) {
1846                 return;
1847         }
1848         cds_list_del(&event_enabler->node);
1849
1850         lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler));
1851
1852         lttng_destroy_context(event_enabler->ctx);
1853         free(event_enabler);
1854 }
1855
1856 /*
1857  * lttng_session_sync_event_enablers should be called just before starting a
1858  * session.
1859  */
1860 static
1861 void lttng_session_sync_event_enablers(struct lttng_session *session)
1862 {
1863         struct lttng_event_enabler *event_enabler;
1864         struct lttng_event *event;
1865
1866         cds_list_for_each_entry(event_enabler, &session->enablers_head, node)
1867                 lttng_event_enabler_ref_events(event_enabler);
1868         /*
1869          * For each event, if at least one of its enablers is enabled,
1870          * and its channel and session transient states are enabled, we
1871          * enable the event, else we disable it.
1872          */
1873         cds_list_for_each_entry(event, &session->events_head, node) {
1874                 struct lttng_enabler_ref *enabler_ref;
1875                 struct lttng_bytecode_runtime *runtime;
1876                 int enabled = 0, has_enablers_without_bytecode = 0;
1877
1878                 /* Enable events */
1879                 cds_list_for_each_entry(enabler_ref,
1880                                 &event->enablers_ref_head, node) {
1881                         if (enabler_ref->ref->enabled) {
1882                                 enabled = 1;
1883                                 break;
1884                         }
1885                 }
1886                 /*
1887                  * Enabled state is based on union of enablers, with
1888                  * intesection of session and channel transient enable
1889                  * states.
1890                  */
1891                 enabled = enabled && session->tstate && event->container->tstate;
1892
1893                 CMM_STORE_SHARED(event->enabled, enabled);
1894                 /*
1895                  * Sync tracepoint registration with event enabled
1896                  * state.
1897                  */
1898                 if (enabled) {
1899                         if (!event->registered)
1900                                 register_event(event);
1901                 } else {
1902                         if (event->registered)
1903                                 unregister_event(event);
1904                 }
1905
1906                 /* Check if has enablers without bytecode enabled */
1907                 cds_list_for_each_entry(enabler_ref,
1908                                 &event->enablers_ref_head, node) {
1909                         if (enabler_ref->ref->enabled
1910                                         && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) {
1911                                 has_enablers_without_bytecode = 1;
1912                                 break;
1913                         }
1914                 }
1915                 event->has_enablers_without_bytecode =
1916                         has_enablers_without_bytecode;
1917
1918                 /* Enable filters */
1919                 cds_list_for_each_entry(runtime,
1920                                 &event->filter_bytecode_runtime_head, node) {
1921                         lttng_bytecode_filter_sync_state(runtime);
1922                 }
1923         }
1924         __tracepoint_probe_prune_release_queue();
1925 }
1926
1927 /* Support for event notifier is introduced by probe provider major version 2. */
1928 static
1929 bool lttng_ust_probe_supports_event_notifier(struct lttng_probe_desc *probe_desc)
1930 {
1931         return probe_desc->major >= 2;
1932 }
1933
1934 static
1935 void lttng_create_event_notifier_if_missing(
1936                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1937 {
1938         struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
1939         struct lttng_probe_desc *probe_desc;
1940         struct cds_list_head *probe_list;
1941         int i;
1942
1943         probe_list = lttng_get_probe_list_head();
1944
1945         cds_list_for_each_entry(probe_desc, probe_list, head) {
1946                 for (i = 0; i < probe_desc->nr_events; i++) {
1947                         int ret;
1948                         bool found = false;
1949                         const struct lttng_event_desc *desc;
1950                         struct lttng_event_notifier *event_notifier;
1951                         struct cds_hlist_head *head;
1952                         struct cds_hlist_node *node;
1953
1954                         desc = probe_desc->event_desc[i];
1955
1956                         if (lttng_desc_match_enabler(desc,
1957                                         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)) <= 0)
1958                                 continue;
1959
1960                         /*
1961                          * Given the current event_notifier group, get the bucket that
1962                          * the target event_notifier would be if it was already
1963                          * created.
1964                          */
1965                         head = borrow_hash_table_bucket(
1966                                 event_notifier_group->event_notifiers_ht.table,
1967                                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, desc->name);
1968
1969                         cds_hlist_for_each_entry(event_notifier, node, head, hlist) {
1970                                 /*
1971                                  * Check if event_notifier already exists by checking
1972                                  * if the event_notifier and enabler share the same
1973                                  * description and id.
1974                                  */
1975                                 if (event_notifier->desc == desc &&
1976                                                 event_notifier->user_token == event_notifier_enabler->base.user_token) {
1977                                         found = true;
1978                                         break;
1979                                 }
1980                         }
1981
1982                         if (found)
1983                                 continue;
1984
1985                         /* Check that the probe supports event notifiers, else report the error. */
1986                         if (!lttng_ust_probe_supports_event_notifier(probe_desc)) {
1987                                 ERR("Probe \"%s\" contains event \"%s\" which matches an enabled event notifier, "
1988                                         "but its version (%u.%u) is too old and does not implement event notifiers. "
1989                                         "It needs to be recompiled against a newer version of LTTng-UST, otherwise "
1990                                         "this event will not generate any notification.",
1991                                         probe_desc->provider,
1992                                         desc->name,
1993                                         probe_desc->major,
1994                                         probe_desc->minor);
1995                                 continue;
1996                         }
1997                         /*
1998                          * We need to create a event_notifier for this event probe.
1999                          */
2000                         ret = lttng_event_notifier_create(desc,
2001                                 event_notifier_enabler->base.user_token,
2002                                 event_notifier_enabler->error_counter_index,
2003                                 event_notifier_group);
2004                         if (ret) {
2005                                 DBG("Unable to create event_notifier %s, error %d\n",
2006                                         probe_desc->event_desc[i]->name, ret);
2007                         }
2008                 }
2009         }
2010 }
2011
2012 /*
2013  * Create event_notifiers associated with a event_notifier enabler (if not already present).
2014  */
2015 static
2016 int lttng_event_notifier_enabler_ref_event_notifiers(
2017                 struct lttng_event_notifier_enabler *event_notifier_enabler)
2018 {
2019         struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
2020         struct lttng_event_notifier *event_notifier;
2021
2022          /*
2023           * Only try to create event_notifiers for enablers that are enabled, the user
2024           * might still be attaching filter or exclusion to the
2025           * event_notifier_enabler.
2026           */
2027         if (!lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled)
2028                 goto end;
2029
2030         /* First, ensure that probe event_notifiers are created for this enabler. */
2031         lttng_create_event_notifier_if_missing(event_notifier_enabler);
2032
2033         /* Link the created event_notifier with its associated enabler. */
2034         cds_list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, node) {
2035                 struct lttng_enabler_ref *enabler_ref;
2036
2037                 if (!lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier))
2038                         continue;
2039
2040                 enabler_ref = lttng_enabler_ref(&event_notifier->enablers_ref_head,
2041                         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
2042                 if (!enabler_ref) {
2043                         /*
2044                          * If no backward ref, create it.
2045                          * Add backward ref from event_notifier to enabler.
2046                          */
2047                         enabler_ref = zmalloc(sizeof(*enabler_ref));
2048                         if (!enabler_ref)
2049                                 return -ENOMEM;
2050
2051                         enabler_ref->ref = lttng_event_notifier_enabler_as_enabler(
2052                                 event_notifier_enabler);
2053                         cds_list_add(&enabler_ref->node,
2054                                 &event_notifier->enablers_ref_head);
2055                 }
2056
2057                 /*
2058                  * Link filter bytecodes if not linked yet.
2059                  */
2060                 lttng_enabler_link_bytecode(event_notifier->desc,
2061                         &event_notifier_group->ctx,
2062                         &event_notifier->filter_bytecode_runtime_head,
2063                         &lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
2064
2065                 /*
2066                  * Link capture bytecodes if not linked yet.
2067                  */
2068                 lttng_enabler_link_bytecode(event_notifier->desc,
2069                         &event_notifier_group->ctx, &event_notifier->capture_bytecode_runtime_head,
2070                         &event_notifier_enabler->capture_bytecode_head);
2071
2072                 event_notifier->num_captures = event_notifier_enabler->num_captures;
2073         }
2074 end:
2075         return 0;
2076 }
2077
2078 static
2079 void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group)
2080 {
2081         struct lttng_event_notifier_enabler *event_notifier_enabler;
2082         struct lttng_event_notifier *event_notifier;
2083
2084         cds_list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node)
2085                 lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_enabler);
2086
2087         /*
2088          * For each event_notifier, if at least one of its enablers is enabled,
2089          * we enable the event_notifier, else we disable it.
2090          */
2091         cds_list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, node) {
2092                 struct lttng_enabler_ref *enabler_ref;
2093                 struct lttng_bytecode_runtime *runtime;
2094                 int enabled = 0, has_enablers_without_bytecode = 0;
2095
2096                 /* Enable event_notifiers */
2097                 cds_list_for_each_entry(enabler_ref,
2098                                 &event_notifier->enablers_ref_head, node) {
2099                         if (enabler_ref->ref->enabled) {
2100                                 enabled = 1;
2101                                 break;
2102                         }
2103                 }
2104
2105                 CMM_STORE_SHARED(event_notifier->enabled, enabled);
2106                 /*
2107                  * Sync tracepoint registration with event_notifier enabled
2108                  * state.
2109                  */
2110                 if (enabled) {
2111                         if (!event_notifier->registered)
2112                                 register_event_notifier(event_notifier);
2113                 } else {
2114                         if (event_notifier->registered)
2115                                 unregister_event_notifier(event_notifier);
2116                 }
2117
2118                 /* Check if has enablers without bytecode enabled */
2119                 cds_list_for_each_entry(enabler_ref,
2120                                 &event_notifier->enablers_ref_head, node) {
2121                         if (enabler_ref->ref->enabled
2122                                         && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) {
2123                                 has_enablers_without_bytecode = 1;
2124                                 break;
2125                         }
2126                 }
2127                 event_notifier->has_enablers_without_bytecode =
2128                         has_enablers_without_bytecode;
2129
2130                 /* Enable filters */
2131                 cds_list_for_each_entry(runtime,
2132                                 &event_notifier->filter_bytecode_runtime_head, node) {
2133                         lttng_bytecode_filter_sync_state(runtime);
2134                 }
2135
2136                 /* Enable captures. */
2137                 cds_list_for_each_entry(runtime,
2138                                 &event_notifier->capture_bytecode_runtime_head, node) {
2139                         lttng_bytecode_capture_sync_state(runtime);
2140                 }
2141         }
2142         __tracepoint_probe_prune_release_queue();
2143 }
2144
2145 /*
2146  * Apply enablers to session events, adding events to session if need
2147  * be. It is required after each modification applied to an active
2148  * session, and right before session "start".
2149  * "lazy" sync means we only sync if required.
2150  */
2151 static
2152 void lttng_session_lazy_sync_event_enablers(struct lttng_session *session)
2153 {
2154         /* We can skip if session is not active */
2155         if (!session->active)
2156                 return;
2157         lttng_session_sync_event_enablers(session);
2158 }
2159
2160 /*
2161  * Update all sessions with the given app context.
2162  * Called with ust lock held.
2163  * This is invoked when an application context gets loaded/unloaded. It
2164  * ensures the context callbacks are in sync with the application
2165  * context (either app context callbacks, or dummy callbacks).
2166  */
2167 void lttng_ust_context_set_session_provider(const char *name,
2168                 size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
2169                 void (*record)(struct lttng_ctx_field *field,
2170                         struct lttng_ust_lib_ring_buffer_ctx *ctx,
2171                         struct lttng_channel *chan),
2172                 void (*get_value)(struct lttng_ctx_field *field,
2173                         struct lttng_ctx_value *value))
2174 {
2175         struct lttng_session *session;
2176
2177         cds_list_for_each_entry(session, &sessions, node) {
2178                 struct lttng_channel *chan;
2179                 struct lttng_event *event;
2180                 int ret;
2181
2182                 ret = lttng_ust_context_set_provider_rcu(&session->ctx,
2183                                 name, get_size, record, get_value);
2184                 if (ret)
2185                         abort();
2186                 cds_list_for_each_entry(chan, &session->chan_head, node) {
2187                         ret = lttng_ust_context_set_provider_rcu(&chan->ctx,
2188                                         name, get_size, record, get_value);
2189                         if (ret)
2190                                 abort();
2191                 }
2192                 cds_list_for_each_entry(event, &session->events_head, node) {
2193                         ret = lttng_ust_context_set_provider_rcu(&event->ctx,
2194                                         name, get_size, record, get_value);
2195                         if (ret)
2196                                 abort();
2197                 }
2198         }
2199 }
2200
2201 /*
2202  * Update all event_notifier groups with the given app context.
2203  * Called with ust lock held.
2204  * This is invoked when an application context gets loaded/unloaded. It
2205  * ensures the context callbacks are in sync with the application
2206  * context (either app context callbacks, or dummy callbacks).
2207  */
2208 void lttng_ust_context_set_event_notifier_group_provider(const char *name,
2209                 size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
2210                 void (*record)(struct lttng_ctx_field *field,
2211                         struct lttng_ust_lib_ring_buffer_ctx *ctx,
2212                         struct lttng_channel *chan),
2213                 void (*get_value)(struct lttng_ctx_field *field,
2214                         struct lttng_ctx_value *value))
2215 {
2216         struct lttng_event_notifier_group *event_notifier_group;
2217
2218         cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
2219                 int ret;
2220
2221                 ret = lttng_ust_context_set_provider_rcu(
2222                                 &event_notifier_group->ctx,
2223                                 name, get_size, record, get_value);
2224                 if (ret)
2225                         abort();
2226         }
2227 }