liblttng-ust/ltt-events.c

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