lttng-events.c

   1 /*
   2  * lttng-events.c
   3  *
   4  * Holds LTTng per-session event registry.
   5  *
   6  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; only
  11  * version 2.1 of the License.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/list.h>
  25 #include <linux/mutex.h>
  26 #include <linux/sched.h>
  27 #include <linux/slab.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/utsname.h>
  30 #include "wrapper/uuid.h"
  31 #include "wrapper/vmalloc.h"    /* for wrapper_vmalloc_sync_all() */
  32 #include "wrapper/random.h"
  33 #include "wrapper/tracepoint.h"
  34 #include "lttng-events.h"
  35 #include "lttng-tracer.h"
  36 #include "lttng-abi-old.h"
  37
  38 static LIST_HEAD(sessions);
  39 static LIST_HEAD(lttng_transport_list);
  40 static DEFINE_MUTEX(sessions_mutex);
  41 static struct kmem_cache *event_cache;
  42
  43 static void _lttng_event_destroy(struct lttng_event *event);
  44 static void _lttng_channel_destroy(struct lttng_channel *chan);
  45 static int _lttng_event_unregister(struct lttng_event *event);
  46 static
  47 int _lttng_event_metadata_statedump(struct lttng_session *session,
  48                                   struct lttng_channel *chan,
  49                                   struct lttng_event *event);
  50 static
  51 int _lttng_session_metadata_statedump(struct lttng_session *session);
  52
  53 void synchronize_trace(void)
  54 {
  55         synchronize_sched();
  56 #ifdef CONFIG_PREEMPT_RT
  57         synchronize_rcu();
  58 #endif
  59 }
  60
  61 struct lttng_session *lttng_session_create(void)
  62 {
  63         struct lttng_session *session;
  64
  65         mutex_lock(&sessions_mutex);
  66         session = kzalloc(sizeof(struct lttng_session), GFP_KERNEL);
  67         if (!session)
  68                 return NULL;
  69         INIT_LIST_HEAD(&session->chan);
  70         INIT_LIST_HEAD(&session->events);
  71         uuid_le_gen(&session->uuid);
  72         list_add(&session->list, &sessions);
  73         mutex_unlock(&sessions_mutex);
  74         return session;
  75 }
  76
  77 void lttng_session_destroy(struct lttng_session *session)
  78 {
  79         struct lttng_channel *chan, *tmpchan;
  80         struct lttng_event *event, *tmpevent;
  81         int ret;
  82
  83         mutex_lock(&sessions_mutex);
  84         ACCESS_ONCE(session->active) = 0;
  85         list_for_each_entry(chan, &session->chan, list) {
  86                 ret = lttng_syscalls_unregister(chan);
  87                 WARN_ON(ret);
  88         }
  89         list_for_each_entry(event, &session->events, list) {
  90                 ret = _lttng_event_unregister(event);
  91                 WARN_ON(ret);
  92         }
  93         synchronize_trace();    /* Wait for in-flight events to complete */
  94         list_for_each_entry_safe(event, tmpevent, &session->events, list)
  95                 _lttng_event_destroy(event);
  96         list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
  97                 _lttng_channel_destroy(chan);
  98         list_del(&session->list);
  99         mutex_unlock(&sessions_mutex);
 100         kfree(session);
 101 }
 102
 103 int lttng_session_enable(struct lttng_session *session)
 104 {
 105         int ret = 0;
 106         struct lttng_channel *chan;
 107
 108         mutex_lock(&sessions_mutex);
 109         if (session->active) {
 110                 ret = -EBUSY;
 111                 goto end;
 112         }
 113
 114         /*
 115          * Snapshot the number of events per channel to know the type of header
 116          * we need to use.
 117          */
 118         list_for_each_entry(chan, &session->chan, list) {
 119                 if (chan->header_type)
 120                         continue;               /* don't change it if session stop/restart */
 121                 if (chan->free_event_id < 31)
 122                         chan->header_type = 1;  /* compact */
 123                 else
 124                         chan->header_type = 2;  /* large */
 125         }
 126
 127         ACCESS_ONCE(session->active) = 1;
 128         ACCESS_ONCE(session->been_active) = 1;
 129         ret = _lttng_session_metadata_statedump(session);
 130         if (ret) {
 131                 ACCESS_ONCE(session->active) = 0;
 132                 goto end;
 133         }
 134         ret = lttng_statedump_start(session);
 135         if (ret)
 136                 ACCESS_ONCE(session->active) = 0;
 137 end:
 138         mutex_unlock(&sessions_mutex);
 139         return ret;
 140 }
 141
 142 int lttng_session_disable(struct lttng_session *session)
 143 {
 144         int ret = 0;
 145
 146         mutex_lock(&sessions_mutex);
 147         if (!session->active) {
 148                 ret = -EBUSY;
 149                 goto end;
 150         }
 151         ACCESS_ONCE(session->active) = 0;
 152 end:
 153         mutex_unlock(&sessions_mutex);
 154         return ret;
 155 }
 156
 157 int lttng_channel_enable(struct lttng_channel *channel)
 158 {
 159         int old;
 160
 161         if (channel == channel->session->metadata)
 162                 return -EPERM;
 163         old = xchg(&channel->enabled, 1);
 164         if (old)
 165                 return -EEXIST;
 166         return 0;
 167 }
 168
 169 int lttng_channel_disable(struct lttng_channel *channel)
 170 {
 171         int old;
 172
 173         if (channel == channel->session->metadata)
 174                 return -EPERM;
 175         old = xchg(&channel->enabled, 0);
 176         if (!old)
 177                 return -EEXIST;
 178         return 0;
 179 }
 180
 181 int lttng_event_enable(struct lttng_event *event)
 182 {
 183         int old;
 184
 185         if (event->chan == event->chan->session->metadata)
 186                 return -EPERM;
 187         old = xchg(&event->enabled, 1);
 188         if (old)
 189                 return -EEXIST;
 190         return 0;
 191 }
 192
 193 int lttng_event_disable(struct lttng_event *event)
 194 {
 195         int old;
 196
 197         if (event->chan == event->chan->session->metadata)
 198                 return -EPERM;
 199         old = xchg(&event->enabled, 0);
 200         if (!old)
 201                 return -EEXIST;
 202         return 0;
 203 }
 204
 205 static struct lttng_transport *lttng_transport_find(const char *name)
 206 {
 207         struct lttng_transport *transport;
 208
 209         list_for_each_entry(transport, &lttng_transport_list, node) {
 210                 if (!strcmp(transport->name, name))
 211                         return transport;
 212         }
 213         return NULL;
 214 }
 215
 216 struct lttng_channel *lttng_channel_create(struct lttng_session *session,
 217                                        const char *transport_name,
 218                                        void *buf_addr,
 219                                        size_t subbuf_size, size_t num_subbuf,
 220                                        unsigned int switch_timer_interval,
 221                                        unsigned int read_timer_interval)
 222 {
 223         struct lttng_channel *chan;
 224         struct lttng_transport *transport = NULL;
 225
 226         mutex_lock(&sessions_mutex);
 227         if (session->been_active)
 228                 goto active;    /* Refuse to add channel to active session */
 229         transport = lttng_transport_find(transport_name);
 230         if (!transport) {
 231                 printk(KERN_WARNING "LTTng transport %s not found\n",
 232                        transport_name);
 233                 goto notransport;
 234         }
 235         if (!try_module_get(transport->owner)) {
 236                 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
 237                 goto notransport;
 238         }
 239         chan = kzalloc(sizeof(struct lttng_channel), GFP_KERNEL);
 240         if (!chan)
 241                 goto nomem;
 242         chan->session = session;
 243         chan->id = session->free_chan_id++;
 244         /*
 245          * Note: the channel creation op already writes into the packet
 246          * headers. Therefore the "chan" information used as input
 247          * should be already accessible.
 248          */
 249         chan->chan = transport->ops.channel_create(transport_name,
 250                         chan, buf_addr, subbuf_size, num_subbuf,
 251                         switch_timer_interval, read_timer_interval);
 252         if (!chan->chan)
 253                 goto create_error;
 254         chan->enabled = 1;
 255         chan->ops = &transport->ops;
 256         chan->transport = transport;
 257         list_add(&chan->list, &session->chan);
 258         mutex_unlock(&sessions_mutex);
 259         return chan;
 260
 261 create_error:
 262         kfree(chan);
 263 nomem:
 264         if (transport)
 265                 module_put(transport->owner);
 266 notransport:
 267 active:
 268         mutex_unlock(&sessions_mutex);
 269         return NULL;
 270 }
 271
 272 /*
 273  * Only used internally at session destruction.
 274  */
 275 static
 276 void _lttng_channel_destroy(struct lttng_channel *chan)
 277 {
 278         chan->ops->channel_destroy(chan->chan);
 279         module_put(chan->transport->owner);
 280         list_del(&chan->list);
 281         lttng_destroy_context(chan->ctx);
 282         kfree(chan);
 283 }
 284
 285 /*
 286  * Supports event creation while tracing session is active.
 287  */
 288 struct lttng_event *lttng_event_create(struct lttng_channel *chan,
 289                                    struct lttng_kernel_event *event_param,
 290                                    void *filter,
 291                                    const struct lttng_event_desc *internal_desc)
 292 {
 293         struct lttng_event *event;
 294         int ret;
 295
 296         mutex_lock(&sessions_mutex);
 297         if (chan->free_event_id == -1U)
 298                 goto full;
 299         /*
 300          * This is O(n^2) (for each event, the loop is called at event
 301          * creation). Might require a hash if we have lots of events.
 302          */
 303         list_for_each_entry(event, &chan->session->events, list)
 304                 if (!strcmp(event->desc->name, event_param->name))
 305                         goto exist;
 306         event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
 307         if (!event)
 308                 goto cache_error;
 309         event->chan = chan;
 310         event->filter = filter;
 311         event->id = chan->free_event_id++;
 312         event->enabled = 1;
 313         event->instrumentation = event_param->instrumentation;
 314         /* Populate lttng_event structure before tracepoint registration. */
 315         smp_wmb();
 316         switch (event_param->instrumentation) {
 317         case LTTNG_KERNEL_TRACEPOINT:
 318                 event->desc = lttng_event_get(event_param->name);
 319                 if (!event->desc)
 320                         goto register_error;
 321                 ret = kabi_2635_tracepoint_probe_register(event_param->name,
 322                                 event->desc->probe_callback,
 323                                 event);
 324                 if (ret)
 325                         goto register_error;
 326                 break;
 327         case LTTNG_KERNEL_KPROBE:
 328                 ret = lttng_kprobes_register(event_param->name,
 329                                 event_param->u.kprobe.symbol_name,
 330                                 event_param->u.kprobe.offset,
 331                                 event_param->u.kprobe.addr,
 332                                 event);
 333                 if (ret)
 334                         goto register_error;
 335                 ret = try_module_get(event->desc->owner);
 336                 WARN_ON_ONCE(!ret);
 337                 break;
 338         case LTTNG_KERNEL_KRETPROBE:
 339         {
 340                 struct lttng_event *event_return;
 341
 342                 /* kretprobe defines 2 events */
 343                 event_return =
 344                         kmem_cache_zalloc(event_cache, GFP_KERNEL);
 345                 if (!event_return)
 346                         goto register_error;
 347                 event_return->chan = chan;
 348                 event_return->filter = filter;
 349                 event_return->id = chan->free_event_id++;
 350                 event_return->enabled = 1;
 351                 event_return->instrumentation = event_param->instrumentation;
 352                 /*
 353                  * Populate lttng_event structure before kretprobe registration.
 354                  */
 355                 smp_wmb();
 356                 ret = lttng_kretprobes_register(event_param->name,
 357                                 event_param->u.kretprobe.symbol_name,
 358                                 event_param->u.kretprobe.offset,
 359                                 event_param->u.kretprobe.addr,
 360                                 event, event_return);
 361                 if (ret) {
 362                         kmem_cache_free(event_cache, event_return);
 363                         goto register_error;
 364                 }
 365                 /* Take 2 refs on the module: one per event. */
 366                 ret = try_module_get(event->desc->owner);
 367                 WARN_ON_ONCE(!ret);
 368                 ret = try_module_get(event->desc->owner);
 369                 WARN_ON_ONCE(!ret);
 370                 ret = _lttng_event_metadata_statedump(chan->session, chan,
 371                                                     event_return);
 372                 if (ret) {
 373                         kmem_cache_free(event_cache, event_return);
 374                         module_put(event->desc->owner);
 375                         module_put(event->desc->owner);
 376                         goto statedump_error;
 377                 }
 378                 list_add(&event_return->list, &chan->session->events);
 379                 break;
 380         }
 381         case LTTNG_KERNEL_FUNCTION:
 382                 ret = lttng_ftrace_register(event_param->name,
 383                                 event_param->u.ftrace.symbol_name,
 384                                 event);
 385                 if (ret)
 386                         goto register_error;
 387                 ret = try_module_get(event->desc->owner);
 388                 WARN_ON_ONCE(!ret);
 389                 break;
 390         case LTTNG_KERNEL_NOOP:
 391                 event->desc = internal_desc;
 392                 if (!event->desc)
 393                         goto register_error;
 394                 break;
 395         default:
 396                 WARN_ON_ONCE(1);
 397         }
 398         ret = _lttng_event_metadata_statedump(chan->session, chan, event);
 399         if (ret)
 400                 goto statedump_error;
 401         list_add(&event->list, &chan->session->events);
 402         mutex_unlock(&sessions_mutex);
 403         return event;
 404
 405 statedump_error:
 406         /* If a statedump error occurs, events will not be readable. */
 407 register_error:
 408         kmem_cache_free(event_cache, event);
 409 cache_error:
 410 exist:
 411 full:
 412         mutex_unlock(&sessions_mutex);
 413         return NULL;
 414 }
 415
 416 /*
 417  * Only used internally at session destruction.
 418  */
 419 int _lttng_event_unregister(struct lttng_event *event)
 420 {
 421         int ret = -EINVAL;
 422
 423         switch (event->instrumentation) {
 424         case LTTNG_KERNEL_TRACEPOINT:
 425                 ret = kabi_2635_tracepoint_probe_unregister(event->desc->name,
 426                                                   event->desc->probe_callback,
 427                                                   event);
 428                 if (ret)
 429                         return ret;
 430                 break;
 431         case LTTNG_KERNEL_KPROBE:
 432                 lttng_kprobes_unregister(event);
 433                 ret = 0;
 434                 break;
 435         case LTTNG_KERNEL_KRETPROBE:
 436                 lttng_kretprobes_unregister(event);
 437                 ret = 0;
 438                 break;
 439         case LTTNG_KERNEL_FUNCTION:
 440                 lttng_ftrace_unregister(event);
 441                 ret = 0;
 442                 break;
 443         case LTTNG_KERNEL_NOOP:
 444                 ret = 0;
 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 _lttng_event_destroy(struct lttng_event *event)
 457 {
 458         switch (event->instrumentation) {
 459         case LTTNG_KERNEL_TRACEPOINT:
 460                 lttng_event_put(event->desc);
 461                 break;
 462         case LTTNG_KERNEL_KPROBE:
 463                 module_put(event->desc->owner);
 464                 lttng_kprobes_destroy_private(event);
 465                 break;
 466         case LTTNG_KERNEL_KRETPROBE:
 467                 module_put(event->desc->owner);
 468                 lttng_kretprobes_destroy_private(event);
 469                 break;
 470         case LTTNG_KERNEL_FUNCTION:
 471                 module_put(event->desc->owner);
 472                 lttng_ftrace_destroy_private(event);
 473                 break;
 474         case LTTNG_KERNEL_NOOP:
 475                 break;
 476         default:
 477                 WARN_ON_ONCE(1);
 478         }
 479         list_del(&event->list);
 480         lttng_destroy_context(event->ctx);
 481         kmem_cache_free(event_cache, event);
 482 }
 483
 484 /*
 485  * We have exclusive access to our metadata buffer (protected by the
 486  * sessions_mutex), so we can do racy operations such as looking for
 487  * remaining space left in packet and write, since mutual exclusion
 488  * protects us from concurrent writes.
 489  */
 490 int lttng_metadata_printf(struct lttng_session *session,
 491                           const char *fmt, ...)
 492 {
 493         struct lib_ring_buffer_ctx ctx;
 494         struct lttng_channel *chan = session->metadata;
 495         char *str;
 496         int ret = 0, waitret;
 497         size_t len, reserve_len, pos;
 498         va_list ap;
 499
 500         WARN_ON_ONCE(!ACCESS_ONCE(session->active));
 501
 502         va_start(ap, fmt);
 503         str = kvasprintf(GFP_KERNEL, fmt, ap);
 504         va_end(ap);
 505         if (!str)
 506                 return -ENOMEM;
 507
 508         len = strlen(str);
 509         pos = 0;
 510
 511         for (pos = 0; pos < len; pos += reserve_len) {
 512                 reserve_len = min_t(size_t,
 513                                 chan->ops->packet_avail_size(chan->chan),
 514                                 len - pos);
 515                 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
 516                                          sizeof(char), -1);
 517                 /*
 518                  * We don't care about metadata buffer's records lost
 519                  * count, because we always retry here. Report error if
 520                  * we need to bail out after timeout or being
 521                  * interrupted.
 522                  */
 523                 waitret = wait_event_interruptible_timeout(*chan->ops->get_writer_buf_wait_queue(chan->chan, -1),
 524                         ({
 525                                 ret = chan->ops->event_reserve(&ctx, 0);
 526                                 ret != -ENOBUFS || !ret;
 527                         }),
 528                         msecs_to_jiffies(LTTNG_METADATA_TIMEOUT_MSEC));
 529                 if (!waitret || waitret == -ERESTARTSYS || ret) {
 530                         printk(KERN_WARNING "LTTng: Failure to write metadata to buffers (%s)\n",
 531                                 waitret == -ERESTARTSYS ? "interrupted" :
 532                                         (ret == -ENOBUFS ? "timeout" : "I/O error"));
 533                         if (waitret == -ERESTARTSYS)
 534                                 ret = waitret;
 535                         goto end;
 536                 }
 537                 chan->ops->event_write(&ctx, &str[pos], reserve_len);
 538                 chan->ops->event_commit(&ctx);
 539         }
 540 end:
 541         kfree(str);
 542         return ret;
 543 }
 544
 545 static
 546 int _lttng_field_statedump(struct lttng_session *session,
 547                          const struct lttng_event_field *field)
 548 {
 549         int ret = 0;
 550
 551         switch (field->type.atype) {
 552         case atype_integer:
 553                 ret = lttng_metadata_printf(session,
 554                         "               integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
 555                         field->type.u.basic.integer.size,
 556                         field->type.u.basic.integer.alignment,
 557                         field->type.u.basic.integer.signedness,
 558                         (field->type.u.basic.integer.encoding == lttng_encode_none)
 559                                 ? "none"
 560                                 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
 561                                         ? "UTF8"
 562                                         : "ASCII",
 563                         field->type.u.basic.integer.base,
 564 #ifdef __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 #ifdef __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 #ifdef __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 #ifdef __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 _lttng_context_metadata_statedump(struct lttng_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 = _lttng_field_statedump(session, &field->event_field);
 677                 if (ret)
 678                         return ret;
 679         }
 680         return ret;
 681 }
 682
 683 static
 684 int _lttng_fields_metadata_statedump(struct lttng_session *session,
 685                                    struct lttng_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 = _lttng_field_statedump(session, field);
 695                 if (ret)
 696                         return ret;
 697         }
 698         return ret;
 699 }
 700
 701 static
 702 int _lttng_event_metadata_statedump(struct lttng_session *session,
 703                                   struct lttng_channel *chan,
 704                                   struct lttng_event *event)
 705 {
 706         int ret = 0;
 707
 708         if (event->metadata_dumped || !ACCESS_ONCE(session->active))
 709                 return 0;
 710         if (chan == session->metadata)
 711                 return 0;
 712
 713         ret = lttng_metadata_printf(session,
 714                 "event {\n"
 715                 "       name = %s;\n"
 716                 "       id = %u;\n"
 717                 "       stream_id = %u;\n",
 718                 event->desc->name,
 719                 event->id,
 720                 event->chan->id);
 721         if (ret)
 722                 goto end;
 723
 724         if (event->ctx) {
 725                 ret = lttng_metadata_printf(session,
 726                         "       context := struct {\n");
 727                 if (ret)
 728                         goto end;
 729         }
 730         ret = _lttng_context_metadata_statedump(session, event->ctx);
 731         if (ret)
 732                 goto end;
 733         if (event->ctx) {
 734                 ret = lttng_metadata_printf(session,
 735                         "       };\n");
 736                 if (ret)
 737                         goto end;
 738         }
 739
 740         ret = lttng_metadata_printf(session,
 741                 "       fields := struct {\n"
 742                 );
 743         if (ret)
 744                 goto end;
 745
 746         ret = _lttng_fields_metadata_statedump(session, event);
 747         if (ret)
 748                 goto end;
 749
 750         /*
 751          * LTTng space reservation can only reserve multiples of the
 752          * byte size.
 753          */
 754         ret = lttng_metadata_printf(session,
 755                 "       };\n"
 756                 "};\n\n");
 757         if (ret)
 758                 goto end;
 759
 760         event->metadata_dumped = 1;
 761 end:
 762         return ret;
 763
 764 }
 765
 766 static
 767 int _lttng_channel_metadata_statedump(struct lttng_session *session,
 768                                     struct lttng_channel *chan)
 769 {
 770         int ret = 0;
 771
 772         if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
 773                 return 0;
 774         if (chan == session->metadata)
 775                 return 0;
 776
 777         WARN_ON_ONCE(!chan->header_type);
 778         ret = lttng_metadata_printf(session,
 779                 "stream {\n"
 780                 "       id = %u;\n"
 781                 "       event.header := %s;\n"
 782                 "       packet.context := struct packet_context;\n",
 783                 chan->id,
 784                 chan->header_type == 1 ? "struct event_header_compact" :
 785                         "struct event_header_large");
 786         if (ret)
 787                 goto end;
 788
 789         if (chan->ctx) {
 790                 ret = lttng_metadata_printf(session,
 791                         "       event.context := struct {\n");
 792                 if (ret)
 793                         goto end;
 794         }
 795         ret = _lttng_context_metadata_statedump(session, chan->ctx);
 796         if (ret)
 797                 goto end;
 798         if (chan->ctx) {
 799                 ret = lttng_metadata_printf(session,
 800                         "       };\n");
 801                 if (ret)
 802                         goto end;
 803         }
 804
 805         ret = lttng_metadata_printf(session,
 806                 "};\n\n");
 807
 808         chan->metadata_dumped = 1;
 809 end:
 810         return ret;
 811 }
 812
 813 static
 814 int _lttng_stream_packet_context_declare(struct lttng_session *session)
 815 {
 816         return lttng_metadata_printf(session,
 817                 "struct packet_context {\n"
 818                 "       uint64_clock_monotonic_t timestamp_begin;\n"
 819                 "       uint64_clock_monotonic_t timestamp_end;\n"
 820                 "       uint64_t content_size;\n"
 821                 "       uint64_t packet_size;\n"
 822                 "       unsigned long events_discarded;\n"
 823                 "       uint32_t cpu_id;\n"
 824                 "};\n\n"
 825                 );
 826 }
 827
 828 /*
 829  * Compact header:
 830  * id: range: 0 - 30.
 831  * id 31 is reserved to indicate an extended header.
 832  *
 833  * Large header:
 834  * id: range: 0 - 65534.
 835  * id 65535 is reserved to indicate an extended header.
 836  */
 837 static
 838 int _lttng_event_header_declare(struct lttng_session *session)
 839 {
 840         return lttng_metadata_printf(session,
 841         "struct event_header_compact {\n"
 842         "       enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
 843         "       variant <id> {\n"
 844         "               struct {\n"
 845         "                       uint27_clock_monotonic_t timestamp;\n"
 846         "               } compact;\n"
 847         "               struct {\n"
 848         "                       uint32_t id;\n"
 849         "                       uint64_clock_monotonic_t timestamp;\n"
 850         "               } extended;\n"
 851         "       } v;\n"
 852         "} align(%u);\n"
 853         "\n"
 854         "struct event_header_large {\n"
 855         "       enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
 856         "       variant <id> {\n"
 857         "               struct {\n"
 858         "                       uint32_clock_monotonic_t timestamp;\n"
 859         "               } compact;\n"
 860         "               struct {\n"
 861         "                       uint32_t id;\n"
 862         "                       uint64_clock_monotonic_t timestamp;\n"
 863         "               } extended;\n"
 864         "       } v;\n"
 865         "} align(%u);\n\n",
 866         lttng_alignof(uint32_t) * CHAR_BIT,
 867         lttng_alignof(uint16_t) * CHAR_BIT
 868         );
 869 }
 870
 871  /*
 872  * Approximation of NTP time of day to clock monotonic correlation,
 873  * taken at start of trace.
 874  * Yes, this is only an approximation. Yes, we can (and will) do better
 875  * in future versions.
 876  */
 877 static
 878 uint64_t measure_clock_offset(void)
 879 {
 880         uint64_t offset, monotonic[2], realtime;
 881         struct timespec rts = { 0, 0 };
 882         unsigned long flags;
 883
 884         /* Disable interrupts to increase correlation precision. */
 885         local_irq_save(flags);
 886         monotonic[0] = trace_clock_read64();
 887         getnstimeofday(&rts);
 888         monotonic[1] = trace_clock_read64();
 889         local_irq_restore(flags);
 890
 891         offset = (monotonic[0] + monotonic[1]) >> 1;
 892         realtime = (uint64_t) rts.tv_sec * NSEC_PER_SEC;
 893         realtime += rts.tv_nsec;
 894         offset = realtime - offset;
 895         return offset;
 896 }
 897
 898 /*
 899  * Output metadata into this session's metadata buffers.
 900  */
 901 static
 902 int _lttng_session_metadata_statedump(struct lttng_session *session)
 903 {
 904         unsigned char *uuid_c = session->uuid.b;
 905         unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
 906         struct lttng_channel *chan;
 907         struct lttng_event *event;
 908         int ret = 0;
 909
 910         if (!ACCESS_ONCE(session->active))
 911                 return 0;
 912         if (session->metadata_dumped)
 913                 goto skip_session;
 914         if (!session->metadata) {
 915                 printk(KERN_WARNING "LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n");
 916                 return -EPERM;
 917         }
 918
 919         snprintf(uuid_s, sizeof(uuid_s),
 920                 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 921                 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
 922                 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
 923                 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
 924                 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
 925
 926         ret = lttng_metadata_printf(session,
 927                 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
 928                 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
 929                 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
 930                 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
 931                 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
 932                 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
 933                 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
 934                 "\n"
 935                 "trace {\n"
 936                 "       major = %u;\n"
 937                 "       minor = %u;\n"
 938                 "       uuid = \"%s\";\n"
 939                 "       byte_order = %s;\n"
 940                 "       packet.header := struct {\n"
 941                 "               uint32_t magic;\n"
 942                 "               uint8_t  uuid[16];\n"
 943                 "               uint32_t stream_id;\n"
 944                 "       };\n"
 945                 "};\n\n",
 946                 lttng_alignof(uint8_t) * CHAR_BIT,
 947                 lttng_alignof(uint16_t) * CHAR_BIT,
 948                 lttng_alignof(uint32_t) * CHAR_BIT,
 949                 lttng_alignof(uint64_t) * CHAR_BIT,
 950                 sizeof(unsigned long) * CHAR_BIT,
 951                 lttng_alignof(unsigned long) * CHAR_BIT,
 952                 CTF_SPEC_MAJOR,
 953                 CTF_SPEC_MINOR,
 954                 uuid_s,
 955 #ifdef __BIG_ENDIAN
 956                 "be"
 957 #else
 958                 "le"
 959 #endif
 960                 );
 961         if (ret)
 962                 goto end;
 963
 964         ret = lttng_metadata_printf(session,
 965                 "env {\n"
 966                 "       hostname = \"%s\";\n"
 967                 "       domain = \"kernel\";\n"
 968                 "       sysname = \"%s\";\n"
 969                 "       kernel_release = \"%s\";\n"
 970                 "       kernel_version = \"%s\";\n"
 971                 "       tracer_name = \"lttng-modules\";\n"
 972                 "       tracer_major = %d;\n"
 973                 "       tracer_minor = %d;\n"
 974                 "       tracer_patchlevel = %d;\n"
 975                 "};\n\n",
 976                 current->nsproxy->uts_ns->name.nodename,
 977                 utsname()->sysname,
 978                 utsname()->release,
 979                 utsname()->version,
 980                 LTTNG_MODULES_MAJOR_VERSION,
 981                 LTTNG_MODULES_MINOR_VERSION,
 982                 LTTNG_MODULES_PATCHLEVEL_VERSION
 983                 );
 984         if (ret)
 985                 goto end;
 986
 987         ret = lttng_metadata_printf(session,
 988                 "clock {\n"
 989                 "       name = %s;\n",
 990                 "monotonic"
 991                 );
 992         if (ret)
 993                 goto end;
 994
 995         if (!trace_clock_uuid(clock_uuid_s)) {
 996                 ret = lttng_metadata_printf(session,
 997                         "       uuid = \"%s\";\n",
 998                         clock_uuid_s
 999                         );
1000                 if (ret)
1001                         goto end;
1002         }
1003
1004         ret = lttng_metadata_printf(session,
1005                 "       description = \"Monotonic Clock\";\n"
1006                 "       freq = %llu; /* Frequency, in Hz */\n"
1007                 "       /* clock value offset from Epoch is: offset * (1/freq) */\n"
1008                 "       offset = %llu;\n"
1009                 "};\n\n",
1010                 (unsigned long long) trace_clock_freq(),
1011                 (unsigned long long) measure_clock_offset()
1012                 );
1013         if (ret)
1014                 goto end;
1015
1016         ret = lttng_metadata_printf(session,
1017                 "typealias integer {\n"
1018                 "       size = 27; align = 1; signed = false;\n"
1019                 "       map = clock.monotonic.value;\n"
1020                 "} := uint27_clock_monotonic_t;\n"
1021                 "\n"
1022                 "typealias integer {\n"
1023                 "       size = 32; align = %u; signed = false;\n"
1024                 "       map = clock.monotonic.value;\n"
1025                 "} := uint32_clock_monotonic_t;\n"
1026                 "\n"
1027                 "typealias integer {\n"
1028                 "       size = 64; align = %u; signed = false;\n"
1029                 "       map = clock.monotonic.value;\n"
1030                 "} := uint64_clock_monotonic_t;\n\n",
1031                 lttng_alignof(uint32_t) * CHAR_BIT,
1032                 lttng_alignof(uint64_t) * CHAR_BIT
1033                 );
1034         if (ret)
1035                 goto end;
1036
1037         ret = _lttng_stream_packet_context_declare(session);
1038         if (ret)
1039                 goto end;
1040
1041         ret = _lttng_event_header_declare(session);
1042         if (ret)
1043                 goto end;
1044
1045 skip_session:
1046         list_for_each_entry(chan, &session->chan, list) {
1047                 ret = _lttng_channel_metadata_statedump(session, chan);
1048                 if (ret)
1049                         goto end;
1050         }
1051
1052         list_for_each_entry(event, &session->events, list) {
1053                 ret = _lttng_event_metadata_statedump(session, event->chan, event);
1054                 if (ret)
1055                         goto end;
1056         }
1057         session->metadata_dumped = 1;
1058 end:
1059         return ret;
1060 }
1061
1062 /**
1063  * lttng_transport_register - LTT transport registration
1064  * @transport: transport structure
1065  *
1066  * Registers a transport which can be used as output to extract the data out of
1067  * LTTng. The module calling this registration function must ensure that no
1068  * trap-inducing code will be executed by the transport functions. E.g.
1069  * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
1070  * is made visible to the transport function. This registration acts as a
1071  * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
1072  * after its registration must it synchronize the TLBs.
1073  */
1074 void lttng_transport_register(struct lttng_transport *transport)
1075 {
1076         /*
1077          * Make sure no page fault can be triggered by the module about to be
1078          * registered. We deal with this here so we don't have to call
1079          * vmalloc_sync_all() in each module's init.
1080          */
1081         wrapper_vmalloc_sync_all();
1082
1083         mutex_lock(&sessions_mutex);
1084         list_add_tail(&transport->node, &lttng_transport_list);
1085         mutex_unlock(&sessions_mutex);
1086 }
1087 EXPORT_SYMBOL_GPL(lttng_transport_register);
1088
1089 /**
1090  * lttng_transport_unregister - LTT transport unregistration
1091  * @transport: transport structure
1092  */
1093 void lttng_transport_unregister(struct lttng_transport *transport)
1094 {
1095         mutex_lock(&sessions_mutex);
1096         list_del(&transport->node);
1097         mutex_unlock(&sessions_mutex);
1098 }
1099 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
1100
1101 static int __init lttng_events_init(void)
1102 {
1103         int ret;
1104
1105         event_cache = KMEM_CACHE(lttng_event, 0);
1106         if (!event_cache)
1107                 return -ENOMEM;
1108         ret = lttng_abi_init();
1109         if (ret)
1110                 goto error_abi;
1111         return 0;
1112 error_abi:
1113         kmem_cache_destroy(event_cache);
1114         return ret;
1115 }
1116
1117 module_init(lttng_events_init);
1118
1119 static void __exit lttng_events_exit(void)
1120 {
1121         struct lttng_session *session, *tmpsession;
1122
1123         lttng_abi_exit();
1124         list_for_each_entry_safe(session, tmpsession, &sessions, list)
1125                 lttng_session_destroy(session);
1126         kmem_cache_destroy(event_cache);
1127 }
1128
1129 module_exit(lttng_events_exit);
1130
1131 MODULE_LICENSE("GPL and additional rights");
1132 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
1133 MODULE_DESCRIPTION("LTTng Events");