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