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                                        struct ltt_channel *chan_priv_init)
 298 {
 299         struct ltt_channel *chan = NULL;
 300         struct ltt_transport *transport;
 301
 302         if (session->been_active)
 303                 goto active;    /* Refuse to add channel to active session */
 304         transport = ltt_transport_find(transport_name);
 305         if (!transport) {
 306                 DBG("LTTng transport %s not found\n",
 307                        transport_name);
 308                 goto notransport;
 309         }
 310         chan_priv_init->id = session->free_chan_id++;
 311         chan_priv_init->session = session;
 312         /*
 313          * Note: the channel creation op already writes into the packet
 314          * headers. Therefore the "chan" information used as input
 315          * should be already accessible.
 316          */
 317         chan = transport->ops.channel_create("[lttng]", buf_addr,
 318                         subbuf_size, num_subbuf, switch_timer_interval,
 319                         read_timer_interval, shm_fd, wait_fd,
 320                         memory_map_size, chan_priv_init);
 321         if (!chan)
 322                 goto create_error;
 323         chan->enabled = 1;
 324         chan->ops = &transport->ops;
 325         cds_list_add(&chan->list, &session->chan);
 326         return chan;
 327
 328 create_error:
 329 notransport:
 330 active:
 331         return NULL;
 332 }
 333
 334 /*
 335  * Only used internally at session destruction.
 336  */
 337 static
 338 void _ltt_channel_destroy(struct ltt_channel *chan)
 339 {
 340         cds_list_del(&chan->list);
 341         lttng_destroy_context(chan->ctx);
 342         chan->ops->channel_destroy(chan);
 343 }
 344
 345 /*
 346  * Supports event creation while tracing session is active.
 347  */
 348 struct ltt_event *ltt_event_create(struct ltt_channel *chan,
 349                                    struct lttng_ust_event *event_param,
 350                                    void *filter)
 351 {
 352         struct ltt_event *event;
 353         int ret;
 354
 355         if (chan->used_event_id == -1UL)
 356                 goto full;
 357         /*
 358          * This is O(n^2) (for each event, the loop is called at event
 359          * creation). Might require a hash if we have lots of events.
 360          */
 361         cds_list_for_each_entry(event, &chan->session->events, list)
 362                 if (event->desc && !strcmp(event->desc->name, event_param->name))
 363                         goto exist;
 364         event = zmalloc(sizeof(struct ltt_event));
 365         if (!event)
 366                 goto cache_error;
 367         event->chan = chan;
 368         event->filter = filter;
 369         /*
 370          * used_event_id counts the maximum number of event IDs that can
 371          * register if all probes register.
 372          */
 373         chan->used_event_id++;
 374         event->enabled = 1;
 375         event->instrumentation = event_param->instrumentation;
 376         /* Populate ltt_event structure before tracepoint registration. */
 377         cmm_smp_wmb();
 378         switch (event_param->instrumentation) {
 379         case LTTNG_UST_TRACEPOINT:
 380                 event->desc = ltt_event_get(event_param->name);
 381                 if (event->desc) {
 382                         ret = __tracepoint_probe_register(event_param->name,
 383                                         event->desc->probe_callback,
 384                                         event);
 385                         if (ret)
 386                                 goto register_error;
 387                         event->id = chan->free_event_id++;
 388                 } else {
 389                         /*
 390                          * If the probe is not present, event->desc stays NULL,
 391                          * waiting for the probe to register, and the event->id
 392                          * stays unallocated.
 393                          */
 394                         ret = add_pending_probe(event, event_param->name);
 395                         if (ret)
 396                                 goto add_pending_error;
 397                 }
 398                 break;
 399         default:
 400                 WARN_ON_ONCE(1);
 401         }
 402         if (event->desc) {
 403                 ret = _ltt_event_metadata_statedump(chan->session, chan, event);
 404                 if (ret)
 405                         goto statedump_error;
 406         }
 407         cds_list_add(&event->list, &chan->session->events);
 408         return event;
 409
 410 statedump_error:
 411         if (event->desc) {
 412                 WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name,
 413                                         event->desc->probe_callback,
 414                                         event));
 415                 ltt_event_put(event->desc);
 416         }
 417 add_pending_error:
 418 register_error:
 419         free(event);
 420 cache_error:
 421 exist:
 422 full:
 423         return NULL;
 424 }
 425
 426 /*
 427  * Only used internally at session destruction.
 428  */
 429 int _ltt_event_unregister(struct ltt_event *event)
 430 {
 431         int ret = -EINVAL;
 432
 433         switch (event->instrumentation) {
 434         case LTTNG_UST_TRACEPOINT:
 435                 if (event->desc) {
 436                         ret = __tracepoint_probe_unregister(event->desc->name,
 437                                                           event->desc->probe_callback,
 438                                                           event);
 439                         if (ret)
 440                                 return ret;
 441                 } else {
 442                         remove_pending_probe(event->pending_probe);
 443                         ret = 0;
 444                 }
 445                 break;
 446         default:
 447                 WARN_ON_ONCE(1);
 448         }
 449         return ret;
 450 }
 451
 452 /*
 453  * Only used internally at session destruction.
 454  */
 455 static
 456 void _ltt_event_destroy(struct ltt_event *event)
 457 {
 458         switch (event->instrumentation) {
 459         case LTTNG_UST_TRACEPOINT:
 460                 if (event->desc) {
 461                         ltt_event_put(event->desc);
 462                 }
 463                 break;
 464         default:
 465                 WARN_ON_ONCE(1);
 466         }
 467         cds_list_del(&event->list);
 468         lttng_destroy_context(event->ctx);
 469         free(event);
 470 }
 471
 472 /*
 473  * We have exclusive access to our metadata buffer (protected by the
 474  * ust_lock), so we can do racy operations such as looking for
 475  * remaining space left in packet and write, since mutual exclusion
 476  * protects us from concurrent writes.
 477  */
 478 int lttng_metadata_printf(struct ltt_session *session,
 479                           const char *fmt, ...)
 480 {
 481         struct lttng_ust_lib_ring_buffer_ctx ctx;
 482         struct ltt_channel *chan = session->metadata;
 483         char *str = NULL;
 484         int ret = 0, waitret;
 485         size_t len, reserve_len, pos;
 486         va_list ap;
 487
 488         WARN_ON_ONCE(!CMM_ACCESS_ONCE(session->active));
 489
 490         va_start(ap, fmt);
 491         ret = vasprintf(&str, fmt, ap);
 492         va_end(ap);
 493         if (ret < 0)
 494                 return -ENOMEM;
 495
 496         len = strlen(str);
 497         pos = 0;
 498
 499         for (pos = 0; pos < len; pos += reserve_len) {
 500                 reserve_len = min_t(size_t,
 501                                 chan->ops->packet_avail_size(chan->chan, chan->handle),
 502                                 len - pos);
 503                 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
 504                                          sizeof(char), -1, chan->handle);
 505                 /*
 506                  * We don't care about metadata buffer's records lost
 507                  * count, because we always retry here. Report error if
 508                  * we need to bail out after timeout or being
 509                  * interrupted.
 510                  */
 511                 waitret = wait_cond_interruptible_timeout(
 512                         ({
 513                                 ret = chan->ops->event_reserve(&ctx, 0);
 514                                 ret != -ENOBUFS || !ret;
 515                         }),
 516                         LTTNG_METADATA_TIMEOUT_MSEC);
 517                 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
 518                         DBG("LTTng: Failure to write metadata to buffers (%s)\n",
 519                                 waitret == -EINTR ? "interrupted" :
 520                                         (ret == -ENOBUFS ? "timeout" : "I/O error"));
 521                         if (waitret == -EINTR)
 522                                 ret = waitret;
 523                         goto end;
 524                 }
 525                 chan->ops->event_write(&ctx, &str[pos], reserve_len);
 526                 chan->ops->event_commit(&ctx);
 527         }
 528 end:
 529         free(str);
 530         return ret;
 531 }
 532
 533 static
 534 int _ltt_field_statedump(struct ltt_session *session,
 535                          const struct lttng_event_field *field)
 536 {
 537         int ret = 0;
 538
 539         switch (field->type.atype) {
 540         case atype_integer:
 541                 ret = lttng_metadata_printf(session,
 542                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
 543                         field->type.u.basic.integer.size,
 544                         field->type.u.basic.integer.alignment,
 545                         field->type.u.basic.integer.signedness,
 546                         (field->type.u.basic.integer.encoding == lttng_encode_none)
 547                                 ? "none"
 548                                 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
 549                                         ? "UTF8"
 550                                         : "ASCII",
 551                         field->type.u.basic.integer.base,
 552 #if (BYTE_ORDER == BIG_ENDIAN)
 553                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 554 #else
 555                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 556 #endif
 557                         field->name);
 558                 break;
 559         case atype_float:
 560                 ret = lttng_metadata_printf(session,
 561                         "               floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n",
 562                         field->type.u.basic._float.exp_dig,
 563                         field->type.u.basic._float.mant_dig,
 564                         field->type.u.basic._float.alignment,
 565 #if (BYTE_ORDER == BIG_ENDIAN)
 566                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 567 #else
 568                         field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 569 #endif
 570                         field->name);
 571                 break;
 572         case atype_enum:
 573                 ret = lttng_metadata_printf(session,
 574                         "               %s %s;\n",
 575                         field->type.u.basic.enumeration.name,
 576                         field->name);
 577                 break;
 578         case atype_array:
 579         {
 580                 const struct lttng_basic_type *elem_type;
 581
 582                 elem_type = &field->type.u.array.elem_type;
 583                 ret = lttng_metadata_printf(session,
 584                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
 585                         elem_type->u.basic.integer.size,
 586                         elem_type->u.basic.integer.alignment,
 587                         elem_type->u.basic.integer.signedness,
 588                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 589                                 ? "none"
 590                                 : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 591                                         ? "UTF8"
 592                                         : "ASCII",
 593                         elem_type->u.basic.integer.base,
 594 #if (BYTE_ORDER == BIG_ENDIAN)
 595                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 596 #else
 597                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 598 #endif
 599                         field->name, field->type.u.array.length);
 600                 break;
 601         }
 602         case atype_sequence:
 603         {
 604                 const struct lttng_basic_type *elem_type;
 605                 const struct lttng_basic_type *length_type;
 606
 607                 elem_type = &field->type.u.sequence.elem_type;
 608                 length_type = &field->type.u.sequence.length_type;
 609                 ret = lttng_metadata_printf(session,
 610                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
 611                         length_type->u.basic.integer.size,
 612                         (unsigned int) length_type->u.basic.integer.alignment,
 613                         length_type->u.basic.integer.signedness,
 614                         (length_type->u.basic.integer.encoding == lttng_encode_none)
 615                                 ? "none"
 616                                 : ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
 617                                         ? "UTF8"
 618                                         : "ASCII"),
 619                         length_type->u.basic.integer.base,
 620 #if (BYTE_ORDER == BIG_ENDIAN)
 621                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 622 #else
 623                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 624 #endif
 625                         field->name);
 626                 if (ret)
 627                         return ret;
 628
 629                 ret = lttng_metadata_printf(session,
 630                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
 631                         elem_type->u.basic.integer.size,
 632                         (unsigned int) elem_type->u.basic.integer.alignment,
 633                         elem_type->u.basic.integer.signedness,
 634                         (elem_type->u.basic.integer.encoding == lttng_encode_none)
 635                                 ? "none"
 636                                 : ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
 637                                         ? "UTF8"
 638                                         : "ASCII"),
 639                         elem_type->u.basic.integer.base,
 640 #if (BYTE_ORDER == BIG_ENDIAN)
 641                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 642 #else
 643                         elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 644 #endif
 645                         field->name,
 646                         field->name);
 647                 break;
 648         }
 649
 650         case atype_string:
 651                 /* Default encoding is UTF8 */
 652                 ret = lttng_metadata_printf(session,
 653                         "               string%s _%s;\n",
 654                         field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 655                                 " { encoding = ASCII; }" : "",
 656                         field->name);
 657                 break;
 658         default:
 659                 WARN_ON_ONCE(1);
 660                 return -EINVAL;
 661         }
 662         return ret;
 663 }
 664
 665 static
 666 int _ltt_context_metadata_statedump(struct ltt_session *session,
 667                                     struct lttng_ctx *ctx)
 668 {
 669         int ret = 0;
 670         int i;
 671
 672         if (!ctx)
 673                 return 0;
 674         for (i = 0; i < ctx->nr_fields; i++) {
 675                 const struct lttng_ctx_field *field = &ctx->fields[i];
 676
 677                 ret = _ltt_field_statedump(session, &field->event_field);
 678                 if (ret)
 679                         return ret;
 680         }
 681         return ret;
 682 }
 683
 684 static
 685 int _ltt_fields_metadata_statedump(struct ltt_session *session,
 686                                    struct ltt_event *event)
 687 {
 688         const struct lttng_event_desc *desc = event->desc;
 689         int ret = 0;
 690         int i;
 691
 692         for (i = 0; i < desc->nr_fields; i++) {
 693                 const struct lttng_event_field *field = &desc->fields[i];
 694
 695                 ret = _ltt_field_statedump(session, field);
 696                 if (ret)
 697                         return ret;
 698         }
 699         return ret;
 700 }
 701
 702 static
 703 int _ltt_event_metadata_statedump(struct ltt_session *session,
 704                                   struct ltt_channel *chan,
 705                                   struct ltt_event *event)
 706 {
 707         int ret = 0;
 708
 709         if (event->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 710                 return 0;
 711         if (chan == session->metadata)
 712                 return 0;
 713         /*
 714          * Don't print events for which probe load is pending.
 715          */
 716         if (!event->desc)
 717                 return 0;
 718
 719         ret = lttng_metadata_printf(session,
 720                 "event {\n"
 721                 "       name = %s;\n"
 722                 "       id = %u;\n"
 723                 "       stream_id = %u;\n",
 724                 event->desc->name,
 725                 event->id,
 726                 event->chan->id);
 727         if (ret)
 728                 goto end;
 729
 730         if (event->ctx) {
 731                 ret = lttng_metadata_printf(session,
 732                         "       context := struct {\n");
 733                 if (ret)
 734                         goto end;
 735         }
 736         ret = _ltt_context_metadata_statedump(session, event->ctx);
 737         if (ret)
 738                 goto end;
 739         if (event->ctx) {
 740                 ret = lttng_metadata_printf(session,
 741                         "       };\n");
 742                 if (ret)
 743                         goto end;
 744         }
 745
 746         ret = lttng_metadata_printf(session,
 747                 "       fields := struct {\n"
 748                 );
 749         if (ret)
 750                 goto end;
 751
 752         ret = _ltt_fields_metadata_statedump(session, event);
 753         if (ret)
 754                 goto end;
 755
 756         /*
 757          * LTTng space reservation can only reserve multiples of the
 758          * byte size.
 759          */
 760         ret = lttng_metadata_printf(session,
 761                 "       };\n"
 762                 "};\n\n");
 763         if (ret)
 764                 goto end;
 765
 766         event->metadata_dumped = 1;
 767 end:
 768         return ret;
 769
 770 }
 771
 772 static
 773 int _ltt_channel_metadata_statedump(struct ltt_session *session,
 774                                     struct ltt_channel *chan)
 775 {
 776         int ret = 0;
 777
 778         if (chan->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
 779                 return 0;
 780         if (chan == session->metadata)
 781                 return 0;
 782
 783         WARN_ON_ONCE(!chan->header_type);
 784         ret = lttng_metadata_printf(session,
 785                 "stream {\n"
 786                 "       id = %u;\n"
 787                 "       event.header := %s;\n"
 788                 "       packet.context := struct packet_context;\n",
 789                 chan->id,
 790                 chan->header_type == 1 ? "struct event_header_compact" :
 791                         "struct event_header_large");
 792         if (ret)
 793                 goto end;
 794
 795         if (chan->ctx) {
 796                 ret = lttng_metadata_printf(session,
 797                         "       event.context := struct {\n");
 798                 if (ret)
 799                         goto end;
 800         }
 801         ret = _ltt_context_metadata_statedump(session, chan->ctx);
 802         if (ret)
 803                 goto end;
 804         if (chan->ctx) {
 805                 ret = lttng_metadata_printf(session,
 806                         "       };\n");
 807                 if (ret)
 808                         goto end;
 809         }
 810
 811         ret = lttng_metadata_printf(session,
 812                 "};\n\n");
 813
 814         chan->metadata_dumped = 1;
 815 end:
 816         return ret;
 817 }
 818
 819 static
 820 int _ltt_stream_packet_context_declare(struct ltt_session *session)
 821 {
 822         return lttng_metadata_printf(session,
 823                 "struct packet_context {\n"
 824                 "       uint64_t timestamp_begin;\n"
 825                 "       uint64_t timestamp_end;\n"
 826                 "       uint32_t events_discarded;\n"
 827                 "       uint32_t content_size;\n"
 828                 "       uint32_t packet_size;\n"
 829                 "       uint32_t cpu_id;\n"
 830                 "};\n\n"
 831                 );
 832 }
 833
 834 /*
 835  * Compact header:
 836  * id: range: 0 - 30.
 837  * id 31 is reserved to indicate an extended header.
 838  *
 839  * Large header:
 840  * id: range: 0 - 65534.
 841  * id 65535 is reserved to indicate an extended header.
 842  */
 843 static
 844 int _ltt_event_header_declare(struct ltt_session *session)
 845 {
 846         return lttng_metadata_printf(session,
 847         "struct event_header_compact {\n"
 848         "       enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
 849         "       variant <id> {\n"
 850         "               struct {\n"
 851         "                       uint27_t timestamp;\n"
 852         "               } compact;\n"
 853         "               struct {\n"
 854         "                       uint32_t id;\n"
 855         "                       uint64_t timestamp;\n"
 856         "               } extended;\n"
 857         "       } v;\n"
 858         "} align(%u);\n"
 859         "\n"
 860         "struct event_header_large {\n"
 861         "       enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
 862         "       variant <id> {\n"
 863         "               struct {\n"
 864         "                       uint32_t timestamp;\n"
 865         "               } compact;\n"
 866         "               struct {\n"
 867         "                       uint32_t id;\n"
 868         "                       uint64_t timestamp;\n"
 869         "               } extended;\n"
 870         "       } v;\n"
 871         "} align(%u);\n\n",
 872         lttng_alignof(uint32_t) * CHAR_BIT,
 873         lttng_alignof(uint16_t) * CHAR_BIT
 874         );
 875 }
 876
 877 /*
 878  * Output metadata into this session's metadata buffers.
 879  */
 880 static
 881 int _ltt_session_metadata_statedump(struct ltt_session *session)
 882 {
 883         unsigned char *uuid_c = session->uuid;
 884         char uuid_s[37];
 885         struct ltt_channel *chan;
 886         struct ltt_event *event;
 887         int ret = 0;
 888
 889         if (!CMM_ACCESS_ONCE(session->active))
 890                 return 0;
 891         if (session->metadata_dumped)
 892                 goto skip_session;
 893         if (!session->metadata) {
 894                 DBG("LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n");
 895                 return -EPERM;
 896         }
 897
 898         snprintf(uuid_s, sizeof(uuid_s),
 899                 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 900                 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
 901                 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
 902                 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
 903                 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
 904
 905         ret = lttng_metadata_printf(session,
 906                 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
 907                 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
 908                 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
 909                 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
 910                 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
 911                 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
 912                 "\n"
 913                 "trace {\n"
 914                 "       major = %u;\n"
 915                 "       minor = %u;\n"
 916                 "       uuid = \"%s\";\n"
 917                 "       byte_order = %s;\n"
 918                 "       packet.header := struct {\n"
 919                 "               uint32_t magic;\n"
 920                 "               uint8_t  uuid[16];\n"
 921                 "               uint32_t stream_id;\n"
 922                 "       };\n"
 923                 "};\n\n",
 924                 lttng_alignof(uint8_t) * CHAR_BIT,
 925                 lttng_alignof(uint16_t) * CHAR_BIT,
 926                 lttng_alignof(uint32_t) * CHAR_BIT,
 927                 lttng_alignof(uint64_t) * CHAR_BIT,
 928                 CTF_VERSION_MAJOR,
 929                 CTF_VERSION_MINOR,
 930                 uuid_s,
 931 #if (BYTE_ORDER == BIG_ENDIAN)
 932                 "be"
 933 #else
 934                 "le"
 935 #endif
 936                 );
 937         if (ret)
 938                 goto end;
 939
 940         ret = _ltt_stream_packet_context_declare(session);
 941         if (ret)
 942                 goto end;
 943
 944         ret = _ltt_event_header_declare(session);
 945         if (ret)
 946                 goto end;
 947
 948 skip_session:
 949         cds_list_for_each_entry(chan, &session->chan, list) {
 950                 ret = _ltt_channel_metadata_statedump(session, chan);
 951                 if (ret)
 952                         goto end;
 953         }
 954
 955         cds_list_for_each_entry(event, &session->events, list) {
 956                 ret = _ltt_event_metadata_statedump(session, event->chan, event);
 957                 if (ret)
 958                         goto end;
 959         }
 960         session->metadata_dumped = 1;
 961 end:
 962         return ret;
 963 }
 964
 965 void lttng_ust_events_exit(void)
 966 {
 967         struct ltt_session *session, *tmpsession;
 968
 969         cds_list_for_each_entry_safe(session, tmpsession, &sessions, list)
 970                 ltt_session_destroy(session);
 971 }