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