liblttng-ust/lttng-events.c

   1 /*
   2  * lttng-events.c
   3  *
   4  * Holds LTTng per-session event registry.
   5  *
   6  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; only
  11  * version 2.1 of the License.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #include <urcu/list.h>
  26 #include <urcu/hlist.h>
  27 #include <pthread.h>
  28 #include <errno.h>
  29 #include <sys/shm.h>
  30 #include <sys/ipc.h>
  31 #include <stdint.h>
  32 #include <stddef.h>
  33 #include <inttypes.h>
  34 #include <time.h>
  35 #include <lttng/ust-endian.h>
  36 #include "clock.h"
  37
  38 #include <urcu-bp.h>
  39 #include <urcu/compiler.h>
  40 #include <urcu/uatomic.h>
  41 #include <urcu/arch.h>
  42
  43 #include <lttng/tracepoint.h>
  44 #include <lttng/ust-events.h>
  45
  46 #include <usterr-signal-safe.h>
  47 #include <helper.h>
  48 #include "error.h"
  49 #include "compat.h"
  50 #include "lttng-ust-uuid.h"
  51
  52 #include "tracepoint-internal.h"
  53 #include "lttng-tracer.h"
  54 #include "lttng-tracer-core.h"
  55 #include "wait.h"
  56 #include "../libringbuffer/shm.h"
  57 #include "jhash.h"
  58
  59 /*
  60  * The sessions mutex is the centralized mutex across UST tracing
  61  * control and probe registration. All operations within this file are
  62  * called by the communication thread, under ust_lock protection.
  63  */
  64 static pthread_mutex_t sessions_mutex = PTHREAD_MUTEX_INITIALIZER;
  65
  66 void ust_lock(void)
  67 {
  68         pthread_mutex_lock(&sessions_mutex);
  69 }
  70
  71 void ust_unlock(void)
  72 {
  73         pthread_mutex_unlock(&sessions_mutex);
  74 }
  75
  76 static CDS_LIST_HEAD(sessions);
  77
  78 static void _lttng_event_destroy(struct lttng_event *event);
  79 static int _lttng_event_unregister(struct lttng_event *event);
  80 static
  81 int _lttng_event_metadata_statedump(struct lttng_session *session,
  82                                   struct lttng_channel *chan,
  83                                   struct lttng_event *event);
  84 static
  85 int _lttng_session_metadata_statedump(struct lttng_session *session);
  86
  87 static
  88 void lttng_session_lazy_sync_enablers(struct lttng_session *session);
  89 static
  90 void lttng_session_sync_enablers(struct lttng_session *session);
  91 static
  92 void lttng_enabler_destroy(struct lttng_enabler *enabler);
  93
  94 static
  95 int lttng_loglevel_match(int loglevel,
  96                 unsigned int has_loglevel,
  97                 enum lttng_ust_loglevel_type req_type,
  98                 int req_loglevel)
  99 {
 100         if (req_type == LTTNG_UST_LOGLEVEL_ALL)
 101                 return 1;
 102         if (!has_loglevel)
 103                 loglevel = TRACE_DEFAULT;
 104         switch (req_type) {
 105         case LTTNG_UST_LOGLEVEL_RANGE:
 106                 if (loglevel <= req_loglevel || req_loglevel == -1)
 107                         return 1;
 108                 else
 109                         return 0;
 110         case LTTNG_UST_LOGLEVEL_SINGLE:
 111                 if (loglevel == req_loglevel || req_loglevel == -1)
 112                         return 1;
 113                 else
 114                         return 0;
 115         case LTTNG_UST_LOGLEVEL_ALL:
 116         default:
 117                 return 1;
 118         }
 119 }
 120
 121 void synchronize_trace(void)
 122 {
 123         synchronize_rcu();
 124 }
 125
 126 struct lttng_session *lttng_session_create(void)
 127 {
 128         struct lttng_session *session;
 129         int i;
 130
 131         session = zmalloc(sizeof(struct lttng_session));
 132         if (!session)
 133                 return NULL;
 134         CDS_INIT_LIST_HEAD(&session->chan_head);
 135         CDS_INIT_LIST_HEAD(&session->events_head);
 136         CDS_INIT_LIST_HEAD(&session->enablers_head);
 137         for (i = 0; i < LTTNG_UST_EVENT_HT_SIZE; i++)
 138                 CDS_INIT_HLIST_HEAD(&session->events_ht.table[i]);
 139         cds_list_add(&session->node, &sessions);
 140         return session;
 141 }
 142
 143 /*
 144  * Only used internally at session destruction.
 145  */
 146 static
 147 void _lttng_channel_unmap(struct lttng_channel *lttng_chan)
 148 {
 149         struct channel *chan;
 150         struct lttng_ust_shm_handle *handle;
 151
 152         cds_list_del(&lttng_chan->node);
 153         lttng_destroy_context(lttng_chan->ctx);
 154         chan = lttng_chan->chan;
 155         handle = lttng_chan->handle;
 156         /*
 157          * note: lttng_chan is private data contained within handle. It
 158          * will be freed along with the handle.
 159          */
 160         channel_destroy(chan, handle, 0);
 161 }
 162
 163 void lttng_session_destroy(struct lttng_session *session)
 164 {
 165         struct lttng_channel *chan, *tmpchan;
 166         struct lttng_event *event, *tmpevent;
 167         struct lttng_enabler *enabler, *tmpenabler;
 168         int ret;
 169
 170         CMM_ACCESS_ONCE(session->active) = 0;
 171         cds_list_for_each_entry(event, &session->events_head, node) {
 172                 ret = _lttng_event_unregister(event);
 173                 WARN_ON(ret);
 174         }
 175         synchronize_trace();    /* Wait for in-flight events to complete */
 176         cds_list_for_each_entry_safe(enabler, tmpenabler,
 177                         &session->enablers_head, node)
 178                 lttng_enabler_destroy(enabler);
 179         cds_list_for_each_entry_safe(event, tmpevent,
 180                         &session->events_head, node)
 181                 _lttng_event_destroy(event);
 182         cds_list_for_each_entry_safe(chan, tmpchan, &session->chan_head, node)
 183                 _lttng_channel_unmap(chan);
 184         cds_list_del(&session->node);
 185         free(session);
 186 }
 187
 188 int lttng_session_enable(struct lttng_session *session)
 189 {
 190         int ret = 0;
 191         struct lttng_channel *chan;
 192
 193         if (session->active) {
 194                 ret = -EBUSY;
 195                 goto end;
 196         }
 197
 198         /* We need to sync enablers with session before activation. */
 199         lttng_session_sync_enablers(session);
 200
 201         /*
 202          * Snapshot the number of events per channel to know the type of header
 203          * we need to use.
 204          */
 205         cds_list_for_each_entry(chan, &session->chan_head, node) {
 206                 if (chan->header_type)
 207                         continue;               /* don't change it if session stop/restart */
 208                 if (chan->free_event_id < 31)
 209                         chan->header_type = 1;  /* compact */
 210                 else
 211                         chan->header_type = 2;  /* large */
 212         }
 213
 214         CMM_ACCESS_ONCE(session->active) = 1;
 215         CMM_ACCESS_ONCE(session->been_active) = 1;
 216         ret = _lttng_session_metadata_statedump(session);
 217         if (ret)
 218                 CMM_ACCESS_ONCE(session->active) = 0;
 219 end:
 220         return ret;
 221 }
 222
 223 int lttng_session_disable(struct lttng_session *session)
 224 {
 225         int ret = 0;
 226
 227         if (!session->active) {
 228                 ret = -EBUSY;
 229                 goto end;
 230         }
 231         CMM_ACCESS_ONCE(session->active) = 0;
 232 end:
 233         return ret;
 234 }
 235
 236 int lttng_channel_enable(struct lttng_channel *channel)
 237 {
 238         int old;
 239
 240         if (channel == channel->session->metadata)
 241                 return -EPERM;
 242         old = uatomic_xchg(&channel->enabled, 1);
 243         if (old)
 244                 return -EEXIST;
 245         return 0;
 246 }
 247
 248 int lttng_channel_disable(struct lttng_channel *channel)
 249 {
 250         int old;
 251
 252         if (channel == channel->session->metadata)
 253                 return -EPERM;
 254         old = uatomic_xchg(&channel->enabled, 0);
 255         if (!old)
 256                 return -EEXIST;
 257         return 0;
 258 }
 259
 260 int lttng_event_enable(struct lttng_event *event)
 261 {
 262         int old;
 263
 264         if (event->chan == event->chan->session->metadata)
 265                 return -EPERM;
 266         old = uatomic_xchg(&event->enabled, 1);
 267         if (old)
 268                 return -EEXIST;
 269         return 0;
 270 }
 271
 272 int lttng_event_disable(struct lttng_event *event)
 273 {
 274         int old;
 275
 276         if (event->chan == event->chan->session->metadata)
 277                 return -EPERM;
 278         old = uatomic_xchg(&event->enabled, 0);
 279         if (!old)
 280                 return -EEXIST;
 281         return 0;
 282 }
 283
 284 /*
 285  * Supports event creation while tracing session is active.
 286  */
 287 static
 288 int lttng_event_create(const struct lttng_event_desc *desc,
 289                 struct lttng_channel *chan)
 290 {
 291         const char *event_name = desc->name;
 292         struct lttng_event *event;
 293         struct cds_hlist_head *head;
 294         struct cds_hlist_node *node;
 295         int ret = 0;
 296         size_t name_len = strlen(event_name);
 297         uint32_t hash;
 298
 299         if (chan->used_event_id == -1U) {
 300                 ret = -ENOMEM;
 301                 goto full;
 302         }
 303         hash = jhash(event_name, name_len, 0);
 304         head = &chan->session->events_ht.table[hash & (LTTNG_UST_EVENT_HT_SIZE - 1)];
 305         cds_hlist_for_each_entry(event, node, head, hlist) {
 306                 assert(event->desc);
 307                 if (!strncmp(event->desc->name,
 308                                 desc->name,
 309                                 LTTNG_UST_SYM_NAME_LEN - 1)) {
 310                         ret = -EEXIST;
 311                         goto exist;
 312                 }
 313         }
 314
 315         /*
 316          * Check if loglevel match. Refuse to connect event if not.
 317          */
 318         event = zmalloc(sizeof(struct lttng_event));
 319         if (!event) {
 320                 ret = -ENOMEM;
 321                 goto cache_error;
 322         }
 323         event->chan = chan;
 324
 325         /*
 326          * used_event_id counts the maximum number of event IDs that can
 327          * register if all probes register.
 328          */
 329         chan->used_event_id++;
 330         event->enabled = 1;
 331         CDS_INIT_LIST_HEAD(&event->bytecode_runtime_head);
 332         CDS_INIT_LIST_HEAD(&event->enablers_ref_head);
 333         event->desc = desc;
 334         /* Populate lttng_event structure before tracepoint registration. */
 335         cmm_smp_wmb();
 336         ret = __tracepoint_probe_register(event_name,
 337                         desc->probe_callback,
 338                         event, desc->signature);
 339         if (ret)
 340                 goto register_error;
 341         event->id = chan->free_event_id++;
 342         ret = _lttng_event_metadata_statedump(chan->session, chan, event);
 343         if (ret)
 344                 goto statedump_error;
 345         cds_list_add(&event->node, &chan->session->events_head);
 346         cds_hlist_add_head(&event->hlist, head);
 347         return 0;
 348
 349 statedump_error:
 350         WARN_ON_ONCE(__tracepoint_probe_unregister(event_name,
 351                                 desc->probe_callback,
 352                                 event));
 353 register_error:
 354         free(event);
 355 cache_error:
 356 exist:
 357 full:
 358         return ret;
 359 }
 360
 361 static
 362 int lttng_desc_match_wildcard_enabler(const struct lttng_event_desc *desc,
 363                 struct lttng_enabler *enabler)
 364 {
 365         int loglevel = 0;
 366         unsigned int has_loglevel;
 367
 368         assert(enabler->type == LTTNG_ENABLER_WILDCARD);
 369         /* Compare excluding final '*' */
 370         if (strncmp(desc->name, enabler->event_param.name,
 371                         strlen(enabler->event_param.name) - 1))
 372                 return 0;
 373         if (desc->loglevel) {
 374                 loglevel = *(*desc->loglevel);
 375                 has_loglevel = 1;
 376         }
 377         if (!lttng_loglevel_match(loglevel,
 378                         has_loglevel,
 379                         enabler->event_param.loglevel_type,
 380                         enabler->event_param.loglevel))
 381                 return 0;
 382         return 1;
 383 }
 384
 385 static
 386 int lttng_desc_match_event_enabler(const struct lttng_event_desc *desc,
 387                 struct lttng_enabler *enabler)
 388 {
 389         int loglevel = 0;
 390         unsigned int has_loglevel = 0;
 391
 392         assert(enabler->type == LTTNG_ENABLER_EVENT);
 393         if (strcmp(desc->name, enabler->event_param.name))
 394                 return 0;
 395         if (desc->loglevel) {
 396                 loglevel = *(*desc->loglevel);
 397                 has_loglevel = 1;
 398         }
 399         if (!lttng_loglevel_match(loglevel,
 400                         has_loglevel,
 401                         enabler->event_param.loglevel_type,
 402                         enabler->event_param.loglevel))
 403                 return 0;
 404         return 1;
 405 }
 406
 407 static
 408 int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 409                 struct lttng_enabler *enabler)
 410 {
 411         switch (enabler->type) {
 412         case LTTNG_ENABLER_WILDCARD:
 413                 return lttng_desc_match_wildcard_enabler(desc, enabler);
 414         case LTTNG_ENABLER_EVENT:
 415                 return lttng_desc_match_event_enabler(desc, enabler);
 416         default:
 417                 return -EINVAL;
 418         }
 419 }
 420
 421 static
 422 int lttng_event_match_enabler(struct lttng_event *event,
 423                 struct lttng_enabler *enabler)
 424 {
 425         return lttng_desc_match_enabler(event->desc, enabler);
 426 }
 427
 428 static
 429 struct lttng_enabler_ref * lttng_event_enabler_ref(struct lttng_event *event,
 430                 struct lttng_enabler *enabler)
 431 {
 432         struct lttng_enabler_ref *enabler_ref;
 433
 434         cds_list_for_each_entry(enabler_ref,
 435                         &event->enablers_ref_head, node) {
 436                 if (enabler_ref->ref == enabler)
 437                         return enabler_ref;
 438         }
 439         return NULL;
 440 }
 441
 442 /*
 443  * Create struct lttng_event if it is missing and present in the list of
 444  * tracepoint probes.
 445  */
 446 static
 447 void lttng_create_event_if_missing(struct lttng_enabler *enabler)
 448 {
 449         struct lttng_session *session = enabler->chan->session;
 450         struct lttng_probe_desc *probe_desc;
 451         const struct lttng_event_desc *desc;
 452         struct lttng_event *event;
 453         int i;
 454         struct cds_list_head *probe_list;
 455
 456         probe_list = lttng_get_probe_list_head();
 457         /*
 458          * For each probe event, if we find that a probe event matches
 459          * our enabler, create an associated lttng_event if not
 460          * already present.
 461          */
 462         cds_list_for_each_entry(probe_desc, probe_list, head) {
 463                 for (i = 0; i < probe_desc->nr_events; i++) {
 464                         int found = 0, ret;
 465                         struct cds_hlist_head *head;
 466                         struct cds_hlist_node *node;
 467                         const char *event_name;
 468                         size_t name_len;
 469                         uint32_t hash;
 470
 471                         desc = probe_desc->event_desc[i];
 472                         if (!lttng_desc_match_enabler(desc, enabler))
 473                                 continue;
 474                         event_name = desc->name;
 475                         name_len = strlen(event_name);
 476
 477                         /*
 478                          * Check if already created.
 479                          */
 480                         hash = jhash(event_name, name_len, 0);
 481                         head = &session->events_ht.table[hash & (LTTNG_UST_EVENT_HT_SIZE - 1)];
 482                         cds_hlist_for_each_entry(event, node, head, hlist) {
 483                                 if (event->desc == desc)
 484                                         found = 1;
 485                         }
 486                         if (found)
 487                                 continue;
 488
 489                         /*
 490                          * We need to create an event for this
 491                          * event probe.
 492                          */
 493                         ret = lttng_event_create(probe_desc->event_desc[i],
 494                                         enabler->chan);
 495                         if (ret) {
 496                                 DBG("Unable to create event %s\n",
 497                                         probe_desc->event_desc[i]->name);
 498                         }
 499                 }
 500         }
 501 }
 502
 503 /*
 504  * Create events associated with an enabler (if not already present),
 505  * and add backward reference from the event to the enabler.
 506  */
 507 static
 508 int lttng_enabler_ref_events(struct lttng_enabler *enabler)
 509 {
 510         struct lttng_session *session = enabler->chan->session;
 511         struct lttng_event *event;
 512
 513         /* First ensure that probe events are created for this enabler. */
 514         lttng_create_event_if_missing(enabler);
 515
 516         /* For each event matching enabler in session event list. */
 517         cds_list_for_each_entry(event, &session->events_head, node) {
 518                 struct lttng_enabler_ref *enabler_ref;
 519
 520                 if (!lttng_event_match_enabler(event, enabler))
 521                         continue;
 522
 523                 enabler_ref = lttng_event_enabler_ref(event, enabler);
 524                 if (!enabler_ref) {
 525                         /*
 526                          * If no backward ref, create it.
 527                          * Add backward ref from event to enabler.
 528                          */
 529                         enabler_ref = zmalloc(sizeof(*enabler_ref));
 530                         if (!enabler_ref)
 531                                 return -ENOMEM;
 532                         enabler_ref->ref = enabler;
 533                         cds_list_add(&enabler_ref->node,
 534                                 &event->enablers_ref_head);
 535                 }
 536
 537                 /*
 538                  * Link filter bytecodes if not linked yet.
 539                  */
 540                 lttng_enabler_event_link_bytecode(event, enabler);
 541
 542                 /* TODO: merge event context. */
 543         }
 544         return 0;
 545 }
 546
 547 /*
 548  * Called at library load: connect the probe on all enablers matching
 549  * this event.
 550  * called with session mutex held.
 551  * TODO: currently, for each desc added, we iterate on all event desc
 552  * (inefficient). We should create specific code that only target the
 553  * added desc.
 554  */
 555 int lttng_fix_pending_event_desc(const struct lttng_event_desc *desc)
 556 {
 557         struct lttng_session *session;
 558
 559         cds_list_for_each_entry(session, &sessions, node) {
 560                 lttng_session_lazy_sync_enablers(session);
 561         }
 562         return 0;
 563 }
 564
 565 /*
 566  * Only used internally at session destruction.
 567  */
 568 int _lttng_event_unregister(struct lttng_event *event)
 569 {
 570         return __tracepoint_probe_unregister(event->desc->name,
 571                                           event->desc->probe_callback,
 572                                           event);
 573 }
 574
 575 /*
 576  * Only used internally at session destruction.
 577  */
 578 static
 579 void _lttng_event_destroy(struct lttng_event *event)
 580 {
 581         struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
 582
 583         cds_list_del(&event->node);
 584         lttng_destroy_context(event->ctx);
 585         lttng_free_event_filter_runtime(event);
 586         /* Free event enabler refs */
 587         cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
 588                         &event->enablers_ref_head, node)
 589                 free(enabler_ref);
 590         free(event);
 591 }
 592
 593 /*
 594  * We have exclusive access to our metadata buffer (protected by the
 595  * ust_lock), so we can do racy operations such as looking for
 596  * remaining space left in packet and write, since mutual exclusion
 597  * protects us from concurrent writes.
 598  */
 599 int lttng_metadata_printf(struct lttng_session *session,
 600                           const char *fmt, ...)
 601 {
 602         struct lttng_ust_lib_ring_buffer_ctx ctx;
 603         struct lttng_channel *chan = session->metadata;
 604         char *str = NULL;
 605         int ret = 0, waitret;
 606         size_t len, reserve_len, pos;
 607         va_list ap;
 608
 609         WARN_ON_ONCE(!CMM_ACCESS_ONCE(session->active));
 610
 611         va_start(ap, fmt);
 612         ret = vasprintf(&str, fmt, ap);
 613         va_end(ap);
 614         if (ret < 0)
 615                 return -ENOMEM;
 616
 617         len = strlen(str);
 618         pos = 0;
 619
 620         for (pos = 0; pos < len; pos += reserve_len) {
 621                 reserve_len = min_t(size_t,
 622                                 chan->ops->packet_avail_size(chan->chan, chan->handle),
 623                                 len - pos);
 624                 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
 625                                          sizeof(char), -1, chan->handle);
 626                 /*
 627                  * We don't care about metadata buffer's records lost
 628                  * count, because we always retry here. Report error if
 629                  * we need to bail out after timeout or being
 630                  * interrupted.
 631                  */
 632                 waitret = wait_cond_interruptible_timeout(
 633                         ({
 634                                 ret = chan->ops->event_reserve(&ctx, 0);
 635                                 ret != -ENOBUFS || !ret;
 636                         }),
 637                         LTTNG_METADATA_TIMEOUT_MSEC);
 638                 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
 639                         DBG("LTTng: Failure to write metadata to buffers (%s)\n",
 640                                 waitret == -EINTR ? "interrupted" :
 641                                         (ret == -ENOBUFS ? "timeout" : "I/O error"));
 642                         if (waitret == -EINTR)
 643                                 ret = waitret;
 644                         goto end;
 645                 }
 646                 chan->ops->event_write(&ctx, &str[pos], reserve_len);
 647                 chan->ops->event_commit(&ctx);
 648         }
 649 end:
 650         free(str);
 651         return ret;
 652 }
 653
 654 static
 655 int _lttng_field_statedump(struct lttng_session *session,
 656                          const struct lttng_event_field *field)
 657 {
 658         int ret = 0;
 659
 660         if (field->nowrite)
 661                 return 0;
 662
 663         switch (field->type.atype) {
 664         case atype_integer:
 665                 ret = lttng_metadata_printf(session,
 666                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
 667                         field->type.u.basic.integer.size,
 668                         field->type.u.basic.integer.alignment,
 669                         field->type.u.basic.integer.signedness,
 670                         (field->type.u.basic.integer.encoding == lttng_encode_none)
 671                                 ? "none"
 672                                 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
 673                                         ? "UTF8"
 674                                         : "ASCII",
 675                         field->type.u.basic.integer.base,
 676 #if (BYTE_ORDER == BIG_ENDIAN)
 677                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 678 #else
 679                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 680 #endif
 681                         field->name);
 682                 break;
 683         case atype_float:
 684                 ret = lttng_metadata_printf(session,
 685                         "               floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n",
 686                         field->type.u.basic._float.exp_dig,
 687                         field->type.u.basic._float.mant_dig,
 688                         field->type.u.basic._float.alignment,
 689 #if (BYTE_ORDER == BIG_ENDIAN)
 690                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 691 #else
 692                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 693 #endif
 694                         field->name);
 695                 break;
 696         case atype_enum:
 697                 ret = lttng_metadata_printf(session,
 698                         "               %s %s;\n",
 699                         field->type.u.basic.enumeration.name,
 700                         field->name);
 701                 break;
 702         case atype_array:
 703         {
 704                 const struct lttng_basic_type *elem_type;
 705
 706                 elem_type = &field->type.u.array.elem_type;
 707                 ret = lttng_metadata_printf(session,
 708                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
 709                         elem_type->u.basic.integer.size,
 710                         elem_type->u.basic.integer.alignment,
 711                         elem_type->u.basic.integer.signedness,
 712                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 713                                 ? "none"
 714                                 : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 715                                         ? "UTF8"
 716                                         : "ASCII",
 717                         elem_type->u.basic.integer.base,
 718 #if (BYTE_ORDER == BIG_ENDIAN)
 719                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 720 #else
 721                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 722 #endif
 723                         field->name, field->type.u.array.length);
 724                 break;
 725         }
 726         case atype_sequence:
 727         {
 728                 const struct lttng_basic_type *elem_type;
 729                 const struct lttng_basic_type *length_type;
 730
 731                 elem_type = &field->type.u.sequence.elem_type;
 732                 length_type = &field->type.u.sequence.length_type;
 733                 ret = lttng_metadata_printf(session,
 734                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
 735                         length_type->u.basic.integer.size,
 736                         (unsigned int) length_type->u.basic.integer.alignment,
 737                         length_type->u.basic.integer.signedness,
 738                         (length_type->u.basic.integer.encoding == lttng_encode_none)
 739                                 ? "none"
 740                                 : ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
 741                                         ? "UTF8"
 742                                         : "ASCII"),
 743                         length_type->u.basic.integer.base,
 744 #if (BYTE_ORDER == BIG_ENDIAN)
 745                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 746 #else
 747                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 748 #endif
 749                         field->name);
 750                 if (ret)
 751                         return ret;
 752
 753                 ret = lttng_metadata_printf(session,
 754                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
 755                         elem_type->u.basic.integer.size,
 756                         (unsigned int) elem_type->u.basic.integer.alignment,
 757                         elem_type->u.basic.integer.signedness,
 758                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 759                                 ? "none"
 760                                 : ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 761                                         ? "UTF8"
 762                                         : "ASCII"),
 763                         elem_type->u.basic.integer.base,
 764 #if (BYTE_ORDER == BIG_ENDIAN)
 765                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 766 #else
 767                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 768 #endif
 769                         field->name,
 770                         field->name);
 771                 break;
 772         }
 773
 774         case atype_string:
 775                 /* Default encoding is UTF8 */
 776                 ret = lttng_metadata_printf(session,
 777                         "               string%s _%s;\n",
 778                         field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 779                                 " { encoding = ASCII; }" : "",
 780                         field->name);
 781                 break;
 782         default:
 783                 WARN_ON_ONCE(1);
 784                 return -EINVAL;
 785         }
 786         return ret;
 787 }
 788
 789 static
 790 int _lttng_context_metadata_statedump(struct lttng_session *session,
 791                                     struct lttng_ctx *ctx)
 792 {
 793         int ret = 0;
 794         int i;
 795
 796         if (!ctx)
 797                 return 0;
 798         for (i = 0; i < ctx->nr_fields; i++) {
 799                 const struct lttng_ctx_field *field = &ctx->fields[i];
 800
 801                 ret = _lttng_field_statedump(session, &field->event_field);
 802                 if (ret)
 803                         return ret;
 804         }
 805         return ret;
 806 }
 807
 808 static
 809 int _lttng_fields_metadata_statedump(struct lttng_session *session,
 810                                    struct lttng_event *event)
 811 {
 812         const struct lttng_event_desc *desc = event->desc;
 813         int ret = 0;
 814         int i;
 815
 816         for (i = 0; i < desc->nr_fields; i++) {
 817                 const struct lttng_event_field *field = &desc->fields[i];
 818
 819                 ret = _lttng_field_statedump(session, field);
 820                 if (ret)
 821                         return ret;
 822         }
 823         return ret;
 824 }
 825
 826 static
 827 int _lttng_event_metadata_statedump(struct lttng_session *session,
 828                                   struct lttng_channel *chan,
 829                                   struct lttng_event *event)
 830 {
 831         int ret = 0;
 832         int loglevel = TRACE_DEFAULT;
 833
 834         if (event->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 835                 return 0;
 836         if (chan == session->metadata)
 837                 return 0;
 838         /*
 839          * Don't print events for which probe load is pending.
 840          */
 841         if (!event->desc)
 842                 return 0;
 843
 844         ret = lttng_metadata_printf(session,
 845                 "event {\n"
 846                 "       name = \"%s\";\n"
 847                 "       id = %u;\n"
 848                 "       stream_id = %u;\n",
 849                 event->desc->name,
 850                 event->id,
 851                 event->chan->id);
 852         if (ret)
 853                 goto end;
 854
 855         if (event->desc->loglevel)
 856                 loglevel = *(*event->desc->loglevel);
 857
 858         ret = lttng_metadata_printf(session,
 859                 "       loglevel = %d;\n",
 860                 loglevel);
 861         if (ret)
 862                 goto end;
 863
 864         if (event->desc->u.ext.model_emf_uri) {
 865                 ret = lttng_metadata_printf(session,
 866                         "       model.emf.uri = \"%s\";\n",
 867                         *(event->desc->u.ext.model_emf_uri));
 868                 if (ret)
 869                         goto end;
 870         }
 871
 872         if (event->ctx) {
 873                 ret = lttng_metadata_printf(session,
 874                         "       context := struct {\n");
 875                 if (ret)
 876                         goto end;
 877         }
 878         ret = _lttng_context_metadata_statedump(session, event->ctx);
 879         if (ret)
 880                 goto end;
 881         if (event->ctx) {
 882                 ret = lttng_metadata_printf(session,
 883                         "       };\n");
 884                 if (ret)
 885                         goto end;
 886         }
 887
 888         ret = lttng_metadata_printf(session,
 889                 "       fields := struct {\n"
 890                 );
 891         if (ret)
 892                 goto end;
 893
 894         ret = _lttng_fields_metadata_statedump(session, event);
 895         if (ret)
 896                 goto end;
 897
 898         /*
 899          * LTTng space reservation can only reserve multiples of the
 900          * byte size.
 901          */
 902         ret = lttng_metadata_printf(session,
 903                 "       };\n"
 904                 "};\n\n");
 905         if (ret)
 906                 goto end;
 907
 908         event->metadata_dumped = 1;
 909 end:
 910         return ret;
 911
 912 }
 913
 914 static
 915 int _lttng_channel_metadata_statedump(struct lttng_session *session,
 916                                     struct lttng_channel *chan)
 917 {
 918         int ret = 0;
 919
 920         if (chan->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 921                 return 0;
 922         if (chan == session->metadata)
 923                 return 0;
 924
 925         WARN_ON_ONCE(!chan->header_type);
 926         ret = lttng_metadata_printf(session,
 927                 "stream {\n"
 928                 "       id = %u;\n"
 929                 "       event.header := %s;\n"
 930                 "       packet.context := struct packet_context;\n",
 931                 chan->id,
 932                 chan->header_type == 1 ? "struct event_header_compact" :
 933                         "struct event_header_large");
 934         if (ret)
 935                 goto end;
 936
 937         if (chan->ctx) {
 938                 ret = lttng_metadata_printf(session,
 939                         "       event.context := struct {\n");
 940                 if (ret)
 941                         goto end;
 942         }
 943         ret = _lttng_context_metadata_statedump(session, chan->ctx);
 944         if (ret)
 945                 goto end;
 946         if (chan->ctx) {
 947                 ret = lttng_metadata_printf(session,
 948                         "       };\n");
 949                 if (ret)
 950                         goto end;
 951         }
 952
 953         ret = lttng_metadata_printf(session,
 954                 "};\n\n");
 955
 956         chan->metadata_dumped = 1;
 957 end:
 958         return ret;
 959 }
 960
 961 static
 962 int _lttng_stream_packet_context_declare(struct lttng_session *session)
 963 {
 964         return lttng_metadata_printf(session,
 965                 "struct packet_context {\n"
 966                 "       uint64_clock_monotonic_t timestamp_begin;\n"
 967                 "       uint64_clock_monotonic_t timestamp_end;\n"
 968                 "       uint64_t content_size;\n"
 969                 "       uint64_t packet_size;\n"
 970                 "       unsigned long events_discarded;\n"
 971                 "       uint32_t cpu_id;\n"
 972                 "};\n\n"
 973                 );
 974 }
 975
 976 /*
 977  * Compact header:
 978  * id: range: 0 - 30.
 979  * id 31 is reserved to indicate an extended header.
 980  *
 981  * Large header:
 982  * id: range: 0 - 65534.
 983  * id 65535 is reserved to indicate an extended header.
 984  */
 985 static
 986 int _lttng_event_header_declare(struct lttng_session *session)
 987 {
 988         return lttng_metadata_printf(session,
 989         "struct event_header_compact {\n"
 990         "       enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
 991         "       variant <id> {\n"
 992         "               struct {\n"
 993         "                       uint27_clock_monotonic_t timestamp;\n"
 994         "               } compact;\n"
 995         "               struct {\n"
 996         "                       uint32_t id;\n"
 997         "                       uint64_clock_monotonic_t timestamp;\n"
 998         "               } extended;\n"
 999         "       } v;\n"
1000         "} align(%u);\n"
1001         "\n"
1002         "struct event_header_large {\n"
1003         "       enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
1004         "       variant <id> {\n"
1005         "               struct {\n"
1006         "                       uint32_clock_monotonic_t timestamp;\n"
1007         "               } compact;\n"
1008         "               struct {\n"
1009         "                       uint32_t id;\n"
1010         "                       uint64_clock_monotonic_t timestamp;\n"
1011         "               } extended;\n"
1012         "       } v;\n"
1013         "} align(%u);\n\n",
1014         lttng_alignof(uint32_t) * CHAR_BIT,
1015         lttng_alignof(uint16_t) * CHAR_BIT
1016         );
1017 }
1018
1019 /*
1020  * Approximation of NTP time of day to clock monotonic correlation,
1021  * taken at start of trace.
1022  * Yes, this is only an approximation. Yes, we can (and will) do better
1023  * in future versions.
1024  */
1025 static
1026 uint64_t measure_clock_offset(void)
1027 {
1028         uint64_t offset, monotonic[2], realtime;
1029         struct timespec rts = { 0, 0 };
1030         int ret;
1031
1032         monotonic[0] = trace_clock_read64();
1033         ret = clock_gettime(CLOCK_REALTIME, &rts);
1034         if (ret < 0)
1035                 return 0;
1036         monotonic[1] = trace_clock_read64();
1037         offset = (monotonic[0] + monotonic[1]) >> 1;
1038         realtime = (uint64_t) rts.tv_sec * 1000000000ULL;
1039         realtime += rts.tv_nsec;
1040         offset = realtime - offset;
1041         return offset;
1042 }
1043
1044 /*
1045  * Output metadata into this session's metadata buffers.
1046  */
1047 static
1048 int _lttng_session_metadata_statedump(struct lttng_session *session)
1049 {
1050         unsigned char *uuid_c;
1051         char uuid_s[LTTNG_UST_UUID_STR_LEN],
1052                 clock_uuid_s[LTTNG_UST_UUID_STR_LEN];
1053         struct lttng_channel *chan;
1054         struct lttng_event *event;
1055         int ret = 0;
1056         char procname[LTTNG_UST_PROCNAME_LEN] = "";
1057         char hostname[HOST_NAME_MAX];
1058
1059         if (!CMM_ACCESS_ONCE(session->active))
1060                 return 0;
1061         if (session->metadata_dumped)
1062                 goto skip_session;
1063         if (!session->metadata) {
1064                 DBG("LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n");
1065                 return -EPERM;
1066         }
1067         uuid_c = session->metadata->uuid;
1068
1069         snprintf(uuid_s, sizeof(uuid_s),
1070                 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
1071                 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
1072                 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
1073                 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
1074                 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
1075
1076         ret = lttng_metadata_printf(session,
1077                 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
1078                 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
1079                 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
1080                 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
1081                 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
1082                 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
1083                 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
1084                 "\n"
1085                 "trace {\n"
1086                 "       major = %u;\n"
1087                 "       minor = %u;\n"
1088                 "       uuid = \"%s\";\n"
1089                 "       byte_order = %s;\n"
1090                 "       packet.header := struct {\n"
1091                 "               uint32_t magic;\n"
1092                 "               uint8_t  uuid[16];\n"
1093                 "               uint32_t stream_id;\n"
1094                 "       };\n"
1095                 "};\n\n",
1096                 lttng_alignof(uint8_t) * CHAR_BIT,
1097                 lttng_alignof(uint16_t) * CHAR_BIT,
1098                 lttng_alignof(uint32_t) * CHAR_BIT,
1099                 lttng_alignof(uint64_t) * CHAR_BIT,
1100                 sizeof(unsigned long) * CHAR_BIT,
1101                 lttng_alignof(unsigned long) * CHAR_BIT,
1102                 CTF_SPEC_MAJOR,
1103                 CTF_SPEC_MINOR,
1104                 uuid_s,
1105 #if (BYTE_ORDER == BIG_ENDIAN)
1106                 "be"
1107 #else
1108                 "le"
1109 #endif
1110                 );
1111         if (ret)
1112                 goto end;
1113
1114         /* ignore error, just use empty string if error. */
1115         hostname[0] = '\0';
1116         ret = gethostname(hostname, sizeof(hostname));
1117         if (ret && errno == ENAMETOOLONG)
1118                 hostname[HOST_NAME_MAX - 1] = '\0';
1119         lttng_ust_getprocname(procname);
1120         procname[LTTNG_UST_PROCNAME_LEN - 1] = '\0';
1121         ret = lttng_metadata_printf(session,
1122                 "env {\n"
1123                 "       hostname = \"%s\";\n"
1124                 "       vpid = %d;\n"
1125                 "       procname = \"%s\";\n"
1126                 "       domain = \"ust\";\n"
1127                 "       tracer_name = \"lttng-ust\";\n"
1128                 "       tracer_major = %u;\n"
1129                 "       tracer_minor = %u;\n"
1130                 "       tracer_patchlevel = %u;\n"
1131                 "};\n\n",
1132                 hostname,
1133                 (int) getpid(),
1134                 procname,
1135                 LTTNG_UST_MAJOR_VERSION,
1136                 LTTNG_UST_MINOR_VERSION,
1137                 LTTNG_UST_PATCHLEVEL_VERSION
1138                 );
1139         if (ret)
1140                 goto end;
1141
1142         ret = lttng_metadata_printf(session,
1143                 "clock {\n"
1144                 "       name = %s;\n",
1145                 "monotonic"
1146                 );
1147         if (ret)
1148                 goto end;
1149
1150         if (!trace_clock_uuid(clock_uuid_s)) {
1151                 ret = lttng_metadata_printf(session,
1152                         "       uuid = \"%s\";\n",
1153                         clock_uuid_s
1154                         );
1155                 if (ret)
1156                         goto end;
1157         }
1158
1159         ret = lttng_metadata_printf(session,
1160                 "       description = \"Monotonic Clock\";\n"
1161                 "       freq = %" PRIu64 "; /* Frequency, in Hz */\n"
1162                 "       /* clock value offset from Epoch is: offset * (1/freq) */\n"
1163                 "       offset = %" PRIu64 ";\n"
1164                 "};\n\n",
1165                 trace_clock_freq(),
1166                 measure_clock_offset()
1167                 );
1168         if (ret)
1169                 goto end;
1170
1171         ret = lttng_metadata_printf(session,
1172                 "typealias integer {\n"
1173                 "       size = 27; align = 1; signed = false;\n"
1174                 "       map = clock.monotonic.value;\n"
1175                 "} := uint27_clock_monotonic_t;\n"
1176                 "\n"
1177                 "typealias integer {\n"
1178                 "       size = 32; align = %u; signed = false;\n"
1179                 "       map = clock.monotonic.value;\n"
1180                 "} := uint32_clock_monotonic_t;\n"
1181                 "\n"
1182                 "typealias integer {\n"
1183                 "       size = 64; align = %u; signed = false;\n"
1184                 "       map = clock.monotonic.value;\n"
1185                 "} := uint64_clock_monotonic_t;\n\n",
1186                 lttng_alignof(uint32_t) * CHAR_BIT,
1187                 lttng_alignof(uint64_t) * CHAR_BIT
1188                 );
1189         if (ret)
1190                 goto end;
1191
1192         ret = _lttng_stream_packet_context_declare(session);
1193         if (ret)
1194                 goto end;
1195
1196         ret = _lttng_event_header_declare(session);
1197         if (ret)
1198                 goto end;
1199
1200 skip_session:
1201         cds_list_for_each_entry(chan, &session->chan_head, node) {
1202                 ret = _lttng_channel_metadata_statedump(session, chan);
1203                 if (ret)
1204                         goto end;
1205         }
1206
1207         cds_list_for_each_entry(event, &session->events_head, node) {
1208                 ret = _lttng_event_metadata_statedump(session, event->chan, event);
1209                 if (ret)
1210                         goto end;
1211         }
1212         session->metadata_dumped = 1;
1213 end:
1214         return ret;
1215 }
1216
1217 void lttng_ust_events_exit(void)
1218 {
1219         struct lttng_session *session, *tmpsession;
1220
1221         cds_list_for_each_entry_safe(session, tmpsession, &sessions, node)
1222                 lttng_session_destroy(session);
1223 }
1224
1225 /*
1226  * Enabler management.
1227  */
1228 struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type,
1229                 struct lttng_ust_event *event_param,
1230                 struct lttng_channel *chan)
1231 {
1232         struct lttng_enabler *enabler;
1233
1234         enabler = zmalloc(sizeof(*enabler));
1235         if (!enabler)
1236                 return NULL;
1237         enabler->type = type;
1238         CDS_INIT_LIST_HEAD(&enabler->filter_bytecode_head);
1239         memcpy(&enabler->event_param, event_param,
1240                 sizeof(enabler->event_param));
1241         enabler->chan = chan;
1242         /* ctx left NULL */
1243         enabler->enabled = 1;
1244         cds_list_add(&enabler->node, &enabler->chan->session->enablers_head);
1245         lttng_session_lazy_sync_enablers(enabler->chan->session);
1246         return enabler;
1247 }
1248
1249 int lttng_enabler_enable(struct lttng_enabler *enabler)
1250 {
1251         enabler->enabled = 1;
1252         lttng_session_lazy_sync_enablers(enabler->chan->session);
1253         return 0;
1254 }
1255
1256 int lttng_enabler_disable(struct lttng_enabler *enabler)
1257 {
1258         if (enabler->chan == enabler->chan->session->metadata)
1259                 return -EPERM;
1260         enabler->enabled = 0;
1261         lttng_session_lazy_sync_enablers(enabler->chan->session);
1262         return 0;
1263 }
1264
1265 int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
1266                 struct lttng_ust_filter_bytecode_node *bytecode)
1267 {
1268         bytecode->enabler = enabler;
1269         cds_list_add_tail(&bytecode->node, &enabler->filter_bytecode_head);
1270         lttng_session_lazy_sync_enablers(enabler->chan->session);
1271         return 0;
1272 }
1273
1274 int lttng_attach_context(struct lttng_ust_context *context_param,
1275                 struct lttng_ctx **ctx, struct lttng_session *session)
1276 {
1277         /*
1278          * We cannot attach a context after trace has been started for a
1279          * session because the metadata does not allow expressing this
1280          * information outside of the original channel scope.
1281          */
1282         if (session->been_active)
1283                 return -EPERM;
1284
1285         switch (context_param->ctx) {
1286         case LTTNG_UST_CONTEXT_PTHREAD_ID:
1287                 return lttng_add_pthread_id_to_ctx(ctx);
1288         case LTTNG_UST_CONTEXT_VTID:
1289                 return lttng_add_vtid_to_ctx(ctx);
1290         case LTTNG_UST_CONTEXT_VPID:
1291                 return lttng_add_vpid_to_ctx(ctx);
1292         case LTTNG_UST_CONTEXT_PROCNAME:
1293                 return lttng_add_procname_to_ctx(ctx);
1294         default:
1295                 return -EINVAL;
1296         }
1297 }
1298
1299 int lttng_enabler_attach_context(struct lttng_enabler *enabler,
1300                 struct lttng_ust_context *context_param)
1301 {
1302 #if 0   // disabled for now.
1303         struct lttng_session *session = enabler->chan->session;
1304         int ret;
1305
1306         ret = lttng_attach_context(context_param, &enabler->ctx,
1307                         session);
1308         if (ret)
1309                 return ret;
1310         lttng_session_lazy_sync_enablers(enabler->chan->session);
1311 #endif
1312         return -ENOSYS;
1313 }
1314
1315 static
1316 void lttng_enabler_destroy(struct lttng_enabler *enabler)
1317 {
1318         struct lttng_ust_filter_bytecode_node *filter_node, *tmp_filter_node;
1319
1320         /* Destroy filter bytecode */
1321         cds_list_for_each_entry_safe(filter_node, tmp_filter_node,
1322                         &enabler->filter_bytecode_head, node) {
1323                 free(filter_node);
1324         }
1325
1326         /* Destroy contexts */
1327         lttng_destroy_context(enabler->ctx);
1328
1329         cds_list_del(&enabler->node);
1330         free(enabler);
1331 }
1332
1333 /*
1334  * lttng_session_sync_enablers should be called just before starting a
1335  * session.
1336  */
1337 static
1338 void lttng_session_sync_enablers(struct lttng_session *session)
1339 {
1340         struct lttng_enabler *enabler;
1341         struct lttng_event *event;
1342
1343         cds_list_for_each_entry(enabler, &session->enablers_head, node)
1344                 lttng_enabler_ref_events(enabler);
1345         /*
1346          * For each event, if at least one of its enablers is enabled,
1347          * we enable the event, else we disable it.
1348          */
1349         cds_list_for_each_entry(event, &session->events_head, node) {
1350                 struct lttng_enabler_ref *enabler_ref;
1351                 struct lttng_bytecode_runtime *runtime;
1352                 int enabled = 0, has_enablers_without_bytecode = 0;
1353
1354                 /* Enable events */
1355                 cds_list_for_each_entry(enabler_ref,
1356                                 &event->enablers_ref_head, node) {
1357                         if (enabler_ref->ref->enabled) {
1358                                 enabled = 1;
1359                                 break;
1360                         }
1361                 }
1362                 event->enabled = enabled;
1363
1364                 /* Check if has enablers without bytecode enabled */
1365                 cds_list_for_each_entry(enabler_ref,
1366                                 &event->enablers_ref_head, node) {
1367                         if (enabler_ref->ref->enabled
1368                                         && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) {
1369                                 has_enablers_without_bytecode = 1;
1370                                 break;
1371                         }
1372                 }
1373                 event->has_enablers_without_bytecode =
1374                         has_enablers_without_bytecode;
1375
1376                 /* Enable filters */
1377                 cds_list_for_each_entry(runtime,
1378                                 &event->bytecode_runtime_head, node) {
1379                         lttng_filter_sync_state(runtime);
1380                 }
1381         }
1382 }
1383
1384 /*
1385  * Apply enablers to session events, adding events to session if need
1386  * be. It is required after each modification applied to an active
1387  * session, and right before session "start".
1388  * "lazy" sync means we only sync if required.
1389  */
1390 static
1391 void lttng_session_lazy_sync_enablers(struct lttng_session *session)
1392 {
1393         /* We can skip if session is not active */
1394         if (!session->active)
1395                 return;
1396         lttng_session_sync_enablers(session);
1397 }