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 <endian.h>
  14 #include <urcu/list.h>
  15 #include <urcu/hlist.h>
  16 #include <pthread.h>
  17 #include <uuid/uuid.h>
  18 #include <errno.h>
  19 #include <sys/shm.h>
  20 #include <sys/ipc.h>
  21 #include <stdint.h>
  22 #include <stddef.h>
  23
  24 #include <urcu-bp.h>
  25 #include <urcu/compiler.h>
  26 #include <urcu/uatomic.h>
  27 #include <urcu/arch.h>
  28
  29 #include <lttng/tracepoint.h>
  30 #include <lttng/ust-events.h>
  31
  32 #include <usterr-signal-safe.h>
  33 #include <helper.h>
  34 #include "error.h"
  35
  36 #include "ltt-tracer.h"
  37 #include "ltt-tracer-core.h"
  38 #include "wait.h"
  39 #include "../libringbuffer/shm.h"
  40 #include "jhash.h"
  41
  42 /*
  43  * The sessions mutex is the centralized mutex across UST tracing
  44  * control and probe registration. All operations within this file are
  45  * called by the communication thread, under ust_lock protection.
  46  */
  47 static pthread_mutex_t sessions_mutex = PTHREAD_MUTEX_INITIALIZER;
  48
  49 void ust_lock(void)
  50 {
  51         pthread_mutex_lock(&sessions_mutex);
  52 }
  53
  54 void ust_unlock(void)
  55 {
  56         pthread_mutex_unlock(&sessions_mutex);
  57 }
  58
  59 static CDS_LIST_HEAD(sessions);
  60
  61 /*
  62  * Pending probes hash table, containing the registered ltt events for
  63  * which tracepoint probes are still missing. Protected by the sessions
  64  * mutex.
  65  */
  66 #define PENDING_PROBE_HASH_BITS         6
  67 #define PENDING_PROBE_HASH_SIZE         (1 << PENDING_PROBE_HASH_BITS)
  68 static struct cds_hlist_head pending_probe_table[PENDING_PROBE_HASH_SIZE];
  69
  70 struct ust_pending_probe {
  71         struct ltt_event *event;
  72         struct cds_hlist_node node;
  73         char name[];
  74 };
  75
  76 static void _ltt_event_destroy(struct ltt_event *event);
  77 static void _ltt_loglevel_destroy(struct loglevel_entry *entry);
  78 static void _ltt_channel_destroy(struct ltt_channel *chan);
  79 static int _ltt_event_unregister(struct ltt_event *event);
  80 static
  81 int _ltt_event_metadata_statedump(struct ltt_session *session,
  82                                   struct ltt_channel *chan,
  83                                   struct ltt_event *event);
  84 static
  85 int _ltt_session_metadata_statedump(struct ltt_session *session);
  86
  87 /*
  88  * called at event creation if probe is missing.
  89  * called with session mutex held.
  90  */
  91 static
  92 int add_pending_probe(struct ltt_event *event, const char *name)
  93 {
  94         struct cds_hlist_head *head;
  95         struct ust_pending_probe *e;
  96         size_t name_len = strlen(name) + 1;
  97         uint32_t hash = jhash(name, name_len - 1, 0);
  98
  99         head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
 100         e = zmalloc(sizeof(struct ust_pending_probe) + name_len);
 101         if (!e)
 102                 return -ENOMEM;
 103         memcpy(&e->name[0], name, name_len);
 104         cds_hlist_add_head(&e->node, head);
 105         e->event = event;
 106         event->pending_probe = e;
 107         return 0;
 108 }
 109
 110 /*
 111  * remove a pending probe. called when at event teardown and when an
 112  * event is fixed (probe is loaded).
 113  * called with session mutex held.
 114  */
 115 static
 116 void remove_pending_probe(struct ust_pending_probe *e)
 117 {
 118         if (!e)
 119                 return;
 120         cds_hlist_del(&e->node);
 121         free(e);
 122 }
 123
 124 /*
 125  * Called at library load: connect the probe on the events pending on
 126  * probe load.
 127  * called with session mutex held.
 128  */
 129 int pending_probe_fix_events(const struct lttng_event_desc *desc)
 130 {
 131         struct cds_hlist_head *head;
 132         struct cds_hlist_node *node, *p;
 133         struct ust_pending_probe *e;
 134         const char *name = desc->name;
 135         size_t name_len = strlen(name) + 1;
 136         uint32_t hash = jhash(name, name_len - 1, 0);
 137         int ret = 0;
 138
 139         /* TODO:
 140          * For this event, we need to lookup the loglevel. If active (in
 141          * the active loglevels hash table), we must create the event.
 142          */
 143
 144         head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
 145         cds_hlist_for_each_entry_safe(e, node, p, head, node) {
 146                 struct ltt_event *event;
 147                 struct ltt_channel *chan;
 148
 149                 if (strcmp(name, e->name))
 150                         continue;
 151                 event = e->event;
 152                 chan = event->chan;
 153                 assert(!event->desc);
 154                 event->desc = desc;
 155                 event->pending_probe = NULL;
 156                 remove_pending_probe(e);
 157                 ret |= __tracepoint_probe_register(name,
 158                                 event->desc->probe_callback,
 159                                 event);
 160                 if (ret)
 161                         continue;
 162                 event->id = chan->free_event_id++;
 163                 ret |= _ltt_event_metadata_statedump(chan->session, chan,
 164                                 event);
 165         }
 166         return ret;
 167 }
 168
 169 void synchronize_trace(void)
 170 {
 171         synchronize_rcu();
 172 }
 173
 174 struct ltt_session *ltt_session_create(void)
 175 {
 176         struct ltt_session *session;
 177
 178         session = zmalloc(sizeof(struct ltt_session));
 179         if (!session)
 180                 return NULL;
 181         CDS_INIT_LIST_HEAD(&session->chan);
 182         CDS_INIT_LIST_HEAD(&session->events);
 183         CDS_INIT_LIST_HEAD(&session->loglevels);
 184         uuid_generate(session->uuid);
 185         cds_list_add(&session->list, &sessions);
 186         return session;
 187 }
 188
 189 void ltt_session_destroy(struct ltt_session *session)
 190 {
 191         struct ltt_channel *chan, *tmpchan;
 192         struct ltt_event *event, *tmpevent;
 193         struct loglevel_entry *loglevel, *tmploglevel;
 194         int ret;
 195
 196         CMM_ACCESS_ONCE(session->active) = 0;
 197         cds_list_for_each_entry(event, &session->events, list) {
 198                 ret = _ltt_event_unregister(event);
 199                 WARN_ON(ret);
 200         }
 201         synchronize_trace();    /* Wait for in-flight events to complete */
 202         cds_list_for_each_entry_safe(loglevel, tmploglevel, &session->loglevels, list)
 203                 _ltt_loglevel_destroy(loglevel);
 204         cds_list_for_each_entry_safe(event, tmpevent, &session->events, list)
 205                 _ltt_event_destroy(event);
 206         cds_list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
 207                 _ltt_channel_destroy(chan);
 208         cds_list_del(&session->list);
 209         free(session);
 210 }
 211
 212 int ltt_session_enable(struct ltt_session *session)
 213 {
 214         int ret = 0;
 215         struct ltt_channel *chan;
 216
 217         if (session->active) {
 218                 ret = -EBUSY;
 219                 goto end;
 220         }
 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, list) {
 227                 if (chan->header_type)
 228                         continue;               /* don't change it if session stop/restart */
 229                 if (chan->free_event_id < 31)
 230                         chan->header_type = 1;  /* compact */
 231                 else
 232                         chan->header_type = 2;  /* large */
 233         }
 234
 235         CMM_ACCESS_ONCE(session->active) = 1;
 236         CMM_ACCESS_ONCE(session->been_active) = 1;
 237         ret = _ltt_session_metadata_statedump(session);
 238         if (ret)
 239                 CMM_ACCESS_ONCE(session->active) = 0;
 240 end:
 241         return ret;
 242 }
 243
 244 int ltt_session_disable(struct ltt_session *session)
 245 {
 246         int ret = 0;
 247
 248         if (!session->active) {
 249                 ret = -EBUSY;
 250                 goto end;
 251         }
 252         CMM_ACCESS_ONCE(session->active) = 0;
 253 end:
 254         return ret;
 255 }
 256
 257 int ltt_channel_enable(struct ltt_channel *channel)
 258 {
 259         int old;
 260
 261         if (channel == channel->session->metadata)
 262                 return -EPERM;
 263         old = uatomic_xchg(&channel->enabled, 1);
 264         if (old)
 265                 return -EEXIST;
 266         return 0;
 267 }
 268
 269 int ltt_channel_disable(struct ltt_channel *channel)
 270 {
 271         int old;
 272
 273         if (channel == channel->session->metadata)
 274                 return -EPERM;
 275         old = uatomic_xchg(&channel->enabled, 0);
 276         if (!old)
 277                 return -EEXIST;
 278         return 0;
 279 }
 280
 281 int ltt_event_enable(struct ltt_event *event)
 282 {
 283         int old;
 284
 285         if (event->chan == event->chan->session->metadata)
 286                 return -EPERM;
 287         old = uatomic_xchg(&event->enabled, 1);
 288         if (old)
 289                 return -EEXIST;
 290         return 0;
 291 }
 292
 293 int ltt_event_disable(struct ltt_event *event)
 294 {
 295         int old;
 296
 297         if (event->chan == event->chan->session->metadata)
 298                 return -EPERM;
 299         old = uatomic_xchg(&event->enabled, 0);
 300         if (!old)
 301                 return -EEXIST;
 302         return 0;
 303 }
 304
 305 struct ltt_channel *ltt_channel_create(struct ltt_session *session,
 306                                        const char *transport_name,
 307                                        void *buf_addr,
 308                                        size_t subbuf_size, size_t num_subbuf,
 309                                        unsigned int switch_timer_interval,
 310                                        unsigned int read_timer_interval,
 311                                        int *shm_fd, int *wait_fd,
 312                                        uint64_t *memory_map_size,
 313                                        struct ltt_channel *chan_priv_init)
 314 {
 315         struct ltt_channel *chan = NULL;
 316         struct ltt_transport *transport;
 317
 318         if (session->been_active)
 319                 goto active;    /* Refuse to add channel to active session */
 320         transport = ltt_transport_find(transport_name);
 321         if (!transport) {
 322                 DBG("LTTng transport %s not found\n",
 323                        transport_name);
 324                 goto notransport;
 325         }
 326         chan_priv_init->id = session->free_chan_id++;
 327         chan_priv_init->session = session;
 328         /*
 329          * Note: the channel creation op already writes into the packet
 330          * headers. Therefore the "chan" information used as input
 331          * should be already accessible.
 332          */
 333         chan = transport->ops.channel_create("[lttng]", buf_addr,
 334                         subbuf_size, num_subbuf, switch_timer_interval,
 335                         read_timer_interval, shm_fd, wait_fd,
 336                         memory_map_size, chan_priv_init);
 337         if (!chan)
 338                 goto create_error;
 339         chan->enabled = 1;
 340         chan->ops = &transport->ops;
 341         cds_list_add(&chan->list, &session->chan);
 342         return chan;
 343
 344 create_error:
 345 notransport:
 346 active:
 347         return NULL;
 348 }
 349
 350 /*
 351  * Only used internally at session destruction.
 352  */
 353 static
 354 void _ltt_channel_destroy(struct ltt_channel *chan)
 355 {
 356         cds_list_del(&chan->list);
 357         lttng_destroy_context(chan->ctx);
 358         chan->ops->channel_destroy(chan);
 359 }
 360
 361 int ltt_loglevel_create(struct ltt_channel *chan,
 362         struct lttng_ust_event *event_param,
 363         struct loglevel_entry **_entry)
 364 {
 365         struct loglevel_entry *entry;
 366
 367         entry = add_loglevel(event_param->name, chan, event_param);
 368         if (!entry || IS_ERR(entry)) {
 369                 return PTR_ERR(entry);
 370         }
 371         *_entry = entry;
 372         return 0;
 373 }
 374
 375 static
 376 void _ltt_loglevel_destroy(struct loglevel_entry *entry)
 377 {
 378         _remove_loglevel(entry);
 379 }
 380
 381 /*
 382  * Supports event creation while tracing session is active.
 383  */
 384 int ltt_event_create(struct ltt_channel *chan,
 385                 struct lttng_ust_event *event_param,
 386                 void *filter,
 387                 struct ltt_event **_event)
 388 {
 389         struct ltt_event *event;
 390         int ret = 0;
 391
 392         if (chan->used_event_id == -1UL) {
 393                 ret = -ENOMEM;
 394                 goto full;
 395         }
 396         /*
 397          * This is O(n^2) (for each event, the loop is called at event
 398          * creation). Might require a hash if we have lots of events.
 399          */
 400         cds_list_for_each_entry(event, &chan->session->events, list) {
 401                 if (event->desc && !strcmp(event->desc->name, event_param->name)) {
 402                         ret = -EEXIST;
 403                         goto exist;
 404                 }
 405         }
 406         event = zmalloc(sizeof(struct ltt_event));
 407         if (!event) {
 408                 ret = -ENOMEM;
 409                 goto cache_error;
 410         }
 411         event->chan = chan;
 412         event->filter = filter;
 413         /*
 414          * used_event_id counts the maximum number of event IDs that can
 415          * register if all probes register.
 416          */
 417         chan->used_event_id++;
 418         event->enabled = 1;
 419         event->instrumentation = event_param->instrumentation;
 420         /* Populate ltt_event structure before tracepoint registration. */
 421         cmm_smp_wmb();
 422         switch (event_param->instrumentation) {
 423         case LTTNG_UST_TRACEPOINT:
 424                 event->desc = ltt_event_get(event_param->name);
 425                 if (event->desc) {
 426                         ret = __tracepoint_probe_register(event_param->name,
 427                                         event->desc->probe_callback,
 428                                         event);
 429                         if (ret)
 430                                 goto register_error;
 431                         event->id = chan->free_event_id++;
 432                 } else {
 433                         /*
 434                          * If the probe is not present, event->desc stays NULL,
 435                          * waiting for the probe to register, and the event->id
 436                          * stays unallocated.
 437                          */
 438                         ret = add_pending_probe(event, event_param->name);
 439                         if (ret)
 440                                 goto add_pending_error;
 441                 }
 442                 break;
 443         case LTTNG_UST_TRACEPOINT_LOGLEVEL:
 444                 assert(0);
 445                 break;
 446         default:
 447                 WARN_ON_ONCE(1);
 448         }
 449         if (event->desc) {
 450                 ret = _ltt_event_metadata_statedump(chan->session, chan, event);
 451                 if (ret)
 452                         goto statedump_error;
 453         }
 454         cds_list_add(&event->list, &chan->session->events);
 455         *_event = event;
 456         return 0;
 457
 458 statedump_error:
 459         if (event->desc) {
 460                 WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name,
 461                                         event->desc->probe_callback,
 462                                         event));
 463                 ltt_event_put(event->desc);
 464         }
 465 add_pending_error:
 466 register_error:
 467         free(event);
 468 cache_error:
 469 exist:
 470 full:
 471         return ret;
 472 }
 473
 474 /*
 475  * Only used internally at session destruction.
 476  */
 477 int _ltt_event_unregister(struct ltt_event *event)
 478 {
 479         int ret = -EINVAL;
 480
 481         switch (event->instrumentation) {
 482         case LTTNG_UST_TRACEPOINT:
 483                 if (event->desc) {
 484                         ret = __tracepoint_probe_unregister(event->desc->name,
 485                                                           event->desc->probe_callback,
 486                                                           event);
 487                         if (ret)
 488                                 return ret;
 489                 } else {
 490                         remove_pending_probe(event->pending_probe);
 491                         ret = 0;
 492                 }
 493                 break;
 494         default:
 495                 WARN_ON_ONCE(1);
 496         }
 497         return ret;
 498 }
 499
 500 /*
 501  * Only used internally at session destruction.
 502  */
 503 static
 504 void _ltt_event_destroy(struct ltt_event *event)
 505 {
 506         switch (event->instrumentation) {
 507         case LTTNG_UST_TRACEPOINT:
 508                 if (event->desc) {
 509                         ltt_event_put(event->desc);
 510                 }
 511                 break;
 512         default:
 513                 WARN_ON_ONCE(1);
 514         }
 515         cds_list_del(&event->list);
 516         lttng_destroy_context(event->ctx);
 517         free(event);
 518 }
 519
 520 /*
 521  * We have exclusive access to our metadata buffer (protected by the
 522  * ust_lock), so we can do racy operations such as looking for
 523  * remaining space left in packet and write, since mutual exclusion
 524  * protects us from concurrent writes.
 525  */
 526 int lttng_metadata_printf(struct ltt_session *session,
 527                           const char *fmt, ...)
 528 {
 529         struct lttng_ust_lib_ring_buffer_ctx ctx;
 530         struct ltt_channel *chan = session->metadata;
 531         char *str = NULL;
 532         int ret = 0, waitret;
 533         size_t len, reserve_len, pos;
 534         va_list ap;
 535
 536         WARN_ON_ONCE(!CMM_ACCESS_ONCE(session->active));
 537
 538         va_start(ap, fmt);
 539         ret = vasprintf(&str, fmt, ap);
 540         va_end(ap);
 541         if (ret < 0)
 542                 return -ENOMEM;
 543
 544         len = strlen(str);
 545         pos = 0;
 546
 547         for (pos = 0; pos < len; pos += reserve_len) {
 548                 reserve_len = min_t(size_t,
 549                                 chan->ops->packet_avail_size(chan->chan, chan->handle),
 550                                 len - pos);
 551                 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
 552                                          sizeof(char), -1, chan->handle);
 553                 /*
 554                  * We don't care about metadata buffer's records lost
 555                  * count, because we always retry here. Report error if
 556                  * we need to bail out after timeout or being
 557                  * interrupted.
 558                  */
 559                 waitret = wait_cond_interruptible_timeout(
 560                         ({
 561                                 ret = chan->ops->event_reserve(&ctx, 0);
 562                                 ret != -ENOBUFS || !ret;
 563                         }),
 564                         LTTNG_METADATA_TIMEOUT_MSEC);
 565                 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
 566                         DBG("LTTng: Failure to write metadata to buffers (%s)\n",
 567                                 waitret == -EINTR ? "interrupted" :
 568                                         (ret == -ENOBUFS ? "timeout" : "I/O error"));
 569                         if (waitret == -EINTR)
 570                                 ret = waitret;
 571                         goto end;
 572                 }
 573                 chan->ops->event_write(&ctx, &str[pos], reserve_len);
 574                 chan->ops->event_commit(&ctx);
 575         }
 576 end:
 577         free(str);
 578         return ret;
 579 }
 580
 581 static
 582 int _ltt_field_statedump(struct ltt_session *session,
 583                          const struct lttng_event_field *field)
 584 {
 585         int ret = 0;
 586
 587         switch (field->type.atype) {
 588         case atype_integer:
 589                 ret = lttng_metadata_printf(session,
 590                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
 591                         field->type.u.basic.integer.size,
 592                         field->type.u.basic.integer.alignment,
 593                         field->type.u.basic.integer.signedness,
 594                         (field->type.u.basic.integer.encoding == lttng_encode_none)
 595                                 ? "none"
 596                                 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
 597                                         ? "UTF8"
 598                                         : "ASCII",
 599                         field->type.u.basic.integer.base,
 600 #if (BYTE_ORDER == BIG_ENDIAN)
 601                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 602 #else
 603                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 604 #endif
 605                         field->name);
 606                 break;
 607         case atype_float:
 608                 ret = lttng_metadata_printf(session,
 609                         "               floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n",
 610                         field->type.u.basic._float.exp_dig,
 611                         field->type.u.basic._float.mant_dig,
 612                         field->type.u.basic._float.alignment,
 613 #if (BYTE_ORDER == BIG_ENDIAN)
 614                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 615 #else
 616                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 617 #endif
 618                         field->name);
 619                 break;
 620         case atype_enum:
 621                 ret = lttng_metadata_printf(session,
 622                         "               %s %s;\n",
 623                         field->type.u.basic.enumeration.name,
 624                         field->name);
 625                 break;
 626         case atype_array:
 627         {
 628                 const struct lttng_basic_type *elem_type;
 629
 630                 elem_type = &field->type.u.array.elem_type;
 631                 ret = lttng_metadata_printf(session,
 632                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
 633                         elem_type->u.basic.integer.size,
 634                         elem_type->u.basic.integer.alignment,
 635                         elem_type->u.basic.integer.signedness,
 636                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 637                                 ? "none"
 638                                 : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 639                                         ? "UTF8"
 640                                         : "ASCII",
 641                         elem_type->u.basic.integer.base,
 642 #if (BYTE_ORDER == BIG_ENDIAN)
 643                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 644 #else
 645                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 646 #endif
 647                         field->name, field->type.u.array.length);
 648                 break;
 649         }
 650         case atype_sequence:
 651         {
 652                 const struct lttng_basic_type *elem_type;
 653                 const struct lttng_basic_type *length_type;
 654
 655                 elem_type = &field->type.u.sequence.elem_type;
 656                 length_type = &field->type.u.sequence.length_type;
 657                 ret = lttng_metadata_printf(session,
 658                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
 659                         length_type->u.basic.integer.size,
 660                         (unsigned int) length_type->u.basic.integer.alignment,
 661                         length_type->u.basic.integer.signedness,
 662                         (length_type->u.basic.integer.encoding == lttng_encode_none)
 663                                 ? "none"
 664                                 : ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
 665                                         ? "UTF8"
 666                                         : "ASCII"),
 667                         length_type->u.basic.integer.base,
 668 #if (BYTE_ORDER == BIG_ENDIAN)
 669                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 670 #else
 671                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 672 #endif
 673                         field->name);
 674                 if (ret)
 675                         return ret;
 676
 677                 ret = lttng_metadata_printf(session,
 678                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
 679                         elem_type->u.basic.integer.size,
 680                         (unsigned int) elem_type->u.basic.integer.alignment,
 681                         elem_type->u.basic.integer.signedness,
 682                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 683                                 ? "none"
 684                                 : ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 685                                         ? "UTF8"
 686                                         : "ASCII"),
 687                         elem_type->u.basic.integer.base,
 688 #if (BYTE_ORDER == BIG_ENDIAN)
 689                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 690 #else
 691                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 692 #endif
 693                         field->name,
 694                         field->name);
 695                 break;
 696         }
 697
 698         case atype_string:
 699                 /* Default encoding is UTF8 */
 700                 ret = lttng_metadata_printf(session,
 701                         "               string%s _%s;\n",
 702                         field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 703                                 " { encoding = ASCII; }" : "",
 704                         field->name);
 705                 break;
 706         default:
 707                 WARN_ON_ONCE(1);
 708                 return -EINVAL;
 709         }
 710         return ret;
 711 }
 712
 713 static
 714 int _ltt_context_metadata_statedump(struct ltt_session *session,
 715                                     struct lttng_ctx *ctx)
 716 {
 717         int ret = 0;
 718         int i;
 719
 720         if (!ctx)
 721                 return 0;
 722         for (i = 0; i < ctx->nr_fields; i++) {
 723                 const struct lttng_ctx_field *field = &ctx->fields[i];
 724
 725                 ret = _ltt_field_statedump(session, &field->event_field);
 726                 if (ret)
 727                         return ret;
 728         }
 729         return ret;
 730 }
 731
 732 static
 733 int _ltt_fields_metadata_statedump(struct ltt_session *session,
 734                                    struct ltt_event *event)
 735 {
 736         const struct lttng_event_desc *desc = event->desc;
 737         int ret = 0;
 738         int i;
 739
 740         for (i = 0; i < desc->nr_fields; i++) {
 741                 const struct lttng_event_field *field = &desc->fields[i];
 742
 743                 ret = _ltt_field_statedump(session, field);
 744                 if (ret)
 745                         return ret;
 746         }
 747         return ret;
 748 }
 749
 750 static
 751 int _ltt_event_metadata_statedump(struct ltt_session *session,
 752                                   struct ltt_channel *chan,
 753                                   struct ltt_event *event)
 754 {
 755         int ret = 0;
 756
 757         if (event->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 758                 return 0;
 759         if (chan == session->metadata)
 760                 return 0;
 761         /*
 762          * Don't print events for which probe load is pending.
 763          */
 764         if (!event->desc)
 765                 return 0;
 766
 767         ret = lttng_metadata_printf(session,
 768                 "event {\n"
 769                 "       name = \"%s\";\n"
 770                 "       id = %u;\n"
 771                 "       stream_id = %u;\n",
 772                 event->desc->name,
 773                 event->id,
 774                 event->chan->id);
 775         if (ret)
 776                 goto end;
 777
 778         if (event->ctx) {
 779                 ret = lttng_metadata_printf(session,
 780                         "       context := struct {\n");
 781                 if (ret)
 782                         goto end;
 783         }
 784         ret = _ltt_context_metadata_statedump(session, event->ctx);
 785         if (ret)
 786                 goto end;
 787         if (event->ctx) {
 788                 ret = lttng_metadata_printf(session,
 789                         "       };\n");
 790                 if (ret)
 791                         goto end;
 792         }
 793
 794         ret = lttng_metadata_printf(session,
 795                 "       fields := struct {\n"
 796                 );
 797         if (ret)
 798                 goto end;
 799
 800         ret = _ltt_fields_metadata_statedump(session, event);
 801         if (ret)
 802                 goto end;
 803
 804         /*
 805          * LTTng space reservation can only reserve multiples of the
 806          * byte size.
 807          */
 808         ret = lttng_metadata_printf(session,
 809                 "       };\n"
 810                 "};\n\n");
 811         if (ret)
 812                 goto end;
 813
 814         event->metadata_dumped = 1;
 815 end:
 816         return ret;
 817
 818 }
 819
 820 static
 821 int _ltt_channel_metadata_statedump(struct ltt_session *session,
 822                                     struct ltt_channel *chan)
 823 {
 824         int ret = 0;
 825
 826         if (chan->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 827                 return 0;
 828         if (chan == session->metadata)
 829                 return 0;
 830
 831         WARN_ON_ONCE(!chan->header_type);
 832         ret = lttng_metadata_printf(session,
 833                 "stream {\n"
 834                 "       id = %u;\n"
 835                 "       event.header := %s;\n"
 836                 "       packet.context := struct packet_context;\n",
 837                 chan->id,
 838                 chan->header_type == 1 ? "struct event_header_compact" :
 839                         "struct event_header_large");
 840         if (ret)
 841                 goto end;
 842
 843         if (chan->ctx) {
 844                 ret = lttng_metadata_printf(session,
 845                         "       event.context := struct {\n");
 846                 if (ret)
 847                         goto end;
 848         }
 849         ret = _ltt_context_metadata_statedump(session, chan->ctx);
 850         if (ret)
 851                 goto end;
 852         if (chan->ctx) {
 853                 ret = lttng_metadata_printf(session,
 854                         "       };\n");
 855                 if (ret)
 856                         goto end;
 857         }
 858
 859         ret = lttng_metadata_printf(session,
 860                 "};\n\n");
 861
 862         chan->metadata_dumped = 1;
 863 end:
 864         return ret;
 865 }
 866
 867 static
 868 int _ltt_stream_packet_context_declare(struct ltt_session *session)
 869 {
 870         return lttng_metadata_printf(session,
 871                 "struct packet_context {\n"
 872                 "       uint64_t timestamp_begin;\n"
 873                 "       uint64_t timestamp_end;\n"
 874                 "       uint32_t events_discarded;\n"
 875                 "       uint32_t content_size;\n"
 876                 "       uint32_t packet_size;\n"
 877                 "       uint32_t cpu_id;\n"
 878                 "};\n\n"
 879                 );
 880 }
 881
 882 /*
 883  * Compact header:
 884  * id: range: 0 - 30.
 885  * id 31 is reserved to indicate an extended header.
 886  *
 887  * Large header:
 888  * id: range: 0 - 65534.
 889  * id 65535 is reserved to indicate an extended header.
 890  */
 891 static
 892 int _ltt_event_header_declare(struct ltt_session *session)
 893 {
 894         return lttng_metadata_printf(session,
 895         "struct event_header_compact {\n"
 896         "       enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
 897         "       variant <id> {\n"
 898         "               struct {\n"
 899         "                       uint27_t timestamp;\n"
 900         "               } compact;\n"
 901         "               struct {\n"
 902         "                       uint32_t id;\n"
 903         "                       uint64_t timestamp;\n"
 904         "               } extended;\n"
 905         "       } v;\n"
 906         "} align(%u);\n"
 907         "\n"
 908         "struct event_header_large {\n"
 909         "       enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
 910         "       variant <id> {\n"
 911         "               struct {\n"
 912         "                       uint32_t timestamp;\n"
 913         "               } compact;\n"
 914         "               struct {\n"
 915         "                       uint32_t id;\n"
 916         "                       uint64_t timestamp;\n"
 917         "               } extended;\n"
 918         "       } v;\n"
 919         "} align(%u);\n\n",
 920         lttng_alignof(uint32_t) * CHAR_BIT,
 921         lttng_alignof(uint16_t) * CHAR_BIT
 922         );
 923 }
 924
 925 /*
 926  * Output metadata into this session's metadata buffers.
 927  */
 928 static
 929 int _ltt_session_metadata_statedump(struct ltt_session *session)
 930 {
 931         unsigned char *uuid_c = session->uuid;
 932         char uuid_s[37];
 933         struct ltt_channel *chan;
 934         struct ltt_event *event;
 935         int ret = 0;
 936
 937         if (!CMM_ACCESS_ONCE(session->active))
 938                 return 0;
 939         if (session->metadata_dumped)
 940                 goto skip_session;
 941         if (!session->metadata) {
 942                 DBG("LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n");
 943                 return -EPERM;
 944         }
 945
 946         snprintf(uuid_s, sizeof(uuid_s),
 947                 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 948                 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
 949                 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
 950                 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
 951                 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
 952
 953         ret = lttng_metadata_printf(session,
 954                 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
 955                 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
 956                 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
 957                 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
 958                 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
 959                 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
 960                 "\n"
 961                 "trace {\n"
 962                 "       major = %u;\n"
 963                 "       minor = %u;\n"
 964                 "       uuid = \"%s\";\n"
 965                 "       byte_order = %s;\n"
 966                 "       packet.header := struct {\n"
 967                 "               uint32_t magic;\n"
 968                 "               uint8_t  uuid[16];\n"
 969                 "               uint32_t stream_id;\n"
 970                 "       };\n"
 971                 "};\n\n",
 972                 lttng_alignof(uint8_t) * CHAR_BIT,
 973                 lttng_alignof(uint16_t) * CHAR_BIT,
 974                 lttng_alignof(uint32_t) * CHAR_BIT,
 975                 lttng_alignof(uint64_t) * CHAR_BIT,
 976                 CTF_VERSION_MAJOR,
 977                 CTF_VERSION_MINOR,
 978                 uuid_s,
 979 #if (BYTE_ORDER == BIG_ENDIAN)
 980                 "be"
 981 #else
 982                 "le"
 983 #endif
 984                 );
 985         if (ret)
 986                 goto end;
 987
 988         ret = _ltt_stream_packet_context_declare(session);
 989         if (ret)
 990                 goto end;
 991
 992         ret = _ltt_event_header_declare(session);
 993         if (ret)
 994                 goto end;
 995
 996 skip_session:
 997         cds_list_for_each_entry(chan, &session->chan, list) {
 998                 ret = _ltt_channel_metadata_statedump(session, chan);
 999                 if (ret)
1000                         goto end;
1001         }
1002
1003         cds_list_for_each_entry(event, &session->events, list) {
1004                 ret = _ltt_event_metadata_statedump(session, event->chan, event);
1005                 if (ret)
1006                         goto end;
1007         }
1008         session->metadata_dumped = 1;
1009 end:
1010         return ret;
1011 }
1012
1013 void lttng_ust_events_exit(void)
1014 {
1015         struct ltt_session *session, *tmpsession;
1016
1017         cds_list_for_each_entry_safe(session, tmpsession, &sessions, list)
1018                 ltt_session_destroy(session);
1019 }