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