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