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