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