projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wrapper: remove kallsyms wrapper
[lttng-modules.git] / lttng-events.c
1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
2 *
3 * lttng-events.c
4 *
5 * Holds LTTng per-session event registry.
6 *
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 */
9
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/sched.h>
13 #include <linux/slab.h>
14 #include <linux/jiffies.h>
15 #include <linux/utsname.h>
16 #include <linux/err.h>
17 #include <linux/seq_file.h>
18 #include <linux/file.h>
19 #include <linux/anon_inodes.h>
20 #include <linux/jhash.h>
21 #include <linux/uaccess.h>
22 #include <linux/uuid.h>
23 #include <linux/dmi.h>
24 #include <linux/vmalloc.h>
25 #include <linux/limits.h>
26
27 #include <wrapper/random.h>
28 #include <wrapper/list.h>
29 #include <lttng-kernel-version.h>
30 #include <lttng-events.h>
31 #include <lttng-tracer.h>
32 #include <lttng-abi-old.h>
33 #include <lttng-endian.h>
34 #include <lttng-string-utils.h>
35 #include <lttng-tracepoint.h>
36 #include <wrapper/ringbuffer/backend.h>
37 #include <wrapper/ringbuffer/frontend.h>
38
39 #define METADATA_CACHE_DEFAULT_SIZE 4096
40
41 static LIST_HEAD(sessions);
42 static LIST_HEAD(lttng_transport_list);
43 /*
44 * Protect the sessions and metadata caches.
45 */
46 static DEFINE_MUTEX(sessions_mutex);
47 static struct kmem_cache *event_cache;
48
49 static void lttng_session_lazy_sync_enablers(struct lttng_session *session);
50 static void lttng_session_sync_enablers(struct lttng_session *session);
51 static void lttng_enabler_destroy(struct lttng_enabler *enabler);
52
53 static void _lttng_event_destroy(struct lttng_event *event);
54 static void _lttng_channel_destroy(struct lttng_channel *chan);
55 static int _lttng_event_unregister(struct lttng_event *event);
56 static
57 int _lttng_event_metadata_statedump(struct lttng_session *session,
58 struct lttng_channel *chan,
59 struct lttng_event *event);
60 static
61 int _lttng_session_metadata_statedump(struct lttng_session *session);
62 static
63 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream);
64 static
65 int _lttng_type_statedump(struct lttng_session *session,
66 const struct lttng_type *type,
67 size_t nesting);
68 static
69 int _lttng_field_statedump(struct lttng_session *session,
70 const struct lttng_event_field *field,
71 size_t nesting);
72
73 void synchronize_trace(void)
74 {
75 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
76 synchronize_rcu();
77 #else
78 synchronize_sched();
79 #endif
80
81 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
82 #ifdef CONFIG_PREEMPT_RT_FULL
83 synchronize_rcu();
84 #endif
85 #else /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
86 #ifdef CONFIG_PREEMPT_RT
87 synchronize_rcu();
88 #endif
89 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
90 }
91
92 void lttng_lock_sessions(void)
93 {
94 mutex_lock(&sessions_mutex);
95 }
96
97 void lttng_unlock_sessions(void)
98 {
99 mutex_unlock(&sessions_mutex);
100 }
101
102 /*
103 * Called with sessions lock held.
104 */
105 int lttng_session_active(void)
106 {
107 struct lttng_session *iter;
108
109 list_for_each_entry(iter, &sessions, list) {
110 if (iter->active)
111 return 1;
112 }
113 return 0;
114 }
115
116 struct lttng_session *lttng_session_create(void)
117 {
118 struct lttng_session *session;
119 struct lttng_metadata_cache *metadata_cache;
120 int i;
121
122 mutex_lock(&sessions_mutex);
123 session = kvzalloc_node(sizeof(struct lttng_session), GFP_KERNEL,
124 NUMA_NO_NODE);
125 if (!session)
126 goto err;
127 INIT_LIST_HEAD(&session->chan);
128 INIT_LIST_HEAD(&session->events);
129 guid_gen(&session->uuid);
130
131 metadata_cache = kzalloc(sizeof(struct lttng_metadata_cache),
132 GFP_KERNEL);
133 if (!metadata_cache)
134 goto err_free_session;
135 metadata_cache->data = vzalloc(METADATA_CACHE_DEFAULT_SIZE);
136 if (!metadata_cache->data)
137 goto err_free_cache;
138 metadata_cache->cache_alloc = METADATA_CACHE_DEFAULT_SIZE;
139 kref_init(&metadata_cache->refcount);
140 mutex_init(&metadata_cache->lock);
141 session->metadata_cache = metadata_cache;
142 INIT_LIST_HEAD(&metadata_cache->metadata_stream);
143 memcpy(&metadata_cache->uuid, &session->uuid,
144 sizeof(metadata_cache->uuid));
145 INIT_LIST_HEAD(&session->enablers_head);
146 for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
147 INIT_HLIST_HEAD(&session->events_ht.table[i]);
148 list_add(&session->list, &sessions);
149 session->pid_tracker.session = session;
150 session->pid_tracker.tracker_type = TRACKER_PID;
151 session->vpid_tracker.session = session;
152 session->vpid_tracker.tracker_type = TRACKER_VPID;
153 session->uid_tracker.session = session;
154 session->uid_tracker.tracker_type = TRACKER_UID;
155 session->vuid_tracker.session = session;
156 session->vuid_tracker.tracker_type = TRACKER_VUID;
157 session->gid_tracker.session = session;
158 session->gid_tracker.tracker_type = TRACKER_GID;
159 session->vgid_tracker.session = session;
160 session->vgid_tracker.tracker_type = TRACKER_VGID;
161 mutex_unlock(&sessions_mutex);
162 return session;
163
164 err_free_cache:
165 kfree(metadata_cache);
166 err_free_session:
167 kvfree(session);
168 err:
169 mutex_unlock(&sessions_mutex);
170 return NULL;
171 }
172
173 void metadata_cache_destroy(struct kref *kref)
174 {
175 struct lttng_metadata_cache *cache =
176 container_of(kref, struct lttng_metadata_cache, refcount);
177 vfree(cache->data);
178 kfree(cache);
179 }
180
181 void lttng_session_destroy(struct lttng_session *session)
182 {
183 struct lttng_channel *chan, *tmpchan;
184 struct lttng_event *event, *tmpevent;
185 struct lttng_metadata_stream *metadata_stream;
186 struct lttng_enabler *enabler, *tmpenabler;
187 int ret;
188
189 mutex_lock(&sessions_mutex);
190 WRITE_ONCE(session->active, 0);
191 list_for_each_entry(chan, &session->chan, list) {
192 ret = lttng_syscalls_unregister(chan);
193 WARN_ON(ret);
194 }
195 list_for_each_entry(event, &session->events, list) {
196 ret = _lttng_event_unregister(event);
197 WARN_ON(ret);
198 }
199 synchronize_trace(); /* Wait for in-flight events to complete */
200 list_for_each_entry_safe(enabler, tmpenabler,
201 &session->enablers_head, node)
202 lttng_enabler_destroy(enabler);
203 list_for_each_entry_safe(event, tmpevent, &session->events, list)
204 _lttng_event_destroy(event);
205 list_for_each_entry_safe(chan, tmpchan, &session->chan, list) {
206 BUG_ON(chan->channel_type == METADATA_CHANNEL);
207 _lttng_channel_destroy(chan);
208 }
209 list_for_each_entry(metadata_stream, &session->metadata_cache->metadata_stream, list)
210 _lttng_metadata_channel_hangup(metadata_stream);
211 lttng_id_tracker_destroy(&session->pid_tracker, false);
212 lttng_id_tracker_destroy(&session->vpid_tracker, false);
213 lttng_id_tracker_destroy(&session->uid_tracker, false);
214 lttng_id_tracker_destroy(&session->vuid_tracker, false);
215 lttng_id_tracker_destroy(&session->gid_tracker, false);
216 lttng_id_tracker_destroy(&session->vgid_tracker, false);
217 kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
218 list_del(&session->list);
219 mutex_unlock(&sessions_mutex);
220 kvfree(session);
221 }
222
223 int lttng_session_statedump(struct lttng_session *session)
224 {
225 int ret;
226
227 mutex_lock(&sessions_mutex);
228 ret = lttng_statedump_start(session);
229 mutex_unlock(&sessions_mutex);
230 return ret;
231 }
232
233 int lttng_session_enable(struct lttng_session *session)
234 {
235 int ret = 0;
236 struct lttng_channel *chan;
237
238 mutex_lock(&sessions_mutex);
239 if (session->active) {
240 ret = -EBUSY;
241 goto end;
242 }
243
244 /* Set transient enabler state to "enabled" */
245 session->tstate = 1;
246
247 /* We need to sync enablers with session before activation. */
248 lttng_session_sync_enablers(session);
249
250 /*
251 * Snapshot the number of events per channel to know the type of header
252 * we need to use.
253 */
254 list_for_each_entry(chan, &session->chan, list) {
255 if (chan->header_type)
256 continue; /* don't change it if session stop/restart */
257 if (chan->free_event_id < 31)
258 chan->header_type = 1; /* compact */
259 else
260 chan->header_type = 2; /* large */
261 }
262
263 /* Clear each stream's quiescent state. */
264 list_for_each_entry(chan, &session->chan, list) {
265 if (chan->channel_type != METADATA_CHANNEL)
266 lib_ring_buffer_clear_quiescent_channel(chan->chan);
267 }
268
269 WRITE_ONCE(session->active, 1);
270 WRITE_ONCE(session->been_active, 1);
271 ret = _lttng_session_metadata_statedump(session);
272 if (ret) {
273 WRITE_ONCE(session->active, 0);
274 goto end;
275 }
276 ret = lttng_statedump_start(session);
277 if (ret)
278 WRITE_ONCE(session->active, 0);
279 end:
280 mutex_unlock(&sessions_mutex);
281 return ret;
282 }
283
284 int lttng_session_disable(struct lttng_session *session)
285 {
286 int ret = 0;
287 struct lttng_channel *chan;
288
289 mutex_lock(&sessions_mutex);
290 if (!session->active) {
291 ret = -EBUSY;
292 goto end;
293 }
294 WRITE_ONCE(session->active, 0);
295
296 /* Set transient enabler state to "disabled" */
297 session->tstate = 0;
298 lttng_session_sync_enablers(session);
299
300 /* Set each stream's quiescent state. */
301 list_for_each_entry(chan, &session->chan, list) {
302 if (chan->channel_type != METADATA_CHANNEL)
303 lib_ring_buffer_set_quiescent_channel(chan->chan);
304 }
305 end:
306 mutex_unlock(&sessions_mutex);
307 return ret;
308 }
309
310 int lttng_session_metadata_regenerate(struct lttng_session *session)
311 {
312 int ret = 0;
313 struct lttng_channel *chan;
314 struct lttng_event *event;
315 struct lttng_metadata_cache *cache = session->metadata_cache;
316 struct lttng_metadata_stream *stream;
317
318 mutex_lock(&sessions_mutex);
319 if (!session->active) {
320 ret = -EBUSY;
321 goto end;
322 }
323
324 mutex_lock(&cache->lock);
325 memset(cache->data, 0, cache->cache_alloc);
326 cache->metadata_written = 0;
327 cache->version++;
328 list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list) {
329 stream->metadata_out = 0;
330 stream->metadata_in = 0;
331 }
332 mutex_unlock(&cache->lock);
333
334 session->metadata_dumped = 0;
335 list_for_each_entry(chan, &session->chan, list) {
336 chan->metadata_dumped = 0;
337 }
338
339 list_for_each_entry(event, &session->events, list) {
340 event->metadata_dumped = 0;
341 }
342
343 ret = _lttng_session_metadata_statedump(session);
344
345 end:
346 mutex_unlock(&sessions_mutex);
347 return ret;
348 }
349
350 int lttng_channel_enable(struct lttng_channel *channel)
351 {
352 int ret = 0;
353
354 mutex_lock(&sessions_mutex);
355 if (channel->channel_type == METADATA_CHANNEL) {
356 ret = -EPERM;
357 goto end;
358 }
359 if (channel->enabled) {
360 ret = -EEXIST;
361 goto end;
362 }
363 /* Set transient enabler state to "enabled" */
364 channel->tstate = 1;
365 lttng_session_sync_enablers(channel->session);
366 /* Set atomically the state to "enabled" */
367 WRITE_ONCE(channel->enabled, 1);
368 end:
369 mutex_unlock(&sessions_mutex);
370 return ret;
371 }
372
373 int lttng_channel_disable(struct lttng_channel *channel)
374 {
375 int ret = 0;
376
377 mutex_lock(&sessions_mutex);
378 if (channel->channel_type == METADATA_CHANNEL) {
379 ret = -EPERM;
380 goto end;
381 }
382 if (!channel->enabled) {
383 ret = -EEXIST;
384 goto end;
385 }
386 /* Set atomically the state to "disabled" */
387 WRITE_ONCE(channel->enabled, 0);
388 /* Set transient enabler state to "enabled" */
389 channel->tstate = 0;
390 lttng_session_sync_enablers(channel->session);
391 end:
392 mutex_unlock(&sessions_mutex);
393 return ret;
394 }
395
396 int lttng_event_enable(struct lttng_event *event)
397 {
398 int ret = 0;
399
400 mutex_lock(&sessions_mutex);
401 if (event->chan->channel_type == METADATA_CHANNEL) {
402 ret = -EPERM;
403 goto end;
404 }
405 if (event->enabled) {
406 ret = -EEXIST;
407 goto end;
408 }
409 switch (event->instrumentation) {
410 case LTTNG_KERNEL_TRACEPOINT:
411 case LTTNG_KERNEL_SYSCALL:
412 ret = -EINVAL;
413 break;
414 case LTTNG_KERNEL_KPROBE:
415 case LTTNG_KERNEL_UPROBE:
416 case LTTNG_KERNEL_NOOP:
417 WRITE_ONCE(event->enabled, 1);
418 break;
419 case LTTNG_KERNEL_KRETPROBE:
420 ret = lttng_kretprobes_event_enable_state(event, 1);
421 break;
422 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
423 default:
424 WARN_ON_ONCE(1);
425 ret = -EINVAL;
426 }
427 end:
428 mutex_unlock(&sessions_mutex);
429 return ret;
430 }
431
432 int lttng_event_disable(struct lttng_event *event)
433 {
434 int ret = 0;
435
436 mutex_lock(&sessions_mutex);
437 if (event->chan->channel_type == METADATA_CHANNEL) {
438 ret = -EPERM;
439 goto end;
440 }
441 if (!event->enabled) {
442 ret = -EEXIST;
443 goto end;
444 }
445 switch (event->instrumentation) {
446 case LTTNG_KERNEL_TRACEPOINT:
447 case LTTNG_KERNEL_SYSCALL:
448 ret = -EINVAL;
449 break;
450 case LTTNG_KERNEL_KPROBE:
451 case LTTNG_KERNEL_UPROBE:
452 case LTTNG_KERNEL_NOOP:
453 WRITE_ONCE(event->enabled, 0);
454 break;
455 case LTTNG_KERNEL_KRETPROBE:
456 ret = lttng_kretprobes_event_enable_state(event, 0);
457 break;
458 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
459 default:
460 WARN_ON_ONCE(1);
461 ret = -EINVAL;
462 }
463 end:
464 mutex_unlock(&sessions_mutex);
465 return ret;
466 }
467
468 static struct lttng_transport *lttng_transport_find(const char *name)
469 {
470 struct lttng_transport *transport;
471
472 list_for_each_entry(transport, &lttng_transport_list, node) {
473 if (!strcmp(transport->name, name))
474 return transport;
475 }
476 return NULL;
477 }
478
479 struct lttng_channel *lttng_channel_create(struct lttng_session *session,
480 const char *transport_name,
481 void *buf_addr,
482 size_t subbuf_size, size_t num_subbuf,
483 unsigned int switch_timer_interval,
484 unsigned int read_timer_interval,
485 enum channel_type channel_type)
486 {
487 struct lttng_channel *chan;
488 struct lttng_transport *transport = NULL;
489
490 mutex_lock(&sessions_mutex);
491 if (session->been_active && channel_type != METADATA_CHANNEL)
492 goto active; /* Refuse to add channel to active session */
493 transport = lttng_transport_find(transport_name);
494 if (!transport) {
495 printk(KERN_WARNING "LTTng transport %s not found\n",
496 transport_name);
497 goto notransport;
498 }
499 if (!try_module_get(transport->owner)) {
500 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
501 goto notransport;
502 }
503 chan = kzalloc(sizeof(struct lttng_channel), GFP_KERNEL);
504 if (!chan)
505 goto nomem;
506 chan->session = session;
507 chan->id = session->free_chan_id++;
508 chan->ops = &transport->ops;
509 /*
510 * Note: the channel creation op already writes into the packet
511 * headers. Therefore the "chan" information used as input
512 * should be already accessible.
513 */
514 chan->chan = transport->ops.channel_create(transport_name,
515 chan, buf_addr, subbuf_size, num_subbuf,
516 switch_timer_interval, read_timer_interval);
517 if (!chan->chan)
518 goto create_error;
519 chan->tstate = 1;
520 chan->enabled = 1;
521 chan->transport = transport;
522 chan->channel_type = channel_type;
523 list_add(&chan->list, &session->chan);
524 mutex_unlock(&sessions_mutex);
525 return chan;
526
527 create_error:
528 kfree(chan);
529 nomem:
530 if (transport)
531 module_put(transport->owner);
532 notransport:
533 active:
534 mutex_unlock(&sessions_mutex);
535 return NULL;
536 }
537
538 /*
539 * Only used internally at session destruction for per-cpu channels, and
540 * when metadata channel is released.
541 * Needs to be called with sessions mutex held.
542 */
543 static
544 void _lttng_channel_destroy(struct lttng_channel *chan)
545 {
546 chan->ops->channel_destroy(chan->chan);
547 module_put(chan->transport->owner);
548 list_del(&chan->list);
549 lttng_destroy_context(chan->ctx);
550 kfree(chan);
551 }
552
553 void lttng_metadata_channel_destroy(struct lttng_channel *chan)
554 {
555 BUG_ON(chan->channel_type != METADATA_CHANNEL);
556
557 /* Protect the metadata cache with the sessions_mutex. */
558 mutex_lock(&sessions_mutex);
559 _lttng_channel_destroy(chan);
560 mutex_unlock(&sessions_mutex);
561 }
562 EXPORT_SYMBOL_GPL(lttng_metadata_channel_destroy);
563
564 static
565 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
566 {
567 stream->finalized = 1;
568 wake_up_interruptible(&stream->read_wait);
569 }
570
571 /*
572 * Supports event creation while tracing session is active.
573 * Needs to be called with sessions mutex held.
574 */
575 struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
576 struct lttng_kernel_event *event_param,
577 void *filter,
578 const struct lttng_event_desc *event_desc,
579 enum lttng_kernel_instrumentation itype)
580 {
581 struct lttng_session *session = chan->session;
582 struct lttng_event *event;
583 const char *event_name;
584 struct hlist_head *head;
585 size_t name_len;
586 uint32_t hash;
587 int ret;
588
589 if (chan->free_event_id == -1U) {
590 ret = -EMFILE;
591 goto full;
592 }
593
594 switch (itype) {
595 case LTTNG_KERNEL_TRACEPOINT:
596 event_name = event_desc->name;
597 break;
598 case LTTNG_KERNEL_KPROBE:
599 case LTTNG_KERNEL_UPROBE:
600 case LTTNG_KERNEL_KRETPROBE:
601 case LTTNG_KERNEL_NOOP:
602 case LTTNG_KERNEL_SYSCALL:
603 event_name = event_param->name;
604 break;
605 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
606 default:
607 WARN_ON_ONCE(1);
608 ret = -EINVAL;
609 goto type_error;
610 }
611 name_len = strlen(event_name);
612 hash = jhash(event_name, name_len, 0);
613 head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
614 lttng_hlist_for_each_entry(event, head, hlist) {
615 WARN_ON_ONCE(!event->desc);
616 if (!strncmp(event->desc->name, event_name,
617 LTTNG_KERNEL_SYM_NAME_LEN - 1)
618 && chan == event->chan) {
619 ret = -EEXIST;
620 goto exist;
621 }
622 }
623
624 event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
625 if (!event) {
626 ret = -ENOMEM;
627 goto cache_error;
628 }
629 event->chan = chan;
630 event->filter = filter;
631 event->id = chan->free_event_id++;
632 event->instrumentation = itype;
633 event->evtype = LTTNG_TYPE_EVENT;
634 INIT_LIST_HEAD(&event->bytecode_runtime_head);
635 INIT_LIST_HEAD(&event->enablers_ref_head);
636
637 switch (itype) {
638 case LTTNG_KERNEL_TRACEPOINT:
639 /* Event will be enabled by enabler sync. */
640 event->enabled = 0;
641 event->registered = 0;
642 event->desc = lttng_event_get(event_name);
643 if (!event->desc) {
644 ret = -ENOENT;
645 goto register_error;
646 }
647 /* Populate lttng_event structure before event registration. */
648 smp_wmb();
649 break;
650 case LTTNG_KERNEL_KPROBE:
651 /*
652 * Needs to be explicitly enabled after creation, since
653 * we may want to apply filters.
654 */
655 event->enabled = 0;
656 event->registered = 1;
657 /*
658 * Populate lttng_event structure before event
659 * registration.
660 */
661 smp_wmb();
662 ret = lttng_kprobes_register(event_name,
663 event_param->u.kprobe.symbol_name,
664 event_param->u.kprobe.offset,
665 event_param->u.kprobe.addr,
666 event);
667 if (ret) {
668 ret = -EINVAL;
669 goto register_error;
670 }
671 ret = try_module_get(event->desc->owner);
672 WARN_ON_ONCE(!ret);
673 break;
674 case LTTNG_KERNEL_KRETPROBE:
675 {
676 struct lttng_event *event_return;
677
678 /* kretprobe defines 2 events */
679 /*
680 * Needs to be explicitly enabled after creation, since
681 * we may want to apply filters.
682 */
683 event->enabled = 0;
684 event->registered = 1;
685 event_return =
686 kmem_cache_zalloc(event_cache, GFP_KERNEL);
687 if (!event_return) {
688 ret = -ENOMEM;
689 goto register_error;
690 }
691 event_return->chan = chan;
692 event_return->filter = filter;
693 event_return->id = chan->free_event_id++;
694 event_return->enabled = 0;
695 event_return->registered = 1;
696 event_return->instrumentation = itype;
697 /*
698 * Populate lttng_event structure before kretprobe registration.
699 */
700 smp_wmb();
701 ret = lttng_kretprobes_register(event_name,
702 event_param->u.kretprobe.symbol_name,
703 event_param->u.kretprobe.offset,
704 event_param->u.kretprobe.addr,
705 event, event_return);
706 if (ret) {
707 kmem_cache_free(event_cache, event_return);
708 ret = -EINVAL;
709 goto register_error;
710 }
711 /* Take 2 refs on the module: one per event. */
712 ret = try_module_get(event->desc->owner);
713 WARN_ON_ONCE(!ret);
714 ret = try_module_get(event->desc->owner);
715 WARN_ON_ONCE(!ret);
716 ret = _lttng_event_metadata_statedump(chan->session, chan,
717 event_return);
718 WARN_ON_ONCE(ret > 0);
719 if (ret) {
720 kmem_cache_free(event_cache, event_return);
721 module_put(event->desc->owner);
722 module_put(event->desc->owner);
723 goto statedump_error;
724 }
725 list_add(&event_return->list, &chan->session->events);
726 break;
727 }
728 case LTTNG_KERNEL_NOOP:
729 case LTTNG_KERNEL_SYSCALL:
730 /*
731 * Needs to be explicitly enabled after creation, since
732 * we may want to apply filters.
733 */
734 event->enabled = 0;
735 event->registered = 0;
736 event->desc = event_desc;
737 if (!event->desc) {
738 ret = -EINVAL;
739 goto register_error;
740 }
741 break;
742 case LTTNG_KERNEL_UPROBE:
743 /*
744 * Needs to be explicitly enabled after creation, since
745 * we may want to apply filters.
746 */
747 event->enabled = 0;
748 event->registered = 1;
749
750 /*
751 * Populate lttng_event structure before event
752 * registration.
753 */
754 smp_wmb();
755
756 ret = lttng_uprobes_register(event_param->name,
757 event_param->u.uprobe.fd,
758 event);
759 if (ret)
760 goto register_error;
761 ret = try_module_get(event->desc->owner);
762 WARN_ON_ONCE(!ret);
763 break;
764 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
765 default:
766 WARN_ON_ONCE(1);
767 ret = -EINVAL;
768 goto register_error;
769 }
770 ret = _lttng_event_metadata_statedump(chan->session, chan, event);
771 WARN_ON_ONCE(ret > 0);
772 if (ret) {
773 goto statedump_error;
774 }
775 hlist_add_head(&event->hlist, head);
776 list_add(&event->list, &chan->session->events);
777 return event;
778
779 statedump_error:
780 /* If a statedump error occurs, events will not be readable. */
781 register_error:
782 kmem_cache_free(event_cache, event);
783 cache_error:
784 exist:
785 type_error:
786 full:
787 return ERR_PTR(ret);
788 }
789
790 struct lttng_event *lttng_event_create(struct lttng_channel *chan,
791 struct lttng_kernel_event *event_param,
792 void *filter,
793 const struct lttng_event_desc *event_desc,
794 enum lttng_kernel_instrumentation itype)
795 {
796 struct lttng_event *event;
797
798 mutex_lock(&sessions_mutex);
799 event = _lttng_event_create(chan, event_param, filter, event_desc,
800 itype);
801 mutex_unlock(&sessions_mutex);
802 return event;
803 }
804
805 /* Only used for tracepoints for now. */
806 static
807 void register_event(struct lttng_event *event)
808 {
809 const struct lttng_event_desc *desc;
810 int ret = -EINVAL;
811
812 if (event->registered)
813 return;
814
815 desc = event->desc;
816 switch (event->instrumentation) {
817 case LTTNG_KERNEL_TRACEPOINT:
818 ret = lttng_tracepoint_probe_register(desc->kname,
819 desc->probe_callback,
820 event);
821 break;
822 case LTTNG_KERNEL_SYSCALL:
823 ret = lttng_syscall_filter_enable(event->chan,
824 desc->name);
825 break;
826 case LTTNG_KERNEL_KPROBE:
827 case LTTNG_KERNEL_UPROBE:
828 case LTTNG_KERNEL_KRETPROBE:
829 case LTTNG_KERNEL_NOOP:
830 ret = 0;
831 break;
832 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
833 default:
834 WARN_ON_ONCE(1);
835 }
836 if (!ret)
837 event->registered = 1;
838 }
839
840 /*
841 * Only used internally at session destruction.
842 */
843 int _lttng_event_unregister(struct lttng_event *event)
844 {
845 const struct lttng_event_desc *desc;
846 int ret = -EINVAL;
847
848 if (!event->registered)
849 return 0;
850
851 desc = event->desc;
852 switch (event->instrumentation) {
853 case LTTNG_KERNEL_TRACEPOINT:
854 ret = lttng_tracepoint_probe_unregister(event->desc->kname,
855 event->desc->probe_callback,
856 event);
857 break;
858 case LTTNG_KERNEL_KPROBE:
859 lttng_kprobes_unregister(event);
860 ret = 0;
861 break;
862 case LTTNG_KERNEL_KRETPROBE:
863 lttng_kretprobes_unregister(event);
864 ret = 0;
865 break;
866 case LTTNG_KERNEL_SYSCALL:
867 ret = lttng_syscall_filter_disable(event->chan,
868 desc->name);
869 break;
870 case LTTNG_KERNEL_NOOP:
871 ret = 0;
872 break;
873 case LTTNG_KERNEL_UPROBE:
874 lttng_uprobes_unregister(event);
875 ret = 0;
876 break;
877 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
878 default:
879 WARN_ON_ONCE(1);
880 }
881 if (!ret)
882 event->registered = 0;
883 return ret;
884 }
885
886 /*
887 * Only used internally at session destruction.
888 */
889 static
890 void _lttng_event_destroy(struct lttng_event *event)
891 {
892 switch (event->instrumentation) {
893 case LTTNG_KERNEL_TRACEPOINT:
894 lttng_event_put(event->desc);
895 break;
896 case LTTNG_KERNEL_KPROBE:
897 module_put(event->desc->owner);
898 lttng_kprobes_destroy_private(event);
899 break;
900 case LTTNG_KERNEL_KRETPROBE:
901 module_put(event->desc->owner);
902 lttng_kretprobes_destroy_private(event);
903 break;
904 case LTTNG_KERNEL_NOOP:
905 case LTTNG_KERNEL_SYSCALL:
906 break;
907 case LTTNG_KERNEL_UPROBE:
908 module_put(event->desc->owner);
909 lttng_uprobes_destroy_private(event);
910 break;
911 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
912 default:
913 WARN_ON_ONCE(1);
914 }
915 list_del(&event->list);
916 lttng_destroy_context(event->ctx);
917 kmem_cache_free(event_cache, event);
918 }
919
920 struct lttng_id_tracker *get_tracker(struct lttng_session *session,
921 enum tracker_type tracker_type)
922 {
923 switch (tracker_type) {
924 case TRACKER_PID:
925 return &session->pid_tracker;
926 case TRACKER_VPID:
927 return &session->vpid_tracker;
928 case TRACKER_UID:
929 return &session->uid_tracker;
930 case TRACKER_VUID:
931 return &session->vuid_tracker;
932 case TRACKER_GID:
933 return &session->gid_tracker;
934 case TRACKER_VGID:
935 return &session->vgid_tracker;
936 default:
937 WARN_ON_ONCE(1);
938 return NULL;
939 }
940 }
941
942 int lttng_session_track_id(struct lttng_session *session,
943 enum tracker_type tracker_type, int id)
944 {
945 struct lttng_id_tracker *tracker;
946 int ret;
947
948 tracker = get_tracker(session, tracker_type);
949 if (!tracker)
950 return -EINVAL;
951 if (id < -1)
952 return -EINVAL;
953 mutex_lock(&sessions_mutex);
954 if (id == -1) {
955 /* track all ids: destroy tracker. */
956 lttng_id_tracker_destroy(tracker, true);
957 ret = 0;
958 } else {
959 ret = lttng_id_tracker_add(tracker, id);
960 }
961 mutex_unlock(&sessions_mutex);
962 return ret;
963 }
964
965 int lttng_session_untrack_id(struct lttng_session *session,
966 enum tracker_type tracker_type, int id)
967 {
968 struct lttng_id_tracker *tracker;
969 int ret;
970
971 tracker = get_tracker(session, tracker_type);
972 if (!tracker)
973 return -EINVAL;
974 if (id < -1)
975 return -EINVAL;
976 mutex_lock(&sessions_mutex);
977 if (id == -1) {
978 /* untrack all ids: replace by empty tracker. */
979 ret = lttng_id_tracker_empty_set(tracker);
980 } else {
981 ret = lttng_id_tracker_del(tracker, id);
982 }
983 mutex_unlock(&sessions_mutex);
984 return ret;
985 }
986
987 static
988 void *id_list_start(struct seq_file *m, loff_t *pos)
989 {
990 struct lttng_id_tracker *id_tracker = m->private;
991 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
992 struct lttng_id_hash_node *e;
993 int iter = 0, i;
994
995 mutex_lock(&sessions_mutex);
996 if (id_tracker_p) {
997 for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
998 struct hlist_head *head = &id_tracker_p->id_hash[i];
999
1000 lttng_hlist_for_each_entry(e, head, hlist) {
1001 if (iter++ >= *pos)
1002 return e;
1003 }
1004 }
1005 } else {
1006 /* ID tracker disabled. */
1007 if (iter >= *pos && iter == 0) {
1008 return id_tracker_p; /* empty tracker */
1009 }
1010 iter++;
1011 }
1012 /* End of list */
1013 return NULL;
1014 }
1015
1016 /* Called with sessions_mutex held. */
1017 static
1018 void *id_list_next(struct seq_file *m, void *p, loff_t *ppos)
1019 {
1020 struct lttng_id_tracker *id_tracker = m->private;
1021 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
1022 struct lttng_id_hash_node *e;
1023 int iter = 0, i;
1024
1025 (*ppos)++;
1026 if (id_tracker_p) {
1027 for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
1028 struct hlist_head *head = &id_tracker_p->id_hash[i];
1029
1030 lttng_hlist_for_each_entry(e, head, hlist) {
1031 if (iter++ >= *ppos)
1032 return e;
1033 }
1034 }
1035 } else {
1036 /* ID tracker disabled. */
1037 if (iter >= *ppos && iter == 0)
1038 return p; /* empty tracker */
1039 iter++;
1040 }
1041
1042 /* End of list */
1043 return NULL;
1044 }
1045
1046 static
1047 void id_list_stop(struct seq_file *m, void *p)
1048 {
1049 mutex_unlock(&sessions_mutex);
1050 }
1051
1052 static
1053 int id_list_show(struct seq_file *m, void *p)
1054 {
1055 struct lttng_id_tracker *id_tracker = m->private;
1056 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
1057 int id;
1058
1059 if (p == id_tracker_p) {
1060 /* Tracker disabled. */
1061 id = -1;
1062 } else {
1063 const struct lttng_id_hash_node *e = p;
1064
1065 id = lttng_id_tracker_get_node_id(e);
1066 }
1067 switch (id_tracker->tracker_type) {
1068 case TRACKER_PID:
1069 seq_printf(m, "process { pid = %d; };\n", id);
1070 break;
1071 case TRACKER_VPID:
1072 seq_printf(m, "process { vpid = %d; };\n", id);
1073 break;
1074 case TRACKER_UID:
1075 seq_printf(m, "user { uid = %d; };\n", id);
1076 break;
1077 case TRACKER_VUID:
1078 seq_printf(m, "user { vuid = %d; };\n", id);
1079 break;
1080 case TRACKER_GID:
1081 seq_printf(m, "group { gid = %d; };\n", id);
1082 break;
1083 case TRACKER_VGID:
1084 seq_printf(m, "group { vgid = %d; };\n", id);
1085 break;
1086 default:
1087 seq_printf(m, "UNKNOWN { field = %d };\n", id);
1088 }
1089 return 0;
1090 }
1091
1092 static
1093 const struct seq_operations lttng_tracker_ids_list_seq_ops = {
1094 .start = id_list_start,
1095 .next = id_list_next,
1096 .stop = id_list_stop,
1097 .show = id_list_show,
1098 };
1099
1100 static
1101 int lttng_tracker_ids_list_open(struct inode *inode, struct file *file)
1102 {
1103 return seq_open(file, &lttng_tracker_ids_list_seq_ops);
1104 }
1105
1106 static
1107 int lttng_tracker_ids_list_release(struct inode *inode, struct file *file)
1108 {
1109 struct seq_file *m = file->private_data;
1110 struct lttng_id_tracker *id_tracker = m->private;
1111 int ret;
1112
1113 WARN_ON_ONCE(!id_tracker);
1114 ret = seq_release(inode, file);
1115 if (!ret)
1116 fput(id_tracker->session->file);
1117 return ret;
1118 }
1119
1120 const struct file_operations lttng_tracker_ids_list_fops = {
1121 .owner = THIS_MODULE,
1122 .open = lttng_tracker_ids_list_open,
1123 .read = seq_read,
1124 .llseek = seq_lseek,
1125 .release = lttng_tracker_ids_list_release,
1126 };
1127
1128 int lttng_session_list_tracker_ids(struct lttng_session *session,
1129 enum tracker_type tracker_type)
1130 {
1131 struct file *tracker_ids_list_file;
1132 struct seq_file *m;
1133 int file_fd, ret;
1134
1135 file_fd = get_unused_fd_flags(0);
1136 if (file_fd < 0) {
1137 ret = file_fd;
1138 goto fd_error;
1139 }
1140
1141 tracker_ids_list_file = anon_inode_getfile("[lttng_tracker_ids_list]",
1142 &lttng_tracker_ids_list_fops,
1143 NULL, O_RDWR);
1144 if (IS_ERR(tracker_ids_list_file)) {
1145 ret = PTR_ERR(tracker_ids_list_file);
1146 goto file_error;
1147 }
1148 if (!atomic_long_add_unless(&session->file->f_count, 1, LONG_MAX)) {
1149 ret = -EOVERFLOW;
1150 goto refcount_error;
1151 }
1152 ret = lttng_tracker_ids_list_fops.open(NULL, tracker_ids_list_file);
1153 if (ret < 0)
1154 goto open_error;
1155 m = tracker_ids_list_file->private_data;
1156
1157 m->private = get_tracker(session, tracker_type);
1158 BUG_ON(!m->private);
1159 fd_install(file_fd, tracker_ids_list_file);
1160
1161 return file_fd;
1162
1163 open_error:
1164 atomic_long_dec(&session->file->f_count);
1165 refcount_error:
1166 fput(tracker_ids_list_file);
1167 file_error:
1168 put_unused_fd(file_fd);
1169 fd_error:
1170 return ret;
1171 }
1172
1173 /*
1174 * Enabler management.
1175 */
1176 static
1177 int lttng_match_enabler_star_glob(const char *desc_name,
1178 const char *pattern)
1179 {
1180 if (!strutils_star_glob_match(pattern, SIZE_MAX,
1181 desc_name, SIZE_MAX))
1182 return 0;
1183 return 1;
1184 }
1185
1186 static
1187 int lttng_match_enabler_name(const char *desc_name,
1188 const char *name)
1189 {
1190 if (strcmp(desc_name, name))
1191 return 0;
1192 return 1;
1193 }
1194
1195 static
1196 int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
1197 struct lttng_enabler *enabler)
1198 {
1199 const char *desc_name, *enabler_name;
1200
1201 enabler_name = enabler->event_param.name;
1202 switch (enabler->event_param.instrumentation) {
1203 case LTTNG_KERNEL_TRACEPOINT:
1204 desc_name = desc->name;
1205 break;
1206 case LTTNG_KERNEL_SYSCALL:
1207 desc_name = desc->name;
1208 if (!strncmp(desc_name, "compat_", strlen("compat_")))
1209 desc_name += strlen("compat_");
1210 if (!strncmp(desc_name, "syscall_exit_",
1211 strlen("syscall_exit_"))) {
1212 desc_name += strlen("syscall_exit_");
1213 } else if (!strncmp(desc_name, "syscall_entry_",
1214 strlen("syscall_entry_"))) {
1215 desc_name += strlen("syscall_entry_");
1216 } else {
1217 WARN_ON_ONCE(1);
1218 return -EINVAL;
1219 }
1220 break;
1221 default:
1222 WARN_ON_ONCE(1);
1223 return -EINVAL;
1224 }
1225 switch (enabler->type) {
1226 case LTTNG_ENABLER_STAR_GLOB:
1227 return lttng_match_enabler_star_glob(desc_name, enabler_name);
1228 case LTTNG_ENABLER_NAME:
1229 return lttng_match_enabler_name(desc_name, enabler_name);
1230 default:
1231 return -EINVAL;
1232 }
1233 }
1234
1235 static
1236 int lttng_event_match_enabler(struct lttng_event *event,
1237 struct lttng_enabler *enabler)
1238 {
1239 if (enabler->event_param.instrumentation != event->instrumentation)
1240 return 0;
1241 if (lttng_desc_match_enabler(event->desc, enabler)
1242 && event->chan == enabler->chan)
1243 return 1;
1244 else
1245 return 0;
1246 }
1247
1248 static
1249 struct lttng_enabler_ref *lttng_event_enabler_ref(struct lttng_event *event,
1250 struct lttng_enabler *enabler)
1251 {
1252 struct lttng_enabler_ref *enabler_ref;
1253
1254 list_for_each_entry(enabler_ref,
1255 &event->enablers_ref_head, node) {
1256 if (enabler_ref->ref == enabler)
1257 return enabler_ref;
1258 }
1259 return NULL;
1260 }
1261
1262 static
1263 void lttng_create_tracepoint_if_missing(struct lttng_enabler *enabler)
1264 {
1265 struct lttng_session *session = enabler->chan->session;
1266 struct lttng_probe_desc *probe_desc;
1267 const struct lttng_event_desc *desc;
1268 int i;
1269 struct list_head *probe_list;
1270
1271 probe_list = lttng_get_probe_list_head();
1272 /*
1273 * For each probe event, if we find that a probe event matches
1274 * our enabler, create an associated lttng_event if not
1275 * already present.
1276 */
1277 list_for_each_entry(probe_desc, probe_list, head) {
1278 for (i = 0; i < probe_desc->nr_events; i++) {
1279 int found = 0;
1280 struct hlist_head *head;
1281 const char *event_name;
1282 size_t name_len;
1283 uint32_t hash;
1284 struct lttng_event *event;
1285
1286 desc = probe_desc->event_desc[i];
1287 if (!lttng_desc_match_enabler(desc, enabler))
1288 continue;
1289 event_name = desc->name;
1290 name_len = strlen(event_name);
1291
1292 /*
1293 * Check if already created.
1294 */
1295 hash = jhash(event_name, name_len, 0);
1296 head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
1297 lttng_hlist_for_each_entry(event, head, hlist) {
1298 if (event->desc == desc
1299 && event->chan == enabler->chan)
1300 found = 1;
1301 }
1302 if (found)
1303 continue;
1304
1305 /*
1306 * We need to create an event for this
1307 * event probe.
1308 */
1309 event = _lttng_event_create(enabler->chan,
1310 NULL, NULL, desc,
1311 LTTNG_KERNEL_TRACEPOINT);
1312 if (!event) {
1313 printk(KERN_INFO "Unable to create event %s\n",
1314 probe_desc->event_desc[i]->name);
1315 }
1316 }
1317 }
1318 }
1319
1320 static
1321 void lttng_create_syscall_if_missing(struct lttng_enabler *enabler)
1322 {
1323 int ret;
1324
1325 ret = lttng_syscalls_register(enabler->chan, NULL);
1326 WARN_ON_ONCE(ret);
1327 }
1328
1329 /*
1330 * Create struct lttng_event if it is missing and present in the list of
1331 * tracepoint probes.
1332 * Should be called with sessions mutex held.
1333 */
1334 static
1335 void lttng_create_event_if_missing(struct lttng_enabler *enabler)
1336 {
1337 switch (enabler->event_param.instrumentation) {
1338 case LTTNG_KERNEL_TRACEPOINT:
1339 lttng_create_tracepoint_if_missing(enabler);
1340 break;
1341 case LTTNG_KERNEL_SYSCALL:
1342 lttng_create_syscall_if_missing(enabler);
1343 break;
1344 default:
1345 WARN_ON_ONCE(1);
1346 break;
1347 }
1348 }
1349
1350 /*
1351 * Create events associated with an enabler (if not already present),
1352 * and add backward reference from the event to the enabler.
1353 * Should be called with sessions mutex held.
1354 */
1355 static
1356 int lttng_enabler_ref_events(struct lttng_enabler *enabler)
1357 {
1358 struct lttng_session *session = enabler->chan->session;
1359 struct lttng_event *event;
1360
1361 /* First ensure that probe events are created for this enabler. */
1362 lttng_create_event_if_missing(enabler);
1363
1364 /* For each event matching enabler in session event list. */
1365 list_for_each_entry(event, &session->events, list) {
1366 struct lttng_enabler_ref *enabler_ref;
1367
1368 if (!lttng_event_match_enabler(event, enabler))
1369 continue;
1370 enabler_ref = lttng_event_enabler_ref(event, enabler);
1371 if (!enabler_ref) {
1372 /*
1373 * If no backward ref, create it.
1374 * Add backward ref from event to enabler.
1375 */
1376 enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
1377 if (!enabler_ref)
1378 return -ENOMEM;
1379 enabler_ref->ref = enabler;
1380 list_add(&enabler_ref->node,
1381 &event->enablers_ref_head);
1382 }
1383
1384 /*
1385 * Link filter bytecodes if not linked yet.
1386 */
1387 lttng_enabler_event_link_bytecode(event, enabler);
1388
1389 /* TODO: merge event context. */
1390 }
1391 return 0;
1392 }
1393
1394 /*
1395 * Called at module load: connect the probe on all enablers matching
1396 * this event.
1397 * Called with sessions lock held.
1398 */
1399 int lttng_fix_pending_events(void)
1400 {
1401 struct lttng_session *session;
1402
1403 list_for_each_entry(session, &sessions, list)
1404 lttng_session_lazy_sync_enablers(session);
1405 return 0;
1406 }
1407
1408 struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type,
1409 struct lttng_kernel_event *event_param,
1410 struct lttng_channel *chan)
1411 {
1412 struct lttng_enabler *enabler;
1413
1414 enabler = kzalloc(sizeof(*enabler), GFP_KERNEL);
1415 if (!enabler)
1416 return NULL;
1417 enabler->type = type;
1418 INIT_LIST_HEAD(&enabler->filter_bytecode_head);
1419 memcpy(&enabler->event_param, event_param,
1420 sizeof(enabler->event_param));
1421 enabler->chan = chan;
1422 /* ctx left NULL */
1423 enabler->enabled = 0;
1424 enabler->evtype = LTTNG_TYPE_ENABLER;
1425 mutex_lock(&sessions_mutex);
1426 list_add(&enabler->node, &enabler->chan->session->enablers_head);
1427 lttng_session_lazy_sync_enablers(enabler->chan->session);
1428 mutex_unlock(&sessions_mutex);
1429 return enabler;
1430 }
1431
1432 int lttng_enabler_enable(struct lttng_enabler *enabler)
1433 {
1434 mutex_lock(&sessions_mutex);
1435 enabler->enabled = 1;
1436 lttng_session_lazy_sync_enablers(enabler->chan->session);
1437 mutex_unlock(&sessions_mutex);
1438 return 0;
1439 }
1440
1441 int lttng_enabler_disable(struct lttng_enabler *enabler)
1442 {
1443 mutex_lock(&sessions_mutex);
1444 enabler->enabled = 0;
1445 lttng_session_lazy_sync_enablers(enabler->chan->session);
1446 mutex_unlock(&sessions_mutex);
1447 return 0;
1448 }
1449
1450 int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
1451 struct lttng_kernel_filter_bytecode __user *bytecode)
1452 {
1453 struct lttng_filter_bytecode_node *bytecode_node;
1454 uint32_t bytecode_len;
1455 int ret;
1456
1457 ret = get_user(bytecode_len, &bytecode->len);
1458 if (ret)
1459 return ret;
1460 bytecode_node = kzalloc(sizeof(*bytecode_node) + bytecode_len,
1461 GFP_KERNEL);
1462 if (!bytecode_node)
1463 return -ENOMEM;
1464 ret = copy_from_user(&bytecode_node->bc, bytecode,
1465 sizeof(*bytecode) + bytecode_len);
1466 if (ret)
1467 goto error_free;
1468 bytecode_node->enabler = enabler;
1469 /* Enforce length based on allocated size */
1470 bytecode_node->bc.len = bytecode_len;
1471 list_add_tail(&bytecode_node->node, &enabler->filter_bytecode_head);
1472 lttng_session_lazy_sync_enablers(enabler->chan->session);
1473 return 0;
1474
1475 error_free:
1476 kfree(bytecode_node);
1477 return ret;
1478 }
1479
1480 int lttng_event_add_callsite(struct lttng_event *event,
1481 struct lttng_kernel_event_callsite __user *callsite)
1482 {
1483
1484 switch (event->instrumentation) {
1485 case LTTNG_KERNEL_UPROBE:
1486 return lttng_uprobes_add_callsite(event, callsite);
1487 default:
1488 return -EINVAL;
1489 }
1490 }
1491
1492 int lttng_enabler_attach_context(struct lttng_enabler *enabler,
1493 struct lttng_kernel_context *context_param)
1494 {
1495 return -ENOSYS;
1496 }
1497
1498 static
1499 void lttng_enabler_destroy(struct lttng_enabler *enabler)
1500 {
1501 struct lttng_filter_bytecode_node *filter_node, *tmp_filter_node;
1502
1503 /* Destroy filter bytecode */
1504 list_for_each_entry_safe(filter_node, tmp_filter_node,
1505 &enabler->filter_bytecode_head, node) {
1506 kfree(filter_node);
1507 }
1508
1509 /* Destroy contexts */
1510 lttng_destroy_context(enabler->ctx);
1511
1512 list_del(&enabler->node);
1513 kfree(enabler);
1514 }
1515
1516 /*
1517 * lttng_session_sync_enablers should be called just before starting a
1518 * session.
1519 * Should be called with sessions mutex held.
1520 */
1521 static
1522 void lttng_session_sync_enablers(struct lttng_session *session)
1523 {
1524 struct lttng_enabler *enabler;
1525 struct lttng_event *event;
1526
1527 list_for_each_entry(enabler, &session->enablers_head, node)
1528 lttng_enabler_ref_events(enabler);
1529 /*
1530 * For each event, if at least one of its enablers is enabled,
1531 * and its channel and session transient states are enabled, we
1532 * enable the event, else we disable it.
1533 */
1534 list_for_each_entry(event, &session->events, list) {
1535 struct lttng_enabler_ref *enabler_ref;
1536 struct lttng_bytecode_runtime *runtime;
1537 int enabled = 0, has_enablers_without_bytecode = 0;
1538
1539 switch (event->instrumentation) {
1540 case LTTNG_KERNEL_TRACEPOINT:
1541 case LTTNG_KERNEL_SYSCALL:
1542 /* Enable events */
1543 list_for_each_entry(enabler_ref,
1544 &event->enablers_ref_head, node) {
1545 if (enabler_ref->ref->enabled) {
1546 enabled = 1;
1547 break;
1548 }
1549 }
1550 break;
1551 default:
1552 /* Not handled with lazy sync. */
1553 continue;
1554 }
1555 /*
1556 * Enabled state is based on union of enablers, with
1557 * intesection of session and channel transient enable
1558 * states.
1559 */
1560 enabled = enabled && session->tstate && event->chan->tstate;
1561
1562 WRITE_ONCE(event->enabled, enabled);
1563 /*
1564 * Sync tracepoint registration with event enabled
1565 * state.
1566 */
1567 if (enabled) {
1568 register_event(event);
1569 } else {
1570 _lttng_event_unregister(event);
1571 }
1572
1573 /* Check if has enablers without bytecode enabled */
1574 list_for_each_entry(enabler_ref,
1575 &event->enablers_ref_head, node) {
1576 if (enabler_ref->ref->enabled
1577 && list_empty(&enabler_ref->ref->filter_bytecode_head)) {
1578 has_enablers_without_bytecode = 1;
1579 break;
1580 }
1581 }
1582 event->has_enablers_without_bytecode =
1583 has_enablers_without_bytecode;
1584
1585 /* Enable filters */
1586 list_for_each_entry(runtime,
1587 &event->bytecode_runtime_head, node)
1588 lttng_filter_sync_state(runtime);
1589 }
1590 }
1591
1592 /*
1593 * Apply enablers to session events, adding events to session if need
1594 * be. It is required after each modification applied to an active
1595 * session, and right before session "start".
1596 * "lazy" sync means we only sync if required.
1597 * Should be called with sessions mutex held.
1598 */
1599 static
1600 void lttng_session_lazy_sync_enablers(struct lttng_session *session)
1601 {
1602 /* We can skip if session is not active */
1603 if (!session->active)
1604 return;
1605 lttng_session_sync_enablers(session);
1606 }
1607
1608 /*
1609 * Serialize at most one packet worth of metadata into a metadata
1610 * channel.
1611 * We grab the metadata cache mutex to get exclusive access to our metadata
1612 * buffer and to the metadata cache. Exclusive access to the metadata buffer
1613 * allows us to do racy operations such as looking for remaining space left in
1614 * packet and write, since mutual exclusion protects us from concurrent writes.
1615 * Mutual exclusion on the metadata cache allow us to read the cache content
1616 * without racing against reallocation of the cache by updates.
1617 * Returns the number of bytes written in the channel, 0 if no data
1618 * was written and a negative value on error.
1619 */
1620 int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
1621 struct channel *chan)
1622 {
1623 struct lib_ring_buffer_ctx ctx;
1624 int ret = 0;
1625 size_t len, reserve_len;
1626
1627 /*
1628 * Ensure we support mutiple get_next / put sequences followed by
1629 * put_next. The metadata cache lock protects reading the metadata
1630 * cache. It can indeed be read concurrently by "get_next_subbuf" and
1631 * "flush" operations on the buffer invoked by different processes.
1632 * Moreover, since the metadata cache memory can be reallocated, we
1633 * need to have exclusive access against updates even though we only
1634 * read it.
1635 */
1636 mutex_lock(&stream->metadata_cache->lock);
1637 WARN_ON(stream->metadata_in < stream->metadata_out);
1638 if (stream->metadata_in != stream->metadata_out)
1639 goto end;
1640
1641 /* Metadata regenerated, change the version. */
1642 if (stream->metadata_cache->version != stream->version)
1643 stream->version = stream->metadata_cache->version;
1644
1645 len = stream->metadata_cache->metadata_written -
1646 stream->metadata_in;
1647 if (!len)
1648 goto end;
1649 reserve_len = min_t(size_t,
1650 stream->transport->ops.packet_avail_size(chan),
1651 len);
1652 lib_ring_buffer_ctx_init(&ctx, chan, NULL, reserve_len,
1653 sizeof(char), -1);
1654 /*
1655 * If reservation failed, return an error to the caller.
1656 */
1657 ret = stream->transport->ops.event_reserve(&ctx, 0);
1658 if (ret != 0) {
1659 printk(KERN_WARNING "LTTng: Metadata event reservation failed\n");
1660 goto end;
1661 }
1662 stream->transport->ops.event_write(&ctx,
1663 stream->metadata_cache->data + stream->metadata_in,
1664 reserve_len);
1665 stream->transport->ops.event_commit(&ctx);
1666 stream->metadata_in += reserve_len;
1667 ret = reserve_len;
1668
1669 end:
1670 mutex_unlock(&stream->metadata_cache->lock);
1671 return ret;
1672 }
1673
1674 /*
1675 * Write the metadata to the metadata cache.
1676 * Must be called with sessions_mutex held.
1677 * The metadata cache lock protects us from concurrent read access from
1678 * thread outputting metadata content to ring buffer.
1679 */
1680 int lttng_metadata_printf(struct lttng_session *session,
1681 const char *fmt, ...)
1682 {
1683 char *str;
1684 size_t len;
1685 va_list ap;
1686 struct lttng_metadata_stream *stream;
1687
1688 WARN_ON_ONCE(!READ_ONCE(session->active));
1689
1690 va_start(ap, fmt);
1691 str = kvasprintf(GFP_KERNEL, fmt, ap);
1692 va_end(ap);
1693 if (!str)
1694 return -ENOMEM;
1695
1696 len = strlen(str);
1697 mutex_lock(&session->metadata_cache->lock);
1698 if (session->metadata_cache->metadata_written + len >
1699 session->metadata_cache->cache_alloc) {
1700 char *tmp_cache_realloc;
1701 unsigned int tmp_cache_alloc_size;
1702
1703 tmp_cache_alloc_size = max_t(unsigned int,
1704 session->metadata_cache->cache_alloc + len,
1705 session->metadata_cache->cache_alloc << 1);
1706 tmp_cache_realloc = vzalloc(tmp_cache_alloc_size);
1707 if (!tmp_cache_realloc)
1708 goto err;
1709 if (session->metadata_cache->data) {
1710 memcpy(tmp_cache_realloc,
1711 session->metadata_cache->data,
1712 session->metadata_cache->cache_alloc);
1713 vfree(session->metadata_cache->data);
1714 }
1715
1716 session->metadata_cache->cache_alloc = tmp_cache_alloc_size;
1717 session->metadata_cache->data = tmp_cache_realloc;
1718 }
1719 memcpy(session->metadata_cache->data +
1720 session->metadata_cache->metadata_written,
1721 str, len);
1722 session->metadata_cache->metadata_written += len;
1723 mutex_unlock(&session->metadata_cache->lock);
1724 kfree(str);
1725
1726 list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list)
1727 wake_up_interruptible(&stream->read_wait);
1728
1729 return 0;
1730
1731 err:
1732 mutex_unlock(&session->metadata_cache->lock);
1733 kfree(str);
1734 return -ENOMEM;
1735 }
1736
1737 static
1738 int print_tabs(struct lttng_session *session, size_t nesting)
1739 {
1740 size_t i;
1741
1742 for (i = 0; i < nesting; i++) {
1743 int ret;
1744
1745 ret = lttng_metadata_printf(session, " ");
1746 if (ret) {
1747 return ret;
1748 }
1749 }
1750 return 0;
1751 }
1752
1753 static
1754 int lttng_field_name_statedump(struct lttng_session *session,
1755 const struct lttng_event_field *field,
1756 size_t nesting)
1757 {
1758 return lttng_metadata_printf(session, " _%s;\n", field->name);
1759 }
1760
1761 static
1762 int _lttng_integer_type_statedump(struct lttng_session *session,
1763 const struct lttng_type *type,
1764 size_t nesting)
1765 {
1766 int ret;
1767
1768 WARN_ON_ONCE(type->atype != atype_integer);
1769 ret = print_tabs(session, nesting);
1770 if (ret)
1771 return ret;
1772 ret = lttng_metadata_printf(session,
1773 "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s }",
1774 type->u.integer.size,
1775 type->u.integer.alignment,
1776 type->u.integer.signedness,
1777 (type->u.integer.encoding == lttng_encode_none)
1778 ? "none"
1779 : (type->u.integer.encoding == lttng_encode_UTF8)
1780 ? "UTF8"
1781 : "ASCII",
1782 type->u.integer.base,
1783 #if __BYTE_ORDER == __BIG_ENDIAN
1784 type->u.integer.reverse_byte_order ? " byte_order = le;" : ""
1785 #else
1786 type->u.integer.reverse_byte_order ? " byte_order = be;" : ""
1787 #endif
1788 );
1789 return ret;
1790 }
1791
1792 /*
1793 * Must be called with sessions_mutex held.
1794 */
1795 static
1796 int _lttng_struct_type_statedump(struct lttng_session *session,
1797 const struct lttng_type *type,
1798 size_t nesting)
1799 {
1800 int ret;
1801 uint32_t i, nr_fields;
1802 unsigned int alignment;
1803
1804 WARN_ON_ONCE(type->atype != atype_struct_nestable);
1805
1806 ret = print_tabs(session, nesting);
1807 if (ret)
1808 return ret;
1809 ret = lttng_metadata_printf(session,
1810 "struct {\n");
1811 if (ret)
1812 return ret;
1813 nr_fields = type->u.struct_nestable.nr_fields;
1814 for (i = 0; i < nr_fields; i++) {
1815 const struct lttng_event_field *iter_field;
1816
1817 iter_field = &type->u.struct_nestable.fields[i];
1818 ret = _lttng_field_statedump(session, iter_field, nesting + 1);
1819 if (ret)
1820 return ret;
1821 }
1822 ret = print_tabs(session, nesting);
1823 if (ret)
1824 return ret;
1825 alignment = type->u.struct_nestable.alignment;
1826 if (alignment) {
1827 ret = lttng_metadata_printf(session,
1828 "} align(%u)",
1829 alignment);
1830 } else {
1831 ret = lttng_metadata_printf(session,
1832 "}");
1833 }
1834 return ret;
1835 }
1836
1837 /*
1838 * Must be called with sessions_mutex held.
1839 */
1840 static
1841 int _lttng_struct_field_statedump(struct lttng_session *session,
1842 const struct lttng_event_field *field,
1843 size_t nesting)
1844 {
1845 int ret;
1846
1847 ret = _lttng_struct_type_statedump(session,
1848 &field->type, nesting);
1849 if (ret)
1850 return ret;
1851 return lttng_field_name_statedump(session, field, nesting);
1852 }
1853
1854 /*
1855 * Must be called with sessions_mutex held.
1856 */
1857 static
1858 int _lttng_variant_type_statedump(struct lttng_session *session,
1859 const struct lttng_type *type,
1860 size_t nesting)
1861 {
1862 int ret;
1863 uint32_t i, nr_choices;
1864
1865 WARN_ON_ONCE(type->atype != atype_variant_nestable);
1866 /*
1867 * CTF 1.8 does not allow expressing nonzero variant alignment in a nestable way.
1868 */
1869 if (type->u.variant_nestable.alignment != 0)
1870 return -EINVAL;
1871 ret = print_tabs(session, nesting);
1872 if (ret)
1873 return ret;
1874 ret = lttng_metadata_printf(session,
1875 "variant <_%s> {\n",
1876 type->u.variant_nestable.tag_name);
1877 if (ret)
1878 return ret;
1879 nr_choices = type->u.variant_nestable.nr_choices;
1880 for (i = 0; i < nr_choices; i++) {
1881 const struct lttng_event_field *iter_field;
1882
1883 iter_field = &type->u.variant_nestable.choices[i];
1884 ret = _lttng_field_statedump(session, iter_field, nesting + 1);
1885 if (ret)
1886 return ret;
1887 }
1888 ret = print_tabs(session, nesting);
1889 if (ret)
1890 return ret;
1891 ret = lttng_metadata_printf(session,
1892 "}");
1893 return ret;
1894 }
1895
1896 /*
1897 * Must be called with sessions_mutex held.
1898 */
1899 static
1900 int _lttng_variant_field_statedump(struct lttng_session *session,
1901 const struct lttng_event_field *field,
1902 size_t nesting)
1903 {
1904 int ret;
1905
1906 ret = _lttng_variant_type_statedump(session,
1907 &field->type, nesting);
1908 if (ret)
1909 return ret;
1910 return lttng_field_name_statedump(session, field, nesting);
1911 }
1912
1913 /*
1914 * Must be called with sessions_mutex held.
1915 */
1916 static
1917 int _lttng_array_field_statedump(struct lttng_session *session,
1918 const struct lttng_event_field *field,
1919 size_t nesting)
1920 {
1921 int ret;
1922 const struct lttng_type *elem_type;
1923
1924 WARN_ON_ONCE(field->type.atype != atype_array_nestable);
1925
1926 if (field->type.u.array_nestable.alignment) {
1927 ret = print_tabs(session, nesting);
1928 if (ret)
1929 return ret;
1930 ret = lttng_metadata_printf(session,
1931 "struct { } align(%u) _%s_padding;\n",
1932 field->type.u.array_nestable.alignment * CHAR_BIT,
1933 field->name);
1934 if (ret)
1935 return ret;
1936 }
1937 /*
1938 * Nested compound types: Only array of structures and variants are
1939 * currently supported.
1940 */
1941 elem_type = field->type.u.array_nestable.elem_type;
1942 switch (elem_type->atype) {
1943 case atype_integer:
1944 case atype_struct_nestable:
1945 case atype_variant_nestable:
1946 ret = _lttng_type_statedump(session, elem_type, nesting);
1947 if (ret)
1948 return ret;
1949 break;
1950
1951 default:
1952 return -EINVAL;
1953 }
1954 ret = lttng_metadata_printf(session,
1955 " _%s[%u];\n",
1956 field->name,
1957 field->type.u.array_nestable.length);
1958 return ret;
1959 }
1960
1961 /*
1962 * Must be called with sessions_mutex held.
1963 */
1964 static
1965 int _lttng_sequence_field_statedump(struct lttng_session *session,
1966 const struct lttng_event_field *field,
1967 size_t nesting)
1968 {
1969 int ret;
1970 const char *length_name;
1971 const struct lttng_type *elem_type;
1972
1973 WARN_ON_ONCE(field->type.atype != atype_sequence_nestable);
1974
1975 length_name = field->type.u.sequence_nestable.length_name;
1976
1977 if (field->type.u.sequence_nestable.alignment) {
1978 ret = print_tabs(session, nesting);
1979 if (ret)
1980 return ret;
1981 ret = lttng_metadata_printf(session,
1982 "struct { } align(%u) _%s_padding;\n",
1983 field->type.u.sequence_nestable.alignment * CHAR_BIT,
1984 field->name);
1985 if (ret)
1986 return ret;
1987 }
1988
1989 /*
1990 * Nested compound types: Only array of structures and variants are
1991 * currently supported.
1992 */
1993 elem_type = field->type.u.sequence_nestable.elem_type;
1994 switch (elem_type->atype) {
1995 case atype_integer:
1996 case atype_struct_nestable:
1997 case atype_variant_nestable:
1998 ret = _lttng_type_statedump(session, elem_type, nesting);
1999 if (ret)
2000 return ret;
2001 break;
2002
2003 default:
2004 return -EINVAL;
2005 }
2006 ret = lttng_metadata_printf(session,
2007 " _%s[ _%s ];\n",
2008 field->name,
2009 field->type.u.sequence_nestable.length_name);
2010 return ret;
2011 }
2012
2013 /*
2014 * Must be called with sessions_mutex held.
2015 */
2016 static
2017 int _lttng_enum_type_statedump(struct lttng_session *session,
2018 const struct lttng_type *type,
2019 size_t nesting)
2020 {
2021 const struct lttng_enum_desc *enum_desc;
2022 const struct lttng_type *container_type;
2023 int ret;
2024 unsigned int i, nr_entries;
2025
2026 container_type = type->u.enum_nestable.container_type;
2027 if (container_type->atype != atype_integer) {
2028 ret = -EINVAL;
2029 goto end;
2030 }
2031 enum_desc = type->u.enum_nestable.desc;
2032 nr_entries = enum_desc->nr_entries;
2033
2034 ret = print_tabs(session, nesting);
2035 if (ret)
2036 goto end;
2037 ret = lttng_metadata_printf(session, "enum : ");
2038 if (ret)
2039 goto end;
2040 ret = _lttng_integer_type_statedump(session, container_type, 0);
2041 if (ret)
2042 goto end;
2043 ret = lttng_metadata_printf(session, " {\n");
2044 if (ret)
2045 goto end;
2046 /* Dump all entries */
2047 for (i = 0; i < nr_entries; i++) {
2048 const struct lttng_enum_entry *entry = &enum_desc->entries[i];
2049 int j, len;
2050
2051 ret = print_tabs(session, nesting + 1);
2052 if (ret)
2053 goto end;
2054 ret = lttng_metadata_printf(session,
2055 "\"");
2056 if (ret)
2057 goto end;
2058 len = strlen(entry->string);
2059 /* Escape the character '"' */
2060 for (j = 0; j < len; j++) {
2061 char c = entry->string[j];
2062
2063 switch (c) {
2064 case '"':
2065 ret = lttng_metadata_printf(session,
2066 "\\\"");
2067 break;
2068 case '\\':
2069 ret = lttng_metadata_printf(session,
2070 "\\\\");
2071 break;
2072 default:
2073 ret = lttng_metadata_printf(session,
2074 "%c", c);
2075 break;
2076 }
2077 if (ret)
2078 goto end;
2079 }
2080 ret = lttng_metadata_printf(session, "\"");
2081 if (ret)
2082 goto end;
2083
2084 if (entry->options.is_auto) {
2085 ret = lttng_metadata_printf(session, ",\n");
2086 if (ret)
2087 goto end;
2088 } else {
2089 ret = lttng_metadata_printf(session,
2090 " = ");
2091 if (ret)
2092 goto end;
2093 if (entry->start.signedness)
2094 ret = lttng_metadata_printf(session,
2095 "%lld", (long long) entry->start.value);
2096 else
2097 ret = lttng_metadata_printf(session,
2098 "%llu", entry->start.value);
2099 if (ret)
2100 goto end;
2101 if (entry->start.signedness == entry->end.signedness &&
2102 entry->start.value
2103 == entry->end.value) {
2104 ret = lttng_metadata_printf(session,
2105 ",\n");
2106 } else {
2107 if (entry->end.signedness) {
2108 ret = lttng_metadata_printf(session,
2109 " ... %lld,\n",
2110 (long long) entry->end.value);
2111 } else {
2112 ret = lttng_metadata_printf(session,
2113 " ... %llu,\n",
2114 entry->end.value);
2115 }
2116 }
2117 if (ret)
2118 goto end;
2119 }
2120 }
2121 ret = print_tabs(session, nesting);
2122 if (ret)
2123 goto end;
2124 ret = lttng_metadata_printf(session, "}");
2125 end:
2126 return ret;
2127 }
2128
2129 /*
2130 * Must be called with sessions_mutex held.
2131 */
2132 static
2133 int _lttng_enum_field_statedump(struct lttng_session *session,
2134 const struct lttng_event_field *field,
2135 size_t nesting)
2136 {
2137 int ret;
2138
2139 ret = _lttng_enum_type_statedump(session, &field->type, nesting);
2140 if (ret)
2141 return ret;
2142 return lttng_field_name_statedump(session, field, nesting);
2143 }
2144
2145 static
2146 int _lttng_integer_field_statedump(struct lttng_session *session,
2147 const struct lttng_event_field *field,
2148 size_t nesting)
2149 {
2150 int ret;
2151
2152 ret = _lttng_integer_type_statedump(session, &field->type, nesting);
2153 if (ret)
2154 return ret;
2155 return lttng_field_name_statedump(session, field, nesting);
2156 }
2157
2158 static
2159 int _lttng_string_type_statedump(struct lttng_session *session,
2160 const struct lttng_type *type,
2161 size_t nesting)
2162 {
2163 int ret;
2164
2165 WARN_ON_ONCE(type->atype != atype_string);
2166 /* Default encoding is UTF8 */
2167 ret = print_tabs(session, nesting);
2168 if (ret)
2169 return ret;
2170 ret = lttng_metadata_printf(session,
2171 "string%s",
2172 type->u.string.encoding == lttng_encode_ASCII ?
2173 " { encoding = ASCII; }" : "");
2174 return ret;
2175 }
2176
2177 static
2178 int _lttng_string_field_statedump(struct lttng_session *session,
2179 const struct lttng_event_field *field,
2180 size_t nesting)
2181 {
2182 int ret;
2183
2184 WARN_ON_ONCE(field->type.atype != atype_string);
2185 ret = _lttng_string_type_statedump(session, &field->type, nesting);
2186 if (ret)
2187 return ret;
2188 return lttng_field_name_statedump(session, field, nesting);
2189 }
2190
2191 /*
2192 * Must be called with sessions_mutex held.
2193 */
2194 static
2195 int _lttng_type_statedump(struct lttng_session *session,
2196 const struct lttng_type *type,
2197 size_t nesting)
2198 {
2199 int ret = 0;
2200
2201 switch (type->atype) {
2202 case atype_integer:
2203 ret = _lttng_integer_type_statedump(session, type, nesting);
2204 break;
2205 case atype_enum_nestable:
2206 ret = _lttng_enum_type_statedump(session, type, nesting);
2207 break;
2208 case atype_string:
2209 ret = _lttng_string_type_statedump(session, type, nesting);
2210 break;
2211 case atype_struct_nestable:
2212 ret = _lttng_struct_type_statedump(session, type, nesting);
2213 break;
2214 case atype_variant_nestable:
2215 ret = _lttng_variant_type_statedump(session, type, nesting);
2216 break;
2217
2218 /* Nested arrays and sequences are not supported yet. */
2219 case atype_array_nestable:
2220 case atype_sequence_nestable:
2221 default:
2222 WARN_ON_ONCE(1);
2223 return -EINVAL;
2224 }
2225 return ret;
2226 }
2227
2228 /*
2229 * Must be called with sessions_mutex held.
2230 */
2231 static
2232 int _lttng_field_statedump(struct lttng_session *session,
2233 const struct lttng_event_field *field,
2234 size_t nesting)
2235 {
2236 int ret = 0;
2237
2238 switch (field->type.atype) {
2239 case atype_integer:
2240 ret = _lttng_integer_field_statedump(session, field, nesting);
2241 break;
2242 case atype_enum_nestable:
2243 ret = _lttng_enum_field_statedump(session, field, nesting);
2244 break;
2245 case atype_string:
2246 ret = _lttng_string_field_statedump(session, field, nesting);
2247 break;
2248 case atype_struct_nestable:
2249 ret = _lttng_struct_field_statedump(session, field, nesting);
2250 break;
2251 case atype_array_nestable:
2252 ret = _lttng_array_field_statedump(session, field, nesting);
2253 break;
2254 case atype_sequence_nestable:
2255 ret = _lttng_sequence_field_statedump(session, field, nesting);
2256 break;
2257 case atype_variant_nestable:
2258 ret = _lttng_variant_field_statedump(session, field, nesting);
2259 break;
2260
2261 default:
2262 WARN_ON_ONCE(1);
2263 return -EINVAL;
2264 }
2265 return ret;
2266 }
2267
2268 static
2269 int _lttng_context_metadata_statedump(struct lttng_session *session,
2270 struct lttng_ctx *ctx)
2271 {
2272 int ret = 0;
2273 int i;
2274
2275 if (!ctx)
2276 return 0;
2277 for (i = 0; i < ctx->nr_fields; i++) {
2278 const struct lttng_ctx_field *field = &ctx->fields[i];
2279
2280 ret = _lttng_field_statedump(session, &field->event_field, 2);
2281 if (ret)
2282 return ret;
2283 }
2284 return ret;
2285 }
2286
2287 static
2288 int _lttng_fields_metadata_statedump(struct lttng_session *session,
2289 struct lttng_event *event)
2290 {
2291 const struct lttng_event_desc *desc = event->desc;
2292 int ret = 0;
2293 int i;
2294
2295 for (i = 0; i < desc->nr_fields; i++) {
2296 const struct lttng_event_field *field = &desc->fields[i];
2297
2298 ret = _lttng_field_statedump(session, field, 2);
2299 if (ret)
2300 return ret;
2301 }
2302 return ret;
2303 }
2304
2305 /*
2306 * Must be called with sessions_mutex held.
2307 */
2308 static
2309 int _lttng_event_metadata_statedump(struct lttng_session *session,
2310 struct lttng_channel *chan,
2311 struct lttng_event *event)
2312 {
2313 int ret = 0;
2314
2315 if (event->metadata_dumped || !READ_ONCE(session->active))
2316 return 0;
2317 if (chan->channel_type == METADATA_CHANNEL)
2318 return 0;
2319
2320 ret = lttng_metadata_printf(session,
2321 "event {\n"
2322 " name = \"%s\";\n"
2323 " id = %u;\n"
2324 " stream_id = %u;\n",
2325 event->desc->name,
2326 event->id,
2327 event->chan->id);
2328 if (ret)
2329 goto end;
2330
2331 if (event->ctx) {
2332 ret = lttng_metadata_printf(session,
2333 " context := struct {\n");
2334 if (ret)
2335 goto end;
2336 }
2337 ret = _lttng_context_metadata_statedump(session, event->ctx);
2338 if (ret)
2339 goto end;
2340 if (event->ctx) {
2341 ret = lttng_metadata_printf(session,
2342 " };\n");
2343 if (ret)
2344 goto end;
2345 }
2346
2347 ret = lttng_metadata_printf(session,
2348 " fields := struct {\n"
2349 );
2350 if (ret)
2351 goto end;
2352
2353 ret = _lttng_fields_metadata_statedump(session, event);
2354 if (ret)
2355 goto end;
2356
2357 /*
2358 * LTTng space reservation can only reserve multiples of the
2359 * byte size.
2360 */
2361 ret = lttng_metadata_printf(session,
2362 " };\n"
2363 "};\n\n");
2364 if (ret)
2365 goto end;
2366
2367 event->metadata_dumped = 1;
2368 end:
2369 return ret;
2370
2371 }
2372
2373 /*
2374 * Must be called with sessions_mutex held.
2375 */
2376 static
2377 int _lttng_channel_metadata_statedump(struct lttng_session *session,
2378 struct lttng_channel *chan)
2379 {
2380 int ret = 0;
2381
2382 if (chan->metadata_dumped || !READ_ONCE(session->active))
2383 return 0;
2384
2385 if (chan->channel_type == METADATA_CHANNEL)
2386 return 0;
2387
2388 WARN_ON_ONCE(!chan->header_type);
2389 ret = lttng_metadata_printf(session,
2390 "stream {\n"
2391 " id = %u;\n"
2392 " event.header := %s;\n"
2393 " packet.context := struct packet_context;\n",
2394 chan->id,
2395 chan->header_type == 1 ? "struct event_header_compact" :
2396 "struct event_header_large");
2397 if (ret)
2398 goto end;
2399
2400 if (chan->ctx) {
2401 ret = lttng_metadata_printf(session,
2402 " event.context := struct {\n");
2403 if (ret)
2404 goto end;
2405 }
2406 ret = _lttng_context_metadata_statedump(session, chan->ctx);
2407 if (ret)
2408 goto end;
2409 if (chan->ctx) {
2410 ret = lttng_metadata_printf(session,
2411 " };\n");
2412 if (ret)
2413 goto end;
2414 }
2415
2416 ret = lttng_metadata_printf(session,
2417 "};\n\n");
2418
2419 chan->metadata_dumped = 1;
2420 end:
2421 return ret;
2422 }
2423
2424 /*
2425 * Must be called with sessions_mutex held.
2426 */
2427 static
2428 int _lttng_stream_packet_context_declare(struct lttng_session *session)
2429 {
2430 return lttng_metadata_printf(session,
2431 "struct packet_context {\n"
2432 " uint64_clock_monotonic_t timestamp_begin;\n"
2433 " uint64_clock_monotonic_t timestamp_end;\n"
2434 " uint64_t content_size;\n"
2435 " uint64_t packet_size;\n"
2436 " uint64_t packet_seq_num;\n"
2437 " unsigned long events_discarded;\n"
2438 " uint32_t cpu_id;\n"
2439 "};\n\n"
2440 );
2441 }
2442
2443 /*
2444 * Compact header:
2445 * id: range: 0 - 30.
2446 * id 31 is reserved to indicate an extended header.
2447 *
2448 * Large header:
2449 * id: range: 0 - 65534.
2450 * id 65535 is reserved to indicate an extended header.
2451 *
2452 * Must be called with sessions_mutex held.
2453 */
2454 static
2455 int _lttng_event_header_declare(struct lttng_session *session)
2456 {
2457 return lttng_metadata_printf(session,
2458 "struct event_header_compact {\n"
2459 " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
2460 " variant <id> {\n"
2461 " struct {\n"
2462 " uint27_clock_monotonic_t timestamp;\n"
2463 " } compact;\n"
2464 " struct {\n"
2465 " uint32_t id;\n"
2466 " uint64_clock_monotonic_t timestamp;\n"
2467 " } extended;\n"
2468 " } v;\n"
2469 "} align(%u);\n"
2470 "\n"
2471 "struct event_header_large {\n"
2472 " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
2473 " variant <id> {\n"
2474 " struct {\n"
2475 " uint32_clock_monotonic_t timestamp;\n"
2476 " } compact;\n"
2477 " struct {\n"
2478 " uint32_t id;\n"
2479 " uint64_clock_monotonic_t timestamp;\n"
2480 " } extended;\n"
2481 " } v;\n"
2482 "} align(%u);\n\n",
2483 lttng_alignof(uint32_t) * CHAR_BIT,
2484 lttng_alignof(uint16_t) * CHAR_BIT
2485 );
2486 }
2487
2488 /*
2489 * Approximation of NTP time of day to clock monotonic correlation,
2490 * taken at start of trace.
2491 * Yes, this is only an approximation. Yes, we can (and will) do better
2492 * in future versions.
2493 * This function may return a negative offset. It may happen if the
2494 * system sets the REALTIME clock to 0 after boot.
2495 *
2496 * Use 64bit timespec on kernels that have it, this makes 32bit arch
2497 * y2038 compliant.
2498 */
2499 static
2500 int64_t measure_clock_offset(void)
2501 {
2502 uint64_t monotonic_avg, monotonic[2], realtime;
2503 uint64_t tcf = trace_clock_freq();
2504 int64_t offset;
2505 unsigned long flags;
2506 struct timespec64 rts = { 0, 0 };
2507
2508 /* Disable interrupts to increase correlation precision. */
2509 local_irq_save(flags);
2510 monotonic[0] = trace_clock_read64();
2511 ktime_get_real_ts64(&rts);
2512 monotonic[1] = trace_clock_read64();
2513 local_irq_restore(flags);
2514
2515 monotonic_avg = (monotonic[0] + monotonic[1]) >> 1;
2516 realtime = (uint64_t) rts.tv_sec * tcf;
2517 if (tcf == NSEC_PER_SEC) {
2518 realtime += rts.tv_nsec;
2519 } else {
2520 uint64_t n = rts.tv_nsec * tcf;
2521
2522 do_div(n, NSEC_PER_SEC);
2523 realtime += n;
2524 }
2525 offset = (int64_t) realtime - monotonic_avg;
2526 return offset;
2527 }
2528
2529 static
2530 int print_escaped_ctf_string(struct lttng_session *session, const char *string)
2531 {
2532 int ret = 0;
2533 size_t i;
2534 char cur;
2535
2536 i = 0;
2537 cur = string[i];
2538 while (cur != '\0') {
2539 switch (cur) {
2540 case '\n':
2541 ret = lttng_metadata_printf(session, "%s", "\\n");
2542 break;
2543 case '\\':
2544 case '"':
2545 ret = lttng_metadata_printf(session, "%c", '\\');
2546 if (ret)
2547 goto error;
2548 /* We still print the current char */
2549 /* Fallthrough */
2550 default:
2551 ret = lttng_metadata_printf(session, "%c", cur);
2552 break;
2553 }
2554
2555 if (ret)
2556 goto error;
2557
2558 cur = string[++i];
2559 }
2560 error:
2561 return ret;
2562 }
2563
2564 static
2565 int print_metadata_escaped_field(struct lttng_session *session, const char *field,
2566 const char *field_value)
2567 {
2568 int ret;
2569
2570 ret = lttng_metadata_printf(session, " %s = \"", field);
2571 if (ret)
2572 goto error;
2573
2574 ret = print_escaped_ctf_string(session, field_value);
2575 if (ret)
2576 goto error;
2577
2578 ret = lttng_metadata_printf(session, "\";\n");
2579
2580 error:
2581 return ret;
2582 }
2583
2584 /*
2585 * Output metadata into this session's metadata buffers.
2586 * Must be called with sessions_mutex held.
2587 */
2588 static
2589 int _lttng_session_metadata_statedump(struct lttng_session *session)
2590 {
2591 unsigned char *uuid_c = session->uuid.b;
2592 unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
2593 const char *product_uuid;
2594 struct lttng_channel *chan;
2595 struct lttng_event *event;
2596 int ret = 0;
2597
2598 if (!READ_ONCE(session->active))
2599 return 0;
2600 if (session->metadata_dumped)
2601 goto skip_session;
2602
2603 snprintf(uuid_s, sizeof(uuid_s),
2604 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
2605 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
2606 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
2607 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
2608 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
2609
2610 ret = lttng_metadata_printf(session,
2611 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
2612 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
2613 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
2614 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
2615 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
2616 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
2617 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
2618 "\n"
2619 "trace {\n"
2620 " major = %u;\n"
2621 " minor = %u;\n"
2622 " uuid = \"%s\";\n"
2623 " byte_order = %s;\n"
2624 " packet.header := struct {\n"
2625 " uint32_t magic;\n"
2626 " uint8_t uuid[16];\n"
2627 " uint32_t stream_id;\n"
2628 " uint64_t stream_instance_id;\n"
2629 " };\n"
2630 "};\n\n",
2631 lttng_alignof(uint8_t) * CHAR_BIT,
2632 lttng_alignof(uint16_t) * CHAR_BIT,
2633 lttng_alignof(uint32_t) * CHAR_BIT,
2634 lttng_alignof(uint64_t) * CHAR_BIT,
2635 sizeof(unsigned long) * CHAR_BIT,
2636 lttng_alignof(unsigned long) * CHAR_BIT,
2637 CTF_SPEC_MAJOR,
2638 CTF_SPEC_MINOR,
2639 uuid_s,
2640 #if __BYTE_ORDER == __BIG_ENDIAN
2641 "be"
2642 #else
2643 "le"
2644 #endif
2645 );
2646 if (ret)
2647 goto end;
2648
2649 ret = lttng_metadata_printf(session,
2650 "env {\n"
2651 " hostname = \"%s\";\n"
2652 " domain = \"kernel\";\n"
2653 " sysname = \"%s\";\n"
2654 " kernel_release = \"%s\";\n"
2655 " kernel_version = \"%s\";\n"
2656 " tracer_name = \"lttng-modules\";\n"
2657 " tracer_major = %d;\n"
2658 " tracer_minor = %d;\n"
2659 " tracer_patchlevel = %d;\n"
2660 " trace_buffering_scheme = \"global\";\n",
2661 current->nsproxy->uts_ns->name.nodename,
2662 utsname()->sysname,
2663 utsname()->release,
2664 utsname()->version,
2665 LTTNG_MODULES_MAJOR_VERSION,
2666 LTTNG_MODULES_MINOR_VERSION,
2667 LTTNG_MODULES_PATCHLEVEL_VERSION
2668 );
2669 if (ret)
2670 goto end;
2671
2672 ret = print_metadata_escaped_field(session, "trace_name", session->name);
2673 if (ret)
2674 goto end;
2675 ret = print_metadata_escaped_field(session, "trace_creation_datetime",
2676 session->creation_time);
2677 if (ret)
2678 goto end;
2679
2680 /* Add the product UUID to the 'env' section */
2681 product_uuid = dmi_get_system_info(DMI_PRODUCT_UUID);
2682 if (product_uuid) {
2683 ret = lttng_metadata_printf(session,
2684 " product_uuid = \"%s\";\n",
2685 product_uuid
2686 );
2687 if (ret)
2688 goto end;
2689 }
2690
2691 /* Close the 'env' section */
2692 ret = lttng_metadata_printf(session, "};\n\n");
2693 if (ret)
2694 goto end;
2695
2696 ret = lttng_metadata_printf(session,
2697 "clock {\n"
2698 " name = \"%s\";\n",
2699 trace_clock_name()
2700 );
2701 if (ret)
2702 goto end;
2703
2704 if (!trace_clock_uuid(clock_uuid_s)) {
2705 ret = lttng_metadata_printf(session,
2706 " uuid = \"%s\";\n",
2707 clock_uuid_s
2708 );
2709 if (ret)
2710 goto end;
2711 }
2712
2713 ret = lttng_metadata_printf(session,
2714 " description = \"%s\";\n"
2715 " freq = %llu; /* Frequency, in Hz */\n"
2716 " /* clock value offset from Epoch is: offset * (1/freq) */\n"
2717 " offset = %lld;\n"
2718 "};\n\n",
2719 trace_clock_description(),
2720 (unsigned long long) trace_clock_freq(),
2721 (long long) measure_clock_offset()
2722 );
2723 if (ret)
2724 goto end;
2725
2726 ret = lttng_metadata_printf(session,
2727 "typealias integer {\n"
2728 " size = 27; align = 1; signed = false;\n"
2729 " map = clock.%s.value;\n"
2730 "} := uint27_clock_monotonic_t;\n"
2731 "\n"
2732 "typealias integer {\n"
2733 " size = 32; align = %u; signed = false;\n"
2734 " map = clock.%s.value;\n"
2735 "} := uint32_clock_monotonic_t;\n"
2736 "\n"
2737 "typealias integer {\n"
2738 " size = 64; align = %u; signed = false;\n"
2739 " map = clock.%s.value;\n"
2740 "} := uint64_clock_monotonic_t;\n\n",
2741 trace_clock_name(),
2742 lttng_alignof(uint32_t) * CHAR_BIT,
2743 trace_clock_name(),
2744 lttng_alignof(uint64_t) * CHAR_BIT,
2745 trace_clock_name()
2746 );
2747 if (ret)
2748 goto end;
2749
2750 ret = _lttng_stream_packet_context_declare(session);
2751 if (ret)
2752 goto end;
2753
2754 ret = _lttng_event_header_declare(session);
2755 if (ret)
2756 goto end;
2757
2758 skip_session:
2759 list_for_each_entry(chan, &session->chan, list) {
2760 ret = _lttng_channel_metadata_statedump(session, chan);
2761 if (ret)
2762 goto end;
2763 }
2764
2765 list_for_each_entry(event, &session->events, list) {
2766 ret = _lttng_event_metadata_statedump(session, event->chan, event);
2767 if (ret)
2768 goto end;
2769 }
2770 session->metadata_dumped = 1;
2771 end:
2772 return ret;
2773 }
2774
2775 /**
2776 * lttng_transport_register - LTT transport registration
2777 * @transport: transport structure
2778 *
2779 * Registers a transport which can be used as output to extract the data out of
2780 * LTTng.
2781 */
2782 void lttng_transport_register(struct lttng_transport *transport)
2783 {
2784 mutex_lock(&sessions_mutex);
2785 list_add_tail(&transport->node, &lttng_transport_list);
2786 mutex_unlock(&sessions_mutex);
2787 }
2788 EXPORT_SYMBOL_GPL(lttng_transport_register);
2789
2790 /**
2791 * lttng_transport_unregister - LTT transport unregistration
2792 * @transport: transport structure
2793 */
2794 void lttng_transport_unregister(struct lttng_transport *transport)
2795 {
2796 mutex_lock(&sessions_mutex);
2797 list_del(&transport->node);
2798 mutex_unlock(&sessions_mutex);
2799 }
2800 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
2801
2802 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
2803
2804 enum cpuhp_state lttng_hp_prepare;
2805 enum cpuhp_state lttng_hp_online;
2806
2807 static int lttng_hotplug_prepare(unsigned int cpu, struct hlist_node *node)
2808 {
2809 struct lttng_cpuhp_node *lttng_node;
2810
2811 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
2812 switch (lttng_node->component) {
2813 case LTTNG_RING_BUFFER_FRONTEND:
2814 return 0;
2815 case LTTNG_RING_BUFFER_BACKEND:
2816 return lttng_cpuhp_rb_backend_prepare(cpu, lttng_node);
2817 case LTTNG_RING_BUFFER_ITER:
2818 return 0;
2819 case LTTNG_CONTEXT_PERF_COUNTERS:
2820 return 0;
2821 default:
2822 return -EINVAL;
2823 }
2824 }
2825
2826 static int lttng_hotplug_dead(unsigned int cpu, struct hlist_node *node)
2827 {
2828 struct lttng_cpuhp_node *lttng_node;
2829
2830 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
2831 switch (lttng_node->component) {
2832 case LTTNG_RING_BUFFER_FRONTEND:
2833 return lttng_cpuhp_rb_frontend_dead(cpu, lttng_node);
2834 case LTTNG_RING_BUFFER_BACKEND:
2835 return 0;
2836 case LTTNG_RING_BUFFER_ITER:
2837 return 0;
2838 case LTTNG_CONTEXT_PERF_COUNTERS:
2839 return lttng_cpuhp_perf_counter_dead(cpu, lttng_node);
2840 default:
2841 return -EINVAL;
2842 }
2843 }
2844
2845 static int lttng_hotplug_online(unsigned int cpu, struct hlist_node *node)
2846 {
2847 struct lttng_cpuhp_node *lttng_node;
2848
2849 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
2850 switch (lttng_node->component) {
2851 case LTTNG_RING_BUFFER_FRONTEND:
2852 return lttng_cpuhp_rb_frontend_online(cpu, lttng_node);
2853 case LTTNG_RING_BUFFER_BACKEND:
2854 return 0;
2855 case LTTNG_RING_BUFFER_ITER:
2856 return lttng_cpuhp_rb_iter_online(cpu, lttng_node);
2857 case LTTNG_CONTEXT_PERF_COUNTERS:
2858 return lttng_cpuhp_perf_counter_online(cpu, lttng_node);
2859 default:
2860 return -EINVAL;
2861 }
2862 }
2863
2864 static int lttng_hotplug_offline(unsigned int cpu, struct hlist_node *node)
2865 {
2866 struct lttng_cpuhp_node *lttng_node;
2867
2868 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
2869 switch (lttng_node->component) {
2870 case LTTNG_RING_BUFFER_FRONTEND:
2871 return lttng_cpuhp_rb_frontend_offline(cpu, lttng_node);
2872 case LTTNG_RING_BUFFER_BACKEND:
2873 return 0;
2874 case LTTNG_RING_BUFFER_ITER:
2875 return 0;
2876 case LTTNG_CONTEXT_PERF_COUNTERS:
2877 return 0;
2878 default:
2879 return -EINVAL;
2880 }
2881 }
2882
2883 static int __init lttng_init_cpu_hotplug(void)
2884 {
2885 int ret;
2886
2887 ret = cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN, "lttng:prepare",
2888 lttng_hotplug_prepare,
2889 lttng_hotplug_dead);
2890 if (ret < 0) {
2891 return ret;
2892 }
2893 lttng_hp_prepare = ret;
2894 lttng_rb_set_hp_prepare(ret);
2895
2896 ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "lttng:online",
2897 lttng_hotplug_online,
2898 lttng_hotplug_offline);
2899 if (ret < 0) {
2900 cpuhp_remove_multi_state(lttng_hp_prepare);
2901 lttng_hp_prepare = 0;
2902 return ret;
2903 }
2904 lttng_hp_online = ret;
2905 lttng_rb_set_hp_online(ret);
2906
2907 return 0;
2908 }
2909
2910 static void __exit lttng_exit_cpu_hotplug(void)
2911 {
2912 lttng_rb_set_hp_online(0);
2913 cpuhp_remove_multi_state(lttng_hp_online);
2914 lttng_rb_set_hp_prepare(0);
2915 cpuhp_remove_multi_state(lttng_hp_prepare);
2916 }
2917
2918 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
2919 static int lttng_init_cpu_hotplug(void)
2920 {
2921 return 0;
2922 }
2923 static void lttng_exit_cpu_hotplug(void)
2924 {
2925 }
2926 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
2927
2928
2929 static int __init lttng_events_init(void)
2930 {
2931 int ret;
2932
2933 ret = lttng_probes_init();
2934 if (ret)
2935 return ret;
2936 ret = lttng_context_init();
2937 if (ret)
2938 return ret;
2939 ret = lttng_tracepoint_init();
2940 if (ret)
2941 goto error_tp;
2942 event_cache = KMEM_CACHE(lttng_event, 0);
2943 if (!event_cache) {
2944 ret = -ENOMEM;
2945 goto error_kmem;
2946 }
2947 ret = lttng_abi_init();
2948 if (ret)
2949 goto error_abi;
2950 ret = lttng_logger_init();
2951 if (ret)
2952 goto error_logger;
2953 ret = lttng_init_cpu_hotplug();
2954 if (ret)
2955 goto error_hotplug;
2956 printk(KERN_NOTICE "LTTng: Loaded modules v%s.%s.%s%s (%s)%s%s\n",
2957 __stringify(LTTNG_MODULES_MAJOR_VERSION),
2958 __stringify(LTTNG_MODULES_MINOR_VERSION),
2959 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
2960 LTTNG_MODULES_EXTRAVERSION,
2961 LTTNG_VERSION_NAME,
2962 #ifdef LTTNG_EXTRA_VERSION_GIT
2963 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
2964 #else
2965 "",
2966 #endif
2967 #ifdef LTTNG_EXTRA_VERSION_NAME
2968 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
2969 #else
2970 "");
2971 #endif
2972 return 0;
2973
2974 error_hotplug:
2975 lttng_logger_exit();
2976 error_logger:
2977 lttng_abi_exit();
2978 error_abi:
2979 kmem_cache_destroy(event_cache);
2980 error_kmem:
2981 lttng_tracepoint_exit();
2982 error_tp:
2983 lttng_context_exit();
2984 printk(KERN_NOTICE "LTTng: Failed to load modules v%s.%s.%s%s (%s)%s%s\n",
2985 __stringify(LTTNG_MODULES_MAJOR_VERSION),
2986 __stringify(LTTNG_MODULES_MINOR_VERSION),
2987 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
2988 LTTNG_MODULES_EXTRAVERSION,
2989 LTTNG_VERSION_NAME,
2990 #ifdef LTTNG_EXTRA_VERSION_GIT
2991 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
2992 #else
2993 "",
2994 #endif
2995 #ifdef LTTNG_EXTRA_VERSION_NAME
2996 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
2997 #else
2998 "");
2999 #endif
3000 return ret;
3001 }
3002
3003 module_init(lttng_events_init);
3004
3005 static void __exit lttng_events_exit(void)
3006 {
3007 struct lttng_session *session, *tmpsession;
3008
3009 lttng_exit_cpu_hotplug();
3010 lttng_logger_exit();
3011 lttng_abi_exit();
3012 list_for_each_entry_safe(session, tmpsession, &sessions, list)
3013 lttng_session_destroy(session);
3014 kmem_cache_destroy(event_cache);
3015 lttng_tracepoint_exit();
3016 lttng_context_exit();
3017 printk(KERN_NOTICE "LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",
3018 __stringify(LTTNG_MODULES_MAJOR_VERSION),
3019 __stringify(LTTNG_MODULES_MINOR_VERSION),
3020 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
3021 LTTNG_MODULES_EXTRAVERSION,
3022 LTTNG_VERSION_NAME,
3023 #ifdef LTTNG_EXTRA_VERSION_GIT
3024 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
3025 #else
3026 "",
3027 #endif
3028 #ifdef LTTNG_EXTRA_VERSION_NAME
3029 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
3030 #else
3031 "");
3032 #endif
3033 }
3034
3035 module_exit(lttng_events_exit);
3036
3037 #include "extra_version/patches.i"
3038 #ifdef LTTNG_EXTRA_VERSION_GIT
3039 MODULE_INFO(extra_version_git, LTTNG_EXTRA_VERSION_GIT);
3040 #endif
3041 #ifdef LTTNG_EXTRA_VERSION_NAME
3042 MODULE_INFO(extra_version_name, LTTNG_EXTRA_VERSION_NAME);
3043 #endif
3044 MODULE_LICENSE("GPL and additional rights");
3045 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
3046 MODULE_DESCRIPTION("LTTng tracer");
3047 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
3048 __stringify(LTTNG_MODULES_MINOR_VERSION) "."
3049 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
3050 LTTNG_MODULES_EXTRAVERSION);
LTTng 2.0/0.x modules
This page took 0.143492 seconds and 4 git commands to generate.