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                         break;
 367                 case atype_sequence:
 368                         break;
 369
 370                 case atype_string:
 371                         ret = lttng_metadata_printf(session,
 372                                 "               string%s %s;\n",
 373                                 field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 374                                         " { encoding = ASCII; }" : "",
 375                                 field->name);
 376                         break;
 377                 default:
 378                         WARN_ON_ONCE(1);
 379                         return -EINVAL;
 380                 }
 381         }
 382         return ret;
 383 }
 384
 385 static
 386 int _ltt_event_metadata_statedump(struct ltt_session *session,
 387                                   struct ltt_channel *chan,
 388                                   struct ltt_event *event)
 389 {
 390         int ret = 0;
 391
 392         if (event->metadata_dumped || !ACCESS_ONCE(session->active))
 393                 return 0;
 394         if (chan == session->metadata)
 395                 return 0;
 396
 397         ret = lttng_metadata_printf(session,
 398                 "event {\n"
 399                 "       name = %s;\n"
 400                 "       id = %u;\n"
 401                 "       stream_id = %u;\n"
 402                 "       event.fields := struct {\n",
 403                 event->desc->name,
 404                 event->id,
 405                 event->chan->id);
 406         if (ret)
 407                 goto end;
 408
 409         ret = _ltt_fields_metadata_statedump(session, event);
 410         if (ret)
 411                 goto end;
 412
 413         /*
 414          * LTTng space reservation can only reserve multiples of the
 415          * byte size.
 416          */
 417         ret = lttng_metadata_printf(session,
 418                 "       } aligned(%u);\n"
 419                 "};\n", ltt_get_header_alignment());
 420         if (ret)
 421                 goto end;
 422
 423
 424
 425
 426         event->metadata_dumped = 1;
 427 end:
 428         return ret;
 429
 430 }
 431
 432 static
 433 int _ltt_channel_metadata_statedump(struct ltt_session *session,
 434                                     struct ltt_channel *chan)
 435 {
 436         int ret = 0;
 437
 438         if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
 439                 return 0;
 440         if (chan == session->metadata)
 441                 return 0;
 442
 443         WARN_ON_ONCE(!chan->header_type);
 444         ret = lttng_metadata_printf(session,
 445                 "stream {\n"
 446                 "       id = %u;\n"
 447                 "       event.header := %s;\n",
 448                 "};\n",
 449                 chan->id,
 450                 chan->header_type == 1 ? "struct event_header_compact" :
 451                         "struct event_header_large");
 452         if (ret)
 453                 goto end;
 454
 455         chan->metadata_dumped = 1;
 456 end:
 457         return ret;
 458 }
 459
 460 /*
 461  * Output metadata into this session's metadata buffers.
 462  */
 463 static
 464 int _ltt_session_metadata_statedump(struct ltt_session *session)
 465 {
 466         struct ltt_channel *chan;
 467         struct ltt_event *event;
 468         int ret = 0;
 469
 470         if (!ACCESS_ONCE(session->active))
 471                 return 0;
 472         if (session->metadata_dumped)
 473                 goto skip_session;
 474
 475
 476
 477
 478 skip_session:
 479         list_for_each_entry(chan, &session->chan, list) {
 480                 ret = _ltt_channel_metadata_statedump(session, chan);
 481                 if (ret)
 482                         goto end;
 483         }
 484
 485         list_for_each_entry(event, &session->events, list) {
 486                 ret = _ltt_event_metadata_statedump(session, chan, event);
 487                 if (ret)
 488                         goto end;
 489         }
 490         session->metadata_dumped = 1;
 491 end:
 492         return ret;
 493 }
 494
 495 /**
 496  * ltt_transport_register - LTT transport registration
 497  * @transport: transport structure
 498  *
 499  * Registers a transport which can be used as output to extract the data out of
 500  * LTTng. The module calling this registration function must ensure that no
 501  * trap-inducing code will be executed by the transport functions. E.g.
 502  * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
 503  * is made visible to the transport function. This registration acts as a
 504  * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
 505  * after its registration must it synchronize the TLBs.
 506  */
 507 void ltt_transport_register(struct ltt_transport *transport)
 508 {
 509         /*
 510          * Make sure no page fault can be triggered by the module about to be
 511          * registered. We deal with this here so we don't have to call
 512          * vmalloc_sync_all() in each module's init.
 513          */
 514         wrapper_vmalloc_sync_all();
 515
 516         mutex_lock(&sessions_mutex);
 517         list_add_tail(&transport->node, &ltt_transport_list);
 518         mutex_unlock(&sessions_mutex);
 519 }
 520 EXPORT_SYMBOL_GPL(ltt_transport_register);
 521
 522 /**
 523  * ltt_transport_unregister - LTT transport unregistration
 524  * @transport: transport structure
 525  */
 526 void ltt_transport_unregister(struct ltt_transport *transport)
 527 {
 528         mutex_lock(&sessions_mutex);
 529         list_del(&transport->node);
 530         mutex_unlock(&sessions_mutex);
 531 }
 532 EXPORT_SYMBOL_GPL(ltt_transport_unregister);
 533
 534 static int __init ltt_events_init(void)
 535 {
 536         int ret;
 537
 538         event_cache = KMEM_CACHE(ltt_event, 0);
 539         if (!event_cache)
 540                 return -ENOMEM;
 541         ret = ltt_debugfs_abi_init();
 542         if (ret)
 543                 goto error_abi;
 544         return 0;
 545 error_abi:
 546         kmem_cache_destroy(event_cache);
 547         return ret;
 548 }
 549
 550 module_init(ltt_events_init);
 551
 552 static void __exit ltt_events_exit(void)
 553 {
 554         struct ltt_session *session, *tmpsession;
 555
 556         ltt_debugfs_abi_exit();
 557         list_for_each_entry_safe(session, tmpsession, &sessions, list)
 558                 ltt_session_destroy(session);
 559         kmem_cache_destroy(event_cache);
 560 }
 561
 562 module_exit(ltt_events_exit);
 563
 564 MODULE_LICENSE("GPL and additional rights");
 565 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 566 MODULE_DESCRIPTION("LTTng Events");