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