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
   9 #include <linux/module.h>
  10 #include <linux/list.h>
  11 #include <linux/mutex.h>
  12 #include <linux/sched.h>
  13 #include <linux/slab.h>
  14 #include <linux/jiffies.h>
  15 #include "wrapper/vmalloc.h"    /* for wrapper_vmalloc_sync_all() */
  16 #include "ltt-events.h"
  17 #include "ltt-tracer.h"
  18
  19 static LIST_HEAD(sessions);
  20 static LIST_HEAD(ltt_transport_list);
  21 static DEFINE_MUTEX(sessions_mutex);
  22 static struct kmem_cache *event_cache;
  23
  24 static
  25 int _ltt_event_metadata_statedump(struct ltt_session *session,
  26                                   struct ltt_channel *chan,
  27                                   struct ltt_event *event);
  28 static
  29 int _ltt_session_metadata_statedump(struct ltt_session *session);
  30
  31
  32 static
  33 void synchronize_trace(void)
  34 {
  35         synchronize_sched();
  36 #ifdef CONFIG_PREEMPT_RT
  37         synchronize_rcu();
  38 #endif
  39 }
  40
  41 struct ltt_session *ltt_session_create(void)
  42 {
  43         struct ltt_session *session;
  44
  45         mutex_lock(&sessions_mutex);
  46         session = kzalloc(sizeof(struct ltt_session), GFP_KERNEL);
  47         if (!session)
  48                 return NULL;
  49         INIT_LIST_HEAD(&session->chan);
  50         INIT_LIST_HEAD(&session->events);
  51         list_add(&session->list, &sessions);
  52         mutex_unlock(&sessions_mutex);
  53         return session;
  54 }
  55
  56 void ltt_session_destroy(struct ltt_session *session)
  57 {
  58         struct ltt_channel *chan, *tmpchan;
  59         struct ltt_event *event, *tmpevent;
  60         int ret;
  61
  62         mutex_lock(&sessions_mutex);
  63         ACCESS_ONCE(session->active) = 0;
  64         list_for_each_entry(event, &session->events, list) {
  65                 ret = _ltt_event_unregister(event);
  66                 WARN_ON(ret);
  67         }
  68         synchronize_trace();    /* Wait for in-flight events to complete */
  69         list_for_each_entry_safe(event, tmpevent, &session->events, list)
  70                 _ltt_event_destroy(event);
  71         list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
  72                 _ltt_channel_destroy(chan);
  73         list_del(&session->list);
  74         mutex_unlock(&sessions_mutex);
  75         kfree(session);
  76 }
  77
  78 int ltt_session_start(struct ltt_session *session)
  79 {
  80         int ret = 0;
  81         struct ltt_channel *chan;
  82
  83         mutex_lock(&sessions_mutex);
  84         if (session->active) {
  85                 ret = -EBUSY;
  86                 goto end;
  87         }
  88
  89         /*
  90          * Snapshot the number of events per channel to know the type of header
  91          * we need to use.
  92          */
  93         list_for_each_entry(chan, &session->chan, list) {
  94                 if (chan->header_type)
  95                         continue;               /* don't change it if session stop/restart */
  96                 if (chan->free_event_id < 31)
  97                         chan->header_type = 1;  /* compact */
  98                 else
  99                         chan->header_type = 2;  /* large */
 100         }
 101
 102         ACCESS_ONCE(session->active) = 1;
 103         synchronize_trace();    /* Wait for in-flight events to complete */
 104         ret = _ltt_session_metadata_statedump(session);
 105         if (ret) {
 106                 ACCESS_ONCE(session->active) = 0;
 107                 synchronize_trace();    /* Wait for in-flight events to complete */
 108         }
 109 end:
 110         mutex_unlock(&sessions_mutex);
 111         return ret;
 112 }
 113
 114 int ltt_session_stop(struct ltt_session *session)
 115 {
 116         int ret = 0;
 117
 118         mutex_lock(&sessions_mutex);
 119         if (!session->active) {
 120                 ret = -EBUSY;
 121                 goto end;
 122         }
 123         ACCESS_ONCE(session->active) = 0;
 124         synchronize_trace();    /* Wait for in-flight events to complete */
 125 end:
 126         mutex_unlock(&sessions_mutex);
 127         return ret;
 128 }
 129
 130 static struct ltt_transport *ltt_transport_find(const char *name)
 131 {
 132         struct ltt_transport *transport;
 133
 134         list_for_each_entry(transport, &ltt_transport_list, node) {
 135                 if (!strcmp(transport->name, name))
 136                         return transport;
 137         }
 138         return NULL;
 139 }
 140
 141 struct ltt_channel *ltt_channel_create(struct ltt_session *session,
 142                                        const char *transport_name,
 143                                        void *buf_addr,
 144                                        size_t subbuf_size, size_t num_subbuf,
 145                                        unsigned int switch_timer_interval,
 146                                        unsigned int read_timer_interval)
 147 {
 148         struct ltt_channel *chan;
 149         struct ltt_transport *transport;
 150
 151         mutex_lock(&sessions_mutex);
 152         if (session->active) {
 153                 printk(KERN_WARNING "LTTng refusing to add channel to active session\n");
 154                 goto active;    /* Refuse to add channel to active session */
 155         }
 156         transport = ltt_transport_find(transport_name);
 157         if (!transport) {
 158                 printk(KERN_WARNING "LTTng transport %s not found\n",
 159                        transport_name);
 160                 goto notransport;
 161         }
 162         chan = kzalloc(sizeof(struct ltt_channel), GFP_KERNEL);
 163         if (!chan)
 164                 goto nomem;
 165         chan->session = session;
 166         init_waitqueue_head(&chan->notify_wait);
 167         chan->chan = transport->ops.channel_create("[lttng]", session, buf_addr,
 168                         subbuf_size, num_subbuf, switch_timer_interval,
 169                         read_timer_interval);
 170         if (!chan->chan)
 171                 goto create_error;
 172         chan->id = session->free_chan_id++;
 173         chan->ops = &transport->ops;
 174         list_add(&chan->list, &session->chan);
 175         mutex_unlock(&sessions_mutex);
 176         return chan;
 177
 178 create_error:
 179         kfree(chan);
 180 nomem:
 181 notransport:
 182 active:
 183         mutex_unlock(&sessions_mutex);
 184         return NULL;
 185 }
 186
 187 /*
 188  * Only used internally at session destruction.
 189  */
 190 void _ltt_channel_destroy(struct ltt_channel *chan)
 191 {
 192         chan->ops->channel_destroy(chan->chan);
 193         list_del(&chan->list);
 194         kfree(chan);
 195 }
 196
 197 /*
 198  * Supports event creation while tracing session is active.
 199  */
 200 struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name,
 201                                    enum instrum_type itype,
 202                                    const struct lttng_event_desc *event_desc,
 203                                    void *filter)
 204 {
 205         struct ltt_event *event;
 206         int ret;
 207
 208         mutex_lock(&sessions_mutex);
 209         if (chan->free_event_id == -1UL)
 210                 goto full;
 211         /*
 212          * This is O(n^2) (for each event, the loop is called at event
 213          * creation). Might require a hash if we have lots of events.
 214          */
 215         list_for_each_entry(event, &chan->session->events, list)
 216                 if (!strcmp(event->desc->name, name))
 217                         goto exist;
 218         event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
 219         if (!event)
 220                 goto cache_error;
 221         event->chan = chan;
 222         event->desc = event_desc;
 223         event->filter = filter;
 224         event->id = chan->free_event_id++;
 225         event->itype = itype;
 226         /* Populate ltt_event structure before tracepoint registration. */
 227         smp_wmb();
 228         switch (itype) {
 229         case INSTRUM_TRACEPOINTS:
 230                 ret = tracepoint_probe_register(name, event_desc->probe_callback,
 231                                                 event);
 232                 if (ret)
 233                         goto register_error;
 234                 break;
 235         default:
 236                 WARN_ON_ONCE(1);
 237         }
 238         ret = _ltt_event_metadata_statedump(chan->session, chan, event);
 239         if (ret)
 240                 goto statedump_error;
 241         list_add(&event->list, &chan->session->events);
 242         mutex_unlock(&sessions_mutex);
 243         return event;
 244
 245 statedump_error:
 246         WARN_ON_ONCE(tracepoint_probe_unregister(name, event_desc->probe_callback,
 247                                                  event));
 248 register_error:
 249         kmem_cache_free(event_cache, event);
 250 cache_error:
 251 exist:
 252 full:
 253         mutex_unlock(&sessions_mutex);
 254         return NULL;
 255 }
 256
 257 /*
 258  * Only used internally at session destruction.
 259  */
 260 int _ltt_event_unregister(struct ltt_event *event)
 261 {
 262         int ret = -EINVAL;
 263
 264         switch (event->itype) {
 265         case INSTRUM_TRACEPOINTS:
 266                 ret = tracepoint_probe_unregister(event->desc->name,
 267                                                   event->desc->probe_callback,
 268                                                   event);
 269                 if (ret)
 270                         return ret;
 271                 break;
 272         default:
 273                 WARN_ON_ONCE(1);
 274         }
 275         return ret;
 276 }
 277
 278 /*
 279  * Only used internally at session destruction.
 280  */
 281 void _ltt_event_destroy(struct ltt_event *event)
 282 {
 283         ltt_event_put(event->desc);
 284         list_del(&event->list);
 285         kmem_cache_free(event_cache, event);
 286 }
 287
 288 int lttng_metadata_printf(struct ltt_session *session,
 289                           const char *fmt, ...)
 290 {
 291         struct lib_ring_buffer_ctx ctx;
 292         struct ltt_channel *chan = session->metadata;
 293         char *str;
 294         int ret = 0, waitret;
 295         size_t len;
 296         va_list ap;
 297
 298         WARN_ON_ONCE(!ACCESS_ONCE(session->active));
 299
 300         va_start(ap, fmt);
 301         str = kvasprintf(GFP_KERNEL, fmt, ap);
 302         va_end(ap);
 303         if (!str)
 304                 return -ENOMEM;
 305
 306         len = strlen(str) + 1;
 307         lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, len, sizeof(char), -1);
 308         /*
 309          * We don't care about metadata buffer's records lost count, because we
 310          * always retry here. Report error if we need to bail out after timeout
 311          * or being interrupted.
 312          */
 313         waitret = wait_event_interruptible_timeout(*chan->ops->get_reader_wait_queue(chan),
 314                 ({
 315                         ret = chan->ops->event_reserve(&ctx);
 316                         ret != -ENOBUFS || !ret;
 317                 }),
 318                 msecs_to_jiffies(LTTNG_METADATA_TIMEOUT_MSEC));
 319         if (waitret || ret) {
 320                 printk(KERN_WARNING "LTTng: Failure to write metadata to buffers (%s)\n",
 321                         waitret == -ERESTARTSYS ? "interrupted" :
 322                                 (ret == -ENOBUFS ? "timeout" : "I/O error"));
 323                 if (waitret == -ERESTARTSYS)
 324                         ret = waitret;
 325                 goto end;
 326         }
 327         chan->ops->event_write(&ctx, str, len);
 328         chan->ops->event_commit(&ctx);
 329 end:
 330         kfree(str);
 331         return ret;
 332 }
 333
 334 static
 335 int _ltt_fields_metadata_statedump(struct ltt_session *session,
 336                                    struct ltt_event *event)
 337 {
 338         const struct lttng_event_desc *desc = event->desc;
 339         int ret = 0;
 340         int i;
 341
 342         for (i = 0; i < desc->nr_fields; i++) {
 343                 const struct lttng_event_field *field = &desc->fields[i];
 344
 345                 switch (field->type.atype) {
 346                 case atype_integer:
 347                         ret = lttng_metadata_printf(session,
 348                                 "               integer { size = %u; align = %u; signed = %u;%s } %s;\n",
 349                                 field->type.u.basic.integer.size,
 350                                 field->type.u.basic.integer.alignment,
 351                                 field->type.u.basic.integer.signedness,
 352 #ifdef __BIG_ENDIAN
 353                                 field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 354 #else
 355                                 field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 356 #endif
 357                                 field->name);
 358                         break;
 359                 case atype_enum:
 360                         ret = lttng_metadata_printf(session,
 361                                 "               %s %s;\n",
 362                                 field->type.u.basic.enumeration.name,
 363                                 field->name);
 364                         break;
 365                 case atype_array:
 366                 {
 367                         const struct lttng_basic_type *elem_type;
 368
 369                         elem_type = &field->type.u.array.elem_type;
 370                         ret = lttng_metadata_printf(session,
 371                                 "               integer { size = %u; align = %u; signed = %u;%s } %s[%u];\n",
 372                                 elem_type->u.basic.integer.size,
 373                                 elem_type->u.basic.integer.alignment,
 374                                 elem_type->u.basic.integer.signedness,
 375 #ifdef __BIG_ENDIAN
 376                                 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 377 #else
 378                                 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 379 #endif
 380                                 field->name, field->type.u.array.length);
 381                         break;
 382                 }
 383                 case atype_sequence:
 384                 {
 385                         const struct lttng_basic_type *elem_type;
 386                         const struct lttng_basic_type *length_type;
 387
 388                         elem_type = &field->type.u.sequence.elem_type;
 389                         length_type = &field->type.u.sequence.length_type;
 390                         ret = lttng_metadata_printf(session,
 391                                 "               integer { size = %u; align = %u; signed = %u;%s } %s[ integer { size = %u; align = %u; signed = %u;%s } ];\n",
 392                                 elem_type->u.basic.integer.size,
 393                                 elem_type->u.basic.integer.alignment,
 394                                 elem_type->u.basic.integer.signedness,
 395 #ifdef __BIG_ENDIAN
 396                                 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 397 #else
 398                                 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
 399 #endif
 400                                 field->name,
 401                                         length_type->u.basic.integer.size,
 402                                         length_type->u.basic.integer.alignment,
 403                                         length_type->u.basic.integer.signedness,
 404 #ifdef __BIG_ENDIAN
 405                                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 406 #else
 407                                         length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : ""
 408 #endif
 409                                 );
 410                         break;
 411                 }
 412
 413                 case atype_string:
 414                         ret = lttng_metadata_printf(session,
 415                                 "               string%s %s;\n",
 416                                 field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 417                                         " { encoding = ASCII; }" : "",
 418                                 field->name);
 419                         break;
 420                 default:
 421                         WARN_ON_ONCE(1);
 422                         return -EINVAL;
 423                 }
 424         }
 425         return ret;
 426 }
 427
 428 static
 429 int _ltt_event_metadata_statedump(struct ltt_session *session,
 430                                   struct ltt_channel *chan,
 431                                   struct ltt_event *event)
 432 {
 433         int ret = 0;
 434
 435         if (event->metadata_dumped || !ACCESS_ONCE(session->active))
 436                 return 0;
 437         if (chan == session->metadata)
 438                 return 0;
 439
 440         ret = lttng_metadata_printf(session,
 441                 "event {\n"
 442                 "       name = %s;\n"
 443                 "       id = %u;\n"
 444                 "       stream_id = %u;\n"
 445                 "       event.fields := struct {\n",
 446                 event->desc->name,
 447                 event->id,
 448                 event->chan->id);
 449         if (ret)
 450                 goto end;
 451
 452         ret = _ltt_fields_metadata_statedump(session, event);
 453         if (ret)
 454                 goto end;
 455
 456         /*
 457          * LTTng space reservation can only reserve multiples of the
 458          * byte size.
 459          */
 460         ret = lttng_metadata_printf(session,
 461                 "       } aligned(%u);\n"
 462                 "};\n", ltt_get_header_alignment());
 463         if (ret)
 464                 goto end;
 465
 466
 467
 468
 469         event->metadata_dumped = 1;
 470 end:
 471         return ret;
 472
 473 }
 474
 475 static
 476 int _ltt_channel_metadata_statedump(struct ltt_session *session,
 477                                     struct ltt_channel *chan)
 478 {
 479         int ret = 0;
 480
 481         if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
 482                 return 0;
 483         if (chan == session->metadata)
 484                 return 0;
 485
 486         WARN_ON_ONCE(!chan->header_type);
 487         ret = lttng_metadata_printf(session,
 488                 "stream {\n"
 489                 "       id = %u;\n"
 490                 "       event.header := %s;\n",
 491                 "};\n",
 492                 chan->id,
 493                 chan->header_type == 1 ? "struct event_header_compact" :
 494                         "struct event_header_large");
 495         if (ret)
 496                 goto end;
 497
 498         chan->metadata_dumped = 1;
 499 end:
 500         return ret;
 501 }
 502
 503 /*
 504  * Output metadata into this session's metadata buffers.
 505  */
 506 static
 507 int _ltt_session_metadata_statedump(struct ltt_session *session)
 508 {
 509         struct ltt_channel *chan;
 510         struct ltt_event *event;
 511         int ret = 0;
 512
 513         if (!ACCESS_ONCE(session->active))
 514                 return 0;
 515         if (session->metadata_dumped)
 516                 goto skip_session;
 517
 518
 519
 520
 521 skip_session:
 522         list_for_each_entry(chan, &session->chan, list) {
 523                 ret = _ltt_channel_metadata_statedump(session, chan);
 524                 if (ret)
 525                         goto end;
 526         }
 527
 528         list_for_each_entry(event, &session->events, list) {
 529                 ret = _ltt_event_metadata_statedump(session, chan, event);
 530                 if (ret)
 531                         goto end;
 532         }
 533         session->metadata_dumped = 1;
 534 end:
 535         return ret;
 536 }
 537
 538 /**
 539  * ltt_transport_register - LTT transport registration
 540  * @transport: transport structure
 541  *
 542  * Registers a transport which can be used as output to extract the data out of
 543  * LTTng. The module calling this registration function must ensure that no
 544  * trap-inducing code will be executed by the transport functions. E.g.
 545  * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
 546  * is made visible to the transport function. This registration acts as a
 547  * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
 548  * after its registration must it synchronize the TLBs.
 549  */
 550 void ltt_transport_register(struct ltt_transport *transport)
 551 {
 552         /*
 553          * Make sure no page fault can be triggered by the module about to be
 554          * registered. We deal with this here so we don't have to call
 555          * vmalloc_sync_all() in each module's init.
 556          */
 557         wrapper_vmalloc_sync_all();
 558
 559         mutex_lock(&sessions_mutex);
 560         list_add_tail(&transport->node, &ltt_transport_list);
 561         mutex_unlock(&sessions_mutex);
 562 }
 563 EXPORT_SYMBOL_GPL(ltt_transport_register);
 564
 565 /**
 566  * ltt_transport_unregister - LTT transport unregistration
 567  * @transport: transport structure
 568  */
 569 void ltt_transport_unregister(struct ltt_transport *transport)
 570 {
 571         mutex_lock(&sessions_mutex);
 572         list_del(&transport->node);
 573         mutex_unlock(&sessions_mutex);
 574 }
 575 EXPORT_SYMBOL_GPL(ltt_transport_unregister);
 576
 577 static int __init ltt_events_init(void)
 578 {
 579         int ret;
 580
 581         event_cache = KMEM_CACHE(ltt_event, 0);
 582         if (!event_cache)
 583                 return -ENOMEM;
 584         ret = ltt_debugfs_abi_init();
 585         if (ret)
 586                 goto error_abi;
 587         return 0;
 588 error_abi:
 589         kmem_cache_destroy(event_cache);
 590         return ret;
 591 }
 592
 593 module_init(ltt_events_init);
 594
 595 static void __exit ltt_events_exit(void)
 596 {
 597         struct ltt_session *session, *tmpsession;
 598
 599         ltt_debugfs_abi_exit();
 600         list_for_each_entry_safe(session, tmpsession, &sessions, list)
 601                 ltt_session_destroy(session);
 602         kmem_cache_destroy(event_cache);
 603 }
 604
 605 module_exit(ltt_events_exit);
 606
 607 MODULE_LICENSE("GPL and additional rights");
 608 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 609 MODULE_DESCRIPTION("LTTng Events");