1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
5 * Holds LTTng per-session event registry.
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
11 * This page_alloc.h wrapper needs to be included before gfpflags.h because it
12 * overrides a function with a define.
14 #include "wrapper/page_alloc.h"
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/sched.h>
19 #include <linux/slab.h>
20 #include <linux/jiffies.h>
21 #include <linux/utsname.h>
22 #include <linux/err.h>
23 #include <linux/seq_file.h>
24 #include <linux/file.h>
25 #include <linux/anon_inodes.h>
26 #include <wrapper/file.h>
27 #include <linux/uaccess.h>
28 #include <linux/vmalloc.h>
29 #include <linux/dmi.h>
31 #include <wrapper/compiler_attributes.h>
32 #include <wrapper/uuid.h>
33 #include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
34 #include <wrapper/random.h>
35 #include <wrapper/tracepoint.h>
36 #include <wrapper/list.h>
37 #include <wrapper/types.h>
38 #include <lttng/kernel-version.h>
39 #include <lttng/events.h>
40 #include <lttng/events-internal.h>
41 #include <lttng/lttng-bytecode.h>
42 #include <lttng/tracer.h>
43 #include <lttng/event-notifier-notification.h>
44 #include <lttng/abi-old.h>
45 #include <lttng/endian.h>
46 #include <lttng/string-utils.h>
47 #include <lttng/utils.h>
48 #include <ringbuffer/backend.h>
49 #include <ringbuffer/frontend.h>
50 #include <wrapper/time.h>
52 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0))
53 #include <linux/stdarg.h>
58 #define METADATA_CACHE_DEFAULT_SIZE 4096
60 static LIST_HEAD(sessions
);
61 static LIST_HEAD(event_notifier_groups
);
62 static LIST_HEAD(lttng_transport_list
);
63 static LIST_HEAD(lttng_counter_transport_list
);
65 * Protect the sessions and metadata caches.
67 static DEFINE_MUTEX(sessions_mutex
);
68 static struct kmem_cache
*event_recorder_cache
;
69 static struct kmem_cache
*event_recorder_private_cache
;
70 static struct kmem_cache
*event_notifier_cache
;
71 static struct kmem_cache
*event_notifier_private_cache
;
73 static void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session
*session
);
74 static void lttng_session_sync_event_enablers(struct lttng_kernel_session
*session
);
75 static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
*event_notifier_group
);
76 static void lttng_event_enabler_sync(struct lttng_event_enabler_common
*event_enabler
);
78 static void _lttng_event_destroy(struct lttng_kernel_event_common
*event
);
79 static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer
*chan
);
80 static void _lttng_event_unregister(struct lttng_kernel_event_common
*event
);
82 int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common
*event
);
84 int _lttng_session_metadata_statedump(struct lttng_kernel_session
*session
);
86 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream
*stream
);
88 int _lttng_type_statedump(struct lttng_kernel_session
*session
,
89 const struct lttng_kernel_type_common
*type
,
90 enum lttng_kernel_string_encoding parent_encoding
,
93 int _lttng_field_statedump(struct lttng_kernel_session
*session
,
94 const struct lttng_kernel_event_field
*field
,
95 size_t nesting
, const char **prev_field_name_p
);
97 void synchronize_trace(void)
99 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) || \
100 LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
106 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
107 #ifdef CONFIG_PREEMPT_RT_FULL
110 #else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
111 #ifdef CONFIG_PREEMPT_RT
114 #endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
117 void lttng_lock_sessions(void)
119 mutex_lock(&sessions_mutex
);
122 void lttng_unlock_sessions(void)
124 mutex_unlock(&sessions_mutex
);
127 static struct lttng_transport
*lttng_transport_find(const char *name
)
129 struct lttng_transport
*transport
;
131 list_for_each_entry(transport
, <tng_transport_list
, node
) {
132 if (!strcmp(transport
->name
, name
))
139 * Called with sessions lock held.
141 int lttng_session_active(void)
143 struct lttng_kernel_session_private
*iter
;
145 list_for_each_entry(iter
, &sessions
, list
) {
146 if (iter
->pub
->active
)
152 struct lttng_kernel_session
*lttng_session_create(void)
154 struct lttng_kernel_session
*session
;
155 struct lttng_kernel_session_private
*session_priv
;
156 struct lttng_metadata_cache
*metadata_cache
;
159 mutex_lock(&sessions_mutex
);
160 session
= lttng_kvzalloc(sizeof(*session
), GFP_KERNEL
);
163 session_priv
= lttng_kvzalloc(sizeof(*session_priv
), GFP_KERNEL
);
165 goto err_free_session
;
166 session
->priv
= session_priv
;
167 session_priv
->pub
= session
;
169 INIT_LIST_HEAD(&session_priv
->chan
);
170 INIT_LIST_HEAD(&session_priv
->events
);
171 lttng_guid_gen(&session_priv
->uuid
);
173 metadata_cache
= kzalloc(sizeof(struct lttng_metadata_cache
),
176 goto err_free_session_private
;
177 metadata_cache
->data
= vzalloc(METADATA_CACHE_DEFAULT_SIZE
);
178 if (!metadata_cache
->data
)
180 metadata_cache
->cache_alloc
= METADATA_CACHE_DEFAULT_SIZE
;
181 kref_init(&metadata_cache
->refcount
);
182 mutex_init(&metadata_cache
->lock
);
183 session_priv
->metadata_cache
= metadata_cache
;
184 INIT_LIST_HEAD(&metadata_cache
->metadata_stream
);
185 memcpy(&metadata_cache
->uuid
, &session_priv
->uuid
,
186 sizeof(metadata_cache
->uuid
));
187 INIT_LIST_HEAD(&session_priv
->enablers_head
);
188 for (i
= 0; i
< LTTNG_EVENT_HT_SIZE
; i
++)
189 INIT_HLIST_HEAD(&session_priv
->events_ht
.table
[i
]);
190 list_add(&session_priv
->list
, &sessions
);
192 if (lttng_id_tracker_init(&session
->pid_tracker
, session
, TRACKER_PID
))
193 goto tracker_alloc_error
;
194 if (lttng_id_tracker_init(&session
->vpid_tracker
, session
, TRACKER_VPID
))
195 goto tracker_alloc_error
;
196 if (lttng_id_tracker_init(&session
->uid_tracker
, session
, TRACKER_UID
))
197 goto tracker_alloc_error
;
198 if (lttng_id_tracker_init(&session
->vuid_tracker
, session
, TRACKER_VUID
))
199 goto tracker_alloc_error
;
200 if (lttng_id_tracker_init(&session
->gid_tracker
, session
, TRACKER_GID
))
201 goto tracker_alloc_error
;
202 if (lttng_id_tracker_init(&session
->vgid_tracker
, session
, TRACKER_VGID
))
203 goto tracker_alloc_error
;
205 mutex_unlock(&sessions_mutex
);
210 lttng_id_tracker_fini(&session
->pid_tracker
);
211 lttng_id_tracker_fini(&session
->vpid_tracker
);
212 lttng_id_tracker_fini(&session
->uid_tracker
);
213 lttng_id_tracker_fini(&session
->vuid_tracker
);
214 lttng_id_tracker_fini(&session
->gid_tracker
);
215 lttng_id_tracker_fini(&session
->vgid_tracker
);
217 kfree(metadata_cache
);
218 err_free_session_private
:
219 lttng_kvfree(session_priv
);
221 lttng_kvfree(session
);
223 mutex_unlock(&sessions_mutex
);
228 struct lttng_counter_transport
*lttng_counter_transport_find(const char *name
)
230 struct lttng_counter_transport
*transport
;
232 list_for_each_entry(transport
, <tng_counter_transport_list
, node
) {
233 if (!strcmp(transport
->name
, name
))
239 struct lttng_counter
*lttng_kernel_counter_create(
240 const char *counter_transport_name
,
241 size_t number_dimensions
, const size_t *dimensions_sizes
)
243 struct lttng_counter
*counter
= NULL
;
244 struct lttng_counter_transport
*counter_transport
= NULL
;
246 counter_transport
= lttng_counter_transport_find(counter_transport_name
);
247 if (!counter_transport
) {
248 printk(KERN_WARNING
"LTTng: counter transport %s not found.\n",
249 counter_transport_name
);
252 if (!try_module_get(counter_transport
->owner
)) {
253 printk(KERN_WARNING
"LTTng: Can't lock counter transport module.\n");
257 counter
= lttng_kvzalloc(sizeof(struct lttng_counter
), GFP_KERNEL
);
261 /* Create event notifier error counter. */
262 counter
->ops
= &counter_transport
->ops
;
263 counter
->transport
= counter_transport
;
265 counter
->counter
= counter
->ops
->counter_create(
266 number_dimensions
, dimensions_sizes
, 0);
267 if (!counter
->counter
) {
274 lttng_kvfree(counter
);
276 if (counter_transport
)
277 module_put(counter_transport
->owner
);
282 struct lttng_event_notifier_group
*lttng_event_notifier_group_create(void)
284 struct lttng_transport
*transport
= NULL
;
285 struct lttng_event_notifier_group
*event_notifier_group
;
286 const char *transport_name
= "relay-event-notifier";
287 size_t subbuf_size
= 4096; //TODO
288 size_t num_subbuf
= 16; //TODO
289 unsigned int switch_timer_interval
= 0;
290 unsigned int read_timer_interval
= 0;
293 mutex_lock(&sessions_mutex
);
295 transport
= lttng_transport_find(transport_name
);
297 printk(KERN_WARNING
"LTTng: transport %s not found\n",
301 if (!try_module_get(transport
->owner
)) {
302 printk(KERN_WARNING
"LTTng: Can't lock transport %s module.\n",
307 event_notifier_group
= lttng_kvzalloc(sizeof(struct lttng_event_notifier_group
),
309 if (!event_notifier_group
)
313 * Initialize the ring buffer used to store event notifier
316 event_notifier_group
->ops
= &transport
->ops
;
317 event_notifier_group
->chan
= transport
->ops
.priv
->channel_create(
318 transport_name
, event_notifier_group
, NULL
,
319 subbuf_size
, num_subbuf
, switch_timer_interval
,
320 read_timer_interval
);
321 if (!event_notifier_group
->chan
)
324 event_notifier_group
->transport
= transport
;
326 INIT_LIST_HEAD(&event_notifier_group
->enablers_head
);
327 INIT_LIST_HEAD(&event_notifier_group
->event_notifiers_head
);
328 for (i
= 0; i
< LTTNG_EVENT_HT_SIZE
; i
++)
329 INIT_HLIST_HEAD(&event_notifier_group
->events_ht
.table
[i
]);
331 list_add(&event_notifier_group
->node
, &event_notifier_groups
);
333 mutex_unlock(&sessions_mutex
);
335 return event_notifier_group
;
338 lttng_kvfree(event_notifier_group
);
341 module_put(transport
->owner
);
343 mutex_unlock(&sessions_mutex
);
347 void metadata_cache_destroy(struct kref
*kref
)
349 struct lttng_metadata_cache
*cache
=
350 container_of(kref
, struct lttng_metadata_cache
, refcount
);
355 void lttng_session_destroy(struct lttng_kernel_session
*session
)
357 struct lttng_kernel_channel_buffer_private
*chan_priv
, *tmpchan_priv
;
358 struct lttng_kernel_event_recorder_private
*event_recorder_priv
, *tmpevent_recorder_priv
;
359 struct lttng_metadata_stream
*metadata_stream
;
360 struct lttng_event_enabler_common
*event_enabler
, *tmp_event_enabler
;
363 mutex_lock(&sessions_mutex
);
364 WRITE_ONCE(session
->active
, 0);
365 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
366 ret
= lttng_syscalls_unregister_syscall_table(&chan_priv
->parent
.syscall_table
);
369 list_for_each_entry(event_recorder_priv
, &session
->priv
->events
, parent
.node
)
370 _lttng_event_unregister(&event_recorder_priv
->pub
->parent
);
371 synchronize_trace(); /* Wait for in-flight events to complete */
372 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
373 ret
= lttng_syscalls_destroy_syscall_table(&chan_priv
->parent
.syscall_table
);
376 list_for_each_entry_safe(event_enabler
, tmp_event_enabler
, &session
->priv
->enablers_head
, node
)
377 lttng_event_enabler_destroy(event_enabler
);
378 list_for_each_entry_safe(event_recorder_priv
, tmpevent_recorder_priv
, &session
->priv
->events
, parent
.node
)
379 _lttng_event_destroy(&event_recorder_priv
->pub
->parent
);
380 list_for_each_entry_safe(chan_priv
, tmpchan_priv
, &session
->priv
->chan
, node
) {
381 BUG_ON(chan_priv
->channel_type
== METADATA_CHANNEL
);
382 _lttng_channel_destroy(chan_priv
->pub
);
384 mutex_lock(&session
->priv
->metadata_cache
->lock
);
385 list_for_each_entry(metadata_stream
, &session
->priv
->metadata_cache
->metadata_stream
, list
)
386 _lttng_metadata_channel_hangup(metadata_stream
);
387 mutex_unlock(&session
->priv
->metadata_cache
->lock
);
388 lttng_id_tracker_fini(&session
->pid_tracker
);
389 lttng_id_tracker_fini(&session
->vpid_tracker
);
390 lttng_id_tracker_fini(&session
->uid_tracker
);
391 lttng_id_tracker_fini(&session
->vuid_tracker
);
392 lttng_id_tracker_fini(&session
->gid_tracker
);
393 lttng_id_tracker_fini(&session
->vgid_tracker
);
394 kref_put(&session
->priv
->metadata_cache
->refcount
, metadata_cache_destroy
);
395 list_del(&session
->priv
->list
);
396 mutex_unlock(&sessions_mutex
);
397 lttng_kvfree(session
->priv
);
398 lttng_kvfree(session
);
401 void lttng_event_notifier_group_destroy(
402 struct lttng_event_notifier_group
*event_notifier_group
)
404 struct lttng_event_enabler_common
*event_enabler
, *tmp_event_enabler
;
405 struct lttng_kernel_event_notifier_private
*event_notifier_priv
, *tmpevent_notifier_priv
;
408 if (!event_notifier_group
)
411 mutex_lock(&sessions_mutex
);
413 ret
= lttng_syscalls_unregister_syscall_table(&event_notifier_group
->syscall_table
);
416 list_for_each_entry_safe(event_notifier_priv
, tmpevent_notifier_priv
,
417 &event_notifier_group
->event_notifiers_head
, parent
.node
)
418 _lttng_event_unregister(&event_notifier_priv
->pub
->parent
);
420 /* Wait for in-flight event notifier to complete */
423 irq_work_sync(&event_notifier_group
->wakeup_pending
);
425 ret
= lttng_syscalls_destroy_syscall_table(&event_notifier_group
->syscall_table
);
428 list_for_each_entry_safe(event_enabler
, tmp_event_enabler
,
429 &event_notifier_group
->enablers_head
, node
)
430 lttng_event_enabler_destroy(event_enabler
);
432 list_for_each_entry_safe(event_notifier_priv
, tmpevent_notifier_priv
,
433 &event_notifier_group
->event_notifiers_head
, parent
.node
)
434 _lttng_event_destroy(&event_notifier_priv
->pub
->parent
);
436 if (event_notifier_group
->error_counter
) {
437 struct lttng_counter
*error_counter
= event_notifier_group
->error_counter
;
439 error_counter
->ops
->counter_destroy(error_counter
->counter
);
440 module_put(error_counter
->transport
->owner
);
441 lttng_kvfree(error_counter
);
442 event_notifier_group
->error_counter
= NULL
;
445 event_notifier_group
->ops
->priv
->channel_destroy(event_notifier_group
->chan
);
446 module_put(event_notifier_group
->transport
->owner
);
447 list_del(&event_notifier_group
->node
);
449 mutex_unlock(&sessions_mutex
);
450 lttng_kvfree(event_notifier_group
);
453 int lttng_session_statedump(struct lttng_kernel_session
*session
)
457 mutex_lock(&sessions_mutex
);
458 ret
= lttng_statedump_start(session
);
459 mutex_unlock(&sessions_mutex
);
463 int lttng_session_enable(struct lttng_kernel_session
*session
)
466 struct lttng_kernel_channel_buffer_private
*chan_priv
;
468 mutex_lock(&sessions_mutex
);
469 if (session
->active
) {
474 /* Set transient enabler state to "enabled" */
475 session
->priv
->tstate
= 1;
477 /* We need to sync enablers with session before activation. */
478 lttng_session_sync_event_enablers(session
);
481 * Snapshot the number of events per channel to know the type of header
484 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
485 if (chan_priv
->header_type
)
486 continue; /* don't change it if session stop/restart */
487 if (chan_priv
->free_event_id
< 31)
488 chan_priv
->header_type
= 1; /* compact */
490 chan_priv
->header_type
= 2; /* large */
493 /* Clear each stream's quiescent state. */
494 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
495 if (chan_priv
->channel_type
!= METADATA_CHANNEL
)
496 lib_ring_buffer_clear_quiescent_channel(chan_priv
->rb_chan
);
499 WRITE_ONCE(session
->active
, 1);
500 WRITE_ONCE(session
->priv
->been_active
, 1);
501 ret
= _lttng_session_metadata_statedump(session
);
503 WRITE_ONCE(session
->active
, 0);
506 ret
= lttng_statedump_start(session
);
508 WRITE_ONCE(session
->active
, 0);
510 mutex_unlock(&sessions_mutex
);
514 int lttng_session_disable(struct lttng_kernel_session
*session
)
517 struct lttng_kernel_channel_buffer_private
*chan_priv
;
519 mutex_lock(&sessions_mutex
);
520 if (!session
->active
) {
524 WRITE_ONCE(session
->active
, 0);
526 /* Set transient enabler state to "disabled" */
527 session
->priv
->tstate
= 0;
528 lttng_session_sync_event_enablers(session
);
530 /* Set each stream's quiescent state. */
531 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
532 if (chan_priv
->channel_type
!= METADATA_CHANNEL
)
533 lib_ring_buffer_set_quiescent_channel(chan_priv
->rb_chan
);
536 mutex_unlock(&sessions_mutex
);
540 int lttng_session_metadata_regenerate(struct lttng_kernel_session
*session
)
543 struct lttng_kernel_channel_buffer_private
*chan_priv
;
544 struct lttng_kernel_event_recorder_private
*event_recorder_priv
;
545 struct lttng_metadata_cache
*cache
= session
->priv
->metadata_cache
;
546 struct lttng_metadata_stream
*stream
;
548 mutex_lock(&sessions_mutex
);
549 if (!session
->active
) {
554 mutex_lock(&cache
->lock
);
555 memset(cache
->data
, 0, cache
->cache_alloc
);
556 cache
->metadata_written
= 0;
558 list_for_each_entry(stream
, &session
->priv
->metadata_cache
->metadata_stream
, list
) {
559 stream
->metadata_out
= 0;
560 stream
->metadata_in
= 0;
562 mutex_unlock(&cache
->lock
);
564 session
->priv
->metadata_dumped
= 0;
565 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
566 chan_priv
->metadata_dumped
= 0;
569 list_for_each_entry(event_recorder_priv
, &session
->priv
->events
, parent
.node
) {
570 event_recorder_priv
->metadata_dumped
= 0;
573 ret
= _lttng_session_metadata_statedump(session
);
576 mutex_unlock(&sessions_mutex
);
581 bool is_channel_buffer_metadata(struct lttng_kernel_channel_common
*channel
)
583 struct lttng_kernel_channel_buffer
*chan_buf
;
585 if (channel
->type
!= LTTNG_KERNEL_CHANNEL_TYPE_BUFFER
)
587 chan_buf
= container_of(channel
, struct lttng_kernel_channel_buffer
, parent
);
588 if (chan_buf
->priv
->channel_type
== METADATA_CHANNEL
)
593 int lttng_channel_enable(struct lttng_kernel_channel_common
*channel
)
597 mutex_lock(&sessions_mutex
);
598 if (is_channel_buffer_metadata(channel
)) {
602 if (channel
->enabled
) {
606 /* Set transient enabler state to "enabled" */
607 channel
->priv
->tstate
= 1;
608 lttng_session_sync_event_enablers(channel
->session
);
609 /* Set atomically the state to "enabled" */
610 WRITE_ONCE(channel
->enabled
, 1);
612 mutex_unlock(&sessions_mutex
);
616 int lttng_channel_disable(struct lttng_kernel_channel_common
*channel
)
620 mutex_lock(&sessions_mutex
);
621 if (is_channel_buffer_metadata(channel
)) {
625 if (!channel
->enabled
) {
629 /* Set atomically the state to "disabled" */
630 WRITE_ONCE(channel
->enabled
, 0);
631 /* Set transient enabler state to "enabled" */
632 channel
->priv
->tstate
= 0;
633 lttng_session_sync_event_enablers(channel
->session
);
635 mutex_unlock(&sessions_mutex
);
639 int lttng_event_enable(struct lttng_kernel_event_common
*event
)
643 mutex_lock(&sessions_mutex
);
644 switch (event
->type
) {
645 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
647 struct lttng_kernel_event_recorder
*event_recorder
=
648 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
650 if (event_recorder
->chan
->priv
->channel_type
== METADATA_CHANNEL
) {
656 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
657 switch (event
->priv
->instrumentation
) {
658 case LTTNG_KERNEL_ABI_KRETPROBE
:
669 if (event
->enabled
) {
673 switch (event
->priv
->instrumentation
) {
674 case LTTNG_KERNEL_ABI_TRACEPOINT
:
676 case LTTNG_KERNEL_ABI_SYSCALL
:
680 case LTTNG_KERNEL_ABI_KPROBE
:
682 case LTTNG_KERNEL_ABI_UPROBE
:
683 WRITE_ONCE(event
->enabled
, 1);
686 case LTTNG_KERNEL_ABI_KRETPROBE
:
687 ret
= lttng_kretprobes_event_enable_state(event
, 1);
690 case LTTNG_KERNEL_ABI_FUNCTION
:
692 case LTTNG_KERNEL_ABI_NOOP
:
699 mutex_unlock(&sessions_mutex
);
703 int lttng_event_disable(struct lttng_kernel_event_common
*event
)
707 mutex_lock(&sessions_mutex
);
708 switch (event
->type
) {
709 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
711 struct lttng_kernel_event_recorder
*event_recorder
=
712 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
714 if (event_recorder
->chan
->priv
->channel_type
== METADATA_CHANNEL
) {
720 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
721 switch (event
->priv
->instrumentation
) {
722 case LTTNG_KERNEL_ABI_KRETPROBE
:
733 if (!event
->enabled
) {
737 switch (event
->priv
->instrumentation
) {
738 case LTTNG_KERNEL_ABI_TRACEPOINT
:
740 case LTTNG_KERNEL_ABI_SYSCALL
:
744 case LTTNG_KERNEL_ABI_KPROBE
:
746 case LTTNG_KERNEL_ABI_UPROBE
:
747 WRITE_ONCE(event
->enabled
, 0);
750 case LTTNG_KERNEL_ABI_KRETPROBE
:
751 ret
= lttng_kretprobes_event_enable_state(event
, 0);
754 case LTTNG_KERNEL_ABI_FUNCTION
:
756 case LTTNG_KERNEL_ABI_NOOP
:
763 mutex_unlock(&sessions_mutex
);
767 struct lttng_kernel_channel_buffer
*lttng_channel_buffer_create(struct lttng_kernel_session
*session
,
768 const char *transport_name
,
770 size_t subbuf_size
, size_t num_subbuf
,
771 unsigned int switch_timer_interval
,
772 unsigned int read_timer_interval
,
773 enum channel_type channel_type
)
775 struct lttng_kernel_channel_buffer
*chan
;
776 struct lttng_kernel_channel_buffer_private
*chan_priv
;
777 struct lttng_transport
*transport
= NULL
;
779 mutex_lock(&sessions_mutex
);
780 if (session
->priv
->been_active
&& channel_type
!= METADATA_CHANNEL
)
781 goto active
; /* Refuse to add channel to active session */
782 transport
= lttng_transport_find(transport_name
);
784 printk(KERN_WARNING
"LTTng: transport %s not found\n",
788 if (!try_module_get(transport
->owner
)) {
789 printk(KERN_WARNING
"LTTng: Can't lock transport module.\n");
792 chan
= kzalloc(sizeof(struct lttng_kernel_channel_buffer
), GFP_KERNEL
);
795 chan_priv
= kzalloc(sizeof(struct lttng_kernel_channel_buffer_private
), GFP_KERNEL
);
798 chan
->priv
= chan_priv
;
799 chan_priv
->pub
= chan
;
800 chan
->parent
.type
= LTTNG_KERNEL_CHANNEL_TYPE_BUFFER
;
801 chan
->parent
.session
= session
;
802 chan
->priv
->id
= session
->priv
->free_chan_id
++;
803 chan
->ops
= &transport
->ops
;
805 * Note: the channel creation op already writes into the packet
806 * headers. Therefore the "chan" information used as input
807 * should be already accessible.
809 chan
->priv
->rb_chan
= transport
->ops
.priv
->channel_create(transport_name
,
810 chan
, buf_addr
, subbuf_size
, num_subbuf
,
811 switch_timer_interval
, read_timer_interval
);
812 if (!chan
->priv
->rb_chan
)
814 chan
->priv
->parent
.tstate
= 1;
815 chan
->parent
.enabled
= 1;
816 chan
->priv
->transport
= transport
;
817 chan
->priv
->channel_type
= channel_type
;
818 list_add(&chan
->priv
->node
, &session
->priv
->chan
);
819 mutex_unlock(&sessions_mutex
);
828 module_put(transport
->owner
);
831 mutex_unlock(&sessions_mutex
);
836 * Only used internally at session destruction for per-cpu channels, and
837 * when metadata channel is released.
838 * Needs to be called with sessions mutex held.
841 void _lttng_channel_destroy(struct lttng_kernel_channel_buffer
*chan
)
843 chan
->ops
->priv
->channel_destroy(chan
->priv
->rb_chan
);
844 module_put(chan
->priv
->transport
->owner
);
845 list_del(&chan
->priv
->node
);
846 lttng_kernel_destroy_context(chan
->priv
->ctx
);
851 void lttng_metadata_channel_destroy(struct lttng_kernel_channel_buffer
*chan
)
853 BUG_ON(chan
->priv
->channel_type
!= METADATA_CHANNEL
);
855 /* Protect the metadata cache with the sessions_mutex. */
856 mutex_lock(&sessions_mutex
);
857 _lttng_channel_destroy(chan
);
858 mutex_unlock(&sessions_mutex
);
860 EXPORT_SYMBOL_GPL(lttng_metadata_channel_destroy
);
863 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream
*stream
)
865 stream
->finalized
= 1;
866 wake_up_interruptible(&stream
->read_wait
);
870 bool lttng_kernel_event_id_available(struct lttng_event_enabler_common
*event_enabler
)
872 struct lttng_kernel_abi_event
*event_param
= &event_enabler
->event_param
;
873 enum lttng_kernel_abi_instrumentation itype
= event_param
->instrumentation
;
875 switch (event_enabler
->enabler_type
) {
876 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
878 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
879 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
880 struct lttng_kernel_channel_buffer
*chan
= event_recorder_enabler
->chan
;
883 case LTTNG_KERNEL_ABI_TRACEPOINT
:
885 case LTTNG_KERNEL_ABI_KPROBE
:
887 case LTTNG_KERNEL_ABI_SYSCALL
:
889 case LTTNG_KERNEL_ABI_UPROBE
:
890 if (chan
->priv
->free_event_id
== -1U)
893 case LTTNG_KERNEL_ABI_KRETPROBE
:
894 /* kretprobes require 2 event IDs. */
895 if (chan
->priv
->free_event_id
>= -2U)
903 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
912 struct lttng_kernel_event_common
*lttng_kernel_event_alloc(struct lttng_event_enabler_common
*event_enabler
)
914 struct lttng_kernel_abi_event
*event_param
= &event_enabler
->event_param
;
915 enum lttng_kernel_abi_instrumentation itype
= event_param
->instrumentation
;
917 switch (event_enabler
->enabler_type
) {
918 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
920 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
921 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
922 struct lttng_kernel_event_recorder
*event_recorder
;
923 struct lttng_kernel_event_recorder_private
*event_recorder_priv
;
924 struct lttng_kernel_channel_buffer
*chan
= event_recorder_enabler
->chan
;
926 event_recorder
= kmem_cache_zalloc(event_recorder_cache
, GFP_KERNEL
);
929 event_recorder_priv
= kmem_cache_zalloc(event_recorder_private_cache
, GFP_KERNEL
);
930 if (!event_recorder_priv
) {
931 kmem_cache_free(event_recorder_private_cache
, event_recorder
);
934 event_recorder_priv
->pub
= event_recorder
;
935 event_recorder_priv
->parent
.pub
= &event_recorder
->parent
;
936 event_recorder
->priv
= event_recorder_priv
;
937 event_recorder
->parent
.priv
= &event_recorder_priv
->parent
;
939 event_recorder
->parent
.type
= LTTNG_KERNEL_EVENT_TYPE_RECORDER
;
940 event_recorder
->parent
.run_filter
= lttng_kernel_interpret_event_filter
;
941 event_recorder
->priv
->parent
.instrumentation
= itype
;
942 INIT_LIST_HEAD(&event_recorder
->priv
->parent
.filter_bytecode_runtime_head
);
943 INIT_LIST_HEAD(&event_recorder
->priv
->parent
.enablers_ref_head
);
945 event_recorder
->chan
= chan
;
946 event_recorder
->priv
->id
= chan
->priv
->free_event_id
++;
947 return &event_recorder
->parent
;
949 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
951 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
952 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
953 struct lttng_kernel_event_notifier
*event_notifier
;
954 struct lttng_kernel_event_notifier_private
*event_notifier_priv
;
956 event_notifier
= kmem_cache_zalloc(event_notifier_cache
, GFP_KERNEL
);
959 event_notifier_priv
= kmem_cache_zalloc(event_notifier_private_cache
, GFP_KERNEL
);
960 if (!event_notifier_priv
) {
961 kmem_cache_free(event_notifier_private_cache
, event_notifier
);
964 event_notifier_priv
->pub
= event_notifier
;
965 event_notifier_priv
->parent
.pub
= &event_notifier
->parent
;
966 event_notifier
->priv
= event_notifier_priv
;
967 event_notifier
->parent
.priv
= &event_notifier_priv
->parent
;
969 event_notifier
->parent
.type
= LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
;
970 event_notifier
->parent
.run_filter
= lttng_kernel_interpret_event_filter
;
971 event_notifier
->priv
->parent
.instrumentation
= itype
;
972 event_notifier
->priv
->parent
.user_token
= event_enabler
->user_token
;
973 INIT_LIST_HEAD(&event_notifier
->priv
->parent
.filter_bytecode_runtime_head
);
974 INIT_LIST_HEAD(&event_notifier
->priv
->parent
.enablers_ref_head
);
976 event_notifier
->priv
->group
= event_notifier_enabler
->group
;
977 event_notifier
->priv
->error_counter_index
= event_notifier_enabler
->error_counter_index
;
978 event_notifier
->priv
->num_captures
= 0;
979 event_notifier
->notification_send
= lttng_event_notifier_notification_send
;
980 INIT_LIST_HEAD(&event_notifier
->priv
->capture_bytecode_runtime_head
);
981 return &event_notifier
->parent
;
989 void lttng_kernel_event_free(struct lttng_kernel_event_common
*event
)
991 switch (event
->type
) {
992 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
994 struct lttng_kernel_event_recorder
*event_recorder
=
995 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
997 kmem_cache_free(event_recorder_private_cache
, event_recorder
->priv
);
998 kmem_cache_free(event_recorder_cache
, event_recorder
);
1001 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1003 struct lttng_kernel_event_notifier
*event_notifier
=
1004 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
1006 kmem_cache_free(event_notifier_private_cache
, event_notifier
->priv
);
1007 kmem_cache_free(event_notifier_cache
, event_notifier
);
1016 int lttng_kernel_event_notifier_clear_error_counter(struct lttng_kernel_event_common
*event
)
1018 switch (event
->type
) {
1019 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1021 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1023 struct lttng_kernel_event_notifier
*event_notifier
=
1024 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
1025 struct lttng_counter
*error_counter
;
1026 struct lttng_event_notifier_group
*event_notifier_group
= event_notifier
->priv
->group
;
1027 size_t dimension_index
[1];
1031 * Clear the error counter bucket. The sessiond keeps track of which
1032 * bucket is currently in use. We trust it. The session lock
1033 * synchronizes against concurrent creation of the error
1036 error_counter
= event_notifier_group
->error_counter
;
1040 * Check that the index is within the boundary of the counter.
1042 if (event_notifier
->priv
->error_counter_index
>= event_notifier_group
->error_counter_len
) {
1043 printk(KERN_INFO
"LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
1044 event_notifier_group
->error_counter_len
, event_notifier
->priv
->error_counter_index
);
1048 dimension_index
[0] = event_notifier
->priv
->error_counter_index
;
1049 ret
= error_counter
->ops
->counter_clear(error_counter
->counter
, dimension_index
);
1051 printk(KERN_INFO
"LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
1052 event_notifier
->priv
->error_counter_index
);
1063 * Supports event creation while tracing session is active.
1064 * Needs to be called with sessions mutex held.
1066 struct lttng_kernel_event_common
*_lttng_kernel_event_create(struct lttng_event_enabler_common
*event_enabler
,
1067 const struct lttng_kernel_event_desc
*event_desc
)
1069 struct lttng_event_ht
*events_ht
= lttng_get_event_ht_from_enabler(event_enabler
);
1070 struct list_head
*event_list_head
= lttng_get_event_list_head_from_enabler(event_enabler
);
1071 struct lttng_kernel_abi_event
*event_param
= &event_enabler
->event_param
;
1072 enum lttng_kernel_abi_instrumentation itype
= event_param
->instrumentation
;
1073 struct lttng_kernel_event_common_private
*event_priv
;
1074 struct lttng_kernel_event_common
*event
;
1075 const char *event_name
;
1076 struct hlist_head
*head
;
1079 if (!lttng_kernel_event_id_available(event_enabler
)) {
1085 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1086 event_name
= event_desc
->event_name
;
1089 case LTTNG_KERNEL_ABI_KPROBE
:
1091 case LTTNG_KERNEL_ABI_UPROBE
:
1093 case LTTNG_KERNEL_ABI_KRETPROBE
:
1095 case LTTNG_KERNEL_ABI_SYSCALL
:
1096 event_name
= event_param
->name
;
1099 case LTTNG_KERNEL_ABI_FUNCTION
:
1101 case LTTNG_KERNEL_ABI_NOOP
:
1109 head
= utils_borrow_hash_table_bucket(events_ht
->table
, LTTNG_EVENT_HT_SIZE
, event_name
);
1110 lttng_hlist_for_each_entry(event_priv
, head
, hlist_node
) {
1111 if (lttng_event_enabler_event_name_match_event(event_enabler
, event_name
, event_priv
->pub
)) {
1117 event
= lttng_kernel_event_alloc(event_enabler
);
1124 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1125 /* Event will be enabled by enabler sync. */
1127 event
->priv
->registered
= 0;
1128 event
->priv
->desc
= lttng_event_desc_get(event_name
);
1129 if (!event
->priv
->desc
) {
1131 goto register_error
;
1133 /* Populate lttng_event structure before event registration. */
1137 case LTTNG_KERNEL_ABI_KPROBE
:
1139 * Needs to be explicitly enabled after creation, since
1140 * we may want to apply filters.
1143 event
->priv
->registered
= 1;
1145 * Populate lttng_event structure before event
1149 ret
= lttng_kprobes_register_event(event_name
,
1150 event_param
->u
.kprobe
.symbol_name
,
1151 event_param
->u
.kprobe
.offset
,
1152 event_param
->u
.kprobe
.addr
,
1156 goto register_error
;
1158 ret
= try_module_get(event
->priv
->desc
->owner
);
1162 case LTTNG_KERNEL_ABI_KRETPROBE
:
1164 struct lttng_kernel_event_common
*event_return
;
1166 /* kretprobe defines 2 events */
1168 * Needs to be explicitly enabled after creation, since
1169 * we may want to apply filters.
1172 event
->priv
->registered
= 1;
1174 event_return
= lttng_kernel_event_alloc(event_enabler
);
1180 event_return
->enabled
= 0;
1181 event_return
->priv
->registered
= 1;
1184 * Populate lttng_event structure before kretprobe registration.
1187 ret
= lttng_kretprobes_register(event_name
,
1188 event_param
->u
.kretprobe
.symbol_name
,
1189 event_param
->u
.kretprobe
.offset
,
1190 event_param
->u
.kretprobe
.addr
,
1191 event
, event_return
);
1193 lttng_kernel_event_free(event_return
);
1195 goto register_error
;
1197 /* Take 2 refs on the module: one per event. */
1198 ret
= try_module_get(event
->priv
->desc
->owner
);
1200 ret
= try_module_get(event_return
->priv
->desc
->owner
);
1202 ret
= _lttng_event_recorder_metadata_statedump(event_return
);
1203 WARN_ON_ONCE(ret
> 0);
1205 lttng_kernel_event_free(event_return
);
1206 module_put(event_return
->priv
->desc
->owner
);
1207 module_put(event
->priv
->desc
->owner
);
1208 goto statedump_error
;
1210 list_add(&event_return
->priv
->node
, event_list_head
);
1214 case LTTNG_KERNEL_ABI_SYSCALL
:
1216 * Needs to be explicitly enabled after creation, since
1217 * we may want to apply filters.
1220 event
->priv
->registered
= 0;
1221 event
->priv
->desc
= event_desc
;
1222 switch (event_param
->u
.syscall
.entryexit
) {
1223 case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
:
1225 goto register_error
;
1226 case LTTNG_KERNEL_ABI_SYSCALL_ENTRY
:
1227 event
->priv
->u
.syscall
.entryexit
= LTTNG_SYSCALL_ENTRY
;
1229 case LTTNG_KERNEL_ABI_SYSCALL_EXIT
:
1230 event
->priv
->u
.syscall
.entryexit
= LTTNG_SYSCALL_EXIT
;
1233 switch (event_param
->u
.syscall
.abi
) {
1234 case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL
:
1236 goto register_error
;
1237 case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
:
1238 event
->priv
->u
.syscall
.abi
= LTTNG_SYSCALL_ABI_NATIVE
;
1240 case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
:
1241 event
->priv
->u
.syscall
.abi
= LTTNG_SYSCALL_ABI_COMPAT
;
1244 if (!event
->priv
->desc
) {
1246 goto register_error
;
1250 case LTTNG_KERNEL_ABI_UPROBE
:
1252 * Needs to be explicitly enabled after creation, since
1253 * we may want to apply filters.
1256 event
->priv
->registered
= 1;
1259 * Populate lttng_event structure before event
1264 ret
= lttng_uprobes_register_event(event_param
->name
,
1265 event_param
->u
.uprobe
.fd
,
1268 goto register_error
;
1269 ret
= try_module_get(event
->priv
->desc
->owner
);
1273 case LTTNG_KERNEL_ABI_FUNCTION
:
1275 case LTTNG_KERNEL_ABI_NOOP
:
1280 goto register_error
;
1283 ret
= _lttng_event_recorder_metadata_statedump(event
);
1284 WARN_ON_ONCE(ret
> 0);
1286 goto statedump_error
;
1289 ret
= lttng_kernel_event_notifier_clear_error_counter(event
);
1291 goto register_error
;
1293 hlist_add_head(&event
->priv
->hlist_node
, head
);
1294 list_add(&event
->priv
->node
, event_list_head
);
1299 /* If a statedump error occurs, events will not be readable. */
1301 lttng_kernel_event_free(event
);
1306 return ERR_PTR(ret
);
1309 struct lttng_kernel_event_common
*lttng_kernel_event_create(struct lttng_event_enabler_common
*event_enabler
,
1310 const struct lttng_kernel_event_desc
*event_desc
)
1312 struct lttng_kernel_event_common
*event
;
1314 mutex_lock(&sessions_mutex
);
1315 event
= _lttng_kernel_event_create(event_enabler
, event_desc
);
1316 mutex_unlock(&sessions_mutex
);
1320 int lttng_kernel_counter_read(struct lttng_counter
*counter
,
1321 const size_t *dim_indexes
, int32_t cpu
,
1322 int64_t *val
, bool *overflow
, bool *underflow
)
1324 return counter
->ops
->counter_read(counter
->counter
, dim_indexes
,
1325 cpu
, val
, overflow
, underflow
);
1328 int lttng_kernel_counter_aggregate(struct lttng_counter
*counter
,
1329 const size_t *dim_indexes
, int64_t *val
,
1330 bool *overflow
, bool *underflow
)
1332 return counter
->ops
->counter_aggregate(counter
->counter
, dim_indexes
,
1333 val
, overflow
, underflow
);
1336 int lttng_kernel_counter_clear(struct lttng_counter
*counter
,
1337 const size_t *dim_indexes
)
1339 return counter
->ops
->counter_clear(counter
->counter
, dim_indexes
);
1342 /* Only used for tracepoints and system calls for now. */
1344 void register_event(struct lttng_kernel_event_common
*event
)
1346 const struct lttng_kernel_event_desc
*desc
;
1349 WARN_ON_ONCE(event
->priv
->registered
);
1351 desc
= event
->priv
->desc
;
1352 switch (event
->priv
->instrumentation
) {
1353 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1354 ret
= lttng_wrapper_tracepoint_probe_register(desc
->event_kname
,
1355 desc
->tp_class
->probe_callback
,
1359 case LTTNG_KERNEL_ABI_SYSCALL
:
1360 ret
= lttng_syscall_filter_enable_event(event
);
1363 case LTTNG_KERNEL_ABI_KPROBE
:
1365 case LTTNG_KERNEL_ABI_UPROBE
:
1369 case LTTNG_KERNEL_ABI_KRETPROBE
:
1370 switch (event
->type
) {
1371 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1374 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1380 case LTTNG_KERNEL_ABI_FUNCTION
:
1382 case LTTNG_KERNEL_ABI_NOOP
:
1389 event
->priv
->registered
= 1;
1393 void unregister_event(struct lttng_kernel_event_common
*event
)
1395 struct lttng_kernel_event_common_private
*event_priv
= event
->priv
;
1396 const struct lttng_kernel_event_desc
*desc
;
1399 WARN_ON_ONCE(!event
->priv
->registered
);
1401 desc
= event_priv
->desc
;
1402 switch (event_priv
->instrumentation
) {
1403 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1404 ret
= lttng_wrapper_tracepoint_probe_unregister(event_priv
->desc
->event_kname
,
1405 event_priv
->desc
->tp_class
->probe_callback
,
1409 case LTTNG_KERNEL_ABI_KPROBE
:
1410 lttng_kprobes_unregister_event(event
);
1414 case LTTNG_KERNEL_ABI_KRETPROBE
:
1415 switch (event
->type
) {
1416 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1417 lttng_kretprobes_unregister(event
);
1420 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1426 case LTTNG_KERNEL_ABI_SYSCALL
:
1427 ret
= lttng_syscall_filter_disable_event(event
);
1430 case LTTNG_KERNEL_ABI_NOOP
:
1431 switch (event
->type
) {
1432 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1435 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1441 case LTTNG_KERNEL_ABI_UPROBE
:
1442 lttng_uprobes_unregister_event(event
);
1446 case LTTNG_KERNEL_ABI_FUNCTION
:
1453 event_priv
->registered
= 0;
1457 void _lttng_event_unregister(struct lttng_kernel_event_common
*event
)
1459 if (event
->priv
->registered
)
1460 unregister_event(event
);
1464 * Only used internally at session destruction.
1467 void _lttng_event_destroy(struct lttng_kernel_event_common
*event
)
1469 struct lttng_kernel_event_common_private
*event_priv
= event
->priv
;
1470 struct lttng_enabler_ref
*enabler_ref
, *tmp_enabler_ref
;
1472 lttng_free_event_filter_runtime(event
);
1473 /* Free event enabler refs */
1474 list_for_each_entry_safe(enabler_ref
, tmp_enabler_ref
,
1475 &event_priv
->enablers_ref_head
, node
)
1478 switch (event
->type
) {
1479 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1481 struct lttng_kernel_event_recorder
*event_recorder
=
1482 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
1484 switch (event_priv
->instrumentation
) {
1485 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1486 lttng_event_desc_put(event_priv
->desc
);
1489 case LTTNG_KERNEL_ABI_KPROBE
:
1490 module_put(event_priv
->desc
->owner
);
1491 lttng_kprobes_destroy_event_private(&event_recorder
->parent
);
1494 case LTTNG_KERNEL_ABI_KRETPROBE
:
1495 module_put(event_priv
->desc
->owner
);
1496 lttng_kretprobes_destroy_private(&event_recorder
->parent
);
1499 case LTTNG_KERNEL_ABI_SYSCALL
:
1502 case LTTNG_KERNEL_ABI_UPROBE
:
1503 module_put(event_priv
->desc
->owner
);
1504 lttng_uprobes_destroy_event_private(&event_recorder
->parent
);
1507 case LTTNG_KERNEL_ABI_FUNCTION
:
1509 case LTTNG_KERNEL_ABI_NOOP
:
1514 list_del(&event_recorder
->priv
->parent
.node
);
1515 kmem_cache_free(event_recorder_private_cache
, event_recorder
->priv
);
1516 kmem_cache_free(event_recorder_cache
, event_recorder
);
1519 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1521 struct lttng_kernel_event_notifier
*event_notifier
=
1522 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
1524 switch (event_notifier
->priv
->parent
.instrumentation
) {
1525 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1526 lttng_event_desc_put(event_notifier
->priv
->parent
.desc
);
1529 case LTTNG_KERNEL_ABI_KPROBE
:
1530 module_put(event_notifier
->priv
->parent
.desc
->owner
);
1531 lttng_kprobes_destroy_event_private(&event_notifier
->parent
);
1534 case LTTNG_KERNEL_ABI_SYSCALL
:
1537 case LTTNG_KERNEL_ABI_UPROBE
:
1538 module_put(event_notifier
->priv
->parent
.desc
->owner
);
1539 lttng_uprobes_destroy_event_private(&event_notifier
->parent
);
1542 case LTTNG_KERNEL_ABI_KRETPROBE
:
1544 case LTTNG_KERNEL_ABI_FUNCTION
:
1546 case LTTNG_KERNEL_ABI_NOOP
:
1551 list_del(&event_notifier
->priv
->parent
.node
);
1552 kmem_cache_free(event_notifier_private_cache
, event_notifier
->priv
);
1553 kmem_cache_free(event_notifier_cache
, event_notifier
);
1561 struct lttng_kernel_id_tracker
*get_tracker(struct lttng_kernel_session
*session
,
1562 enum tracker_type tracker_type
)
1564 switch (tracker_type
) {
1566 return &session
->pid_tracker
;
1568 return &session
->vpid_tracker
;
1570 return &session
->uid_tracker
;
1572 return &session
->vuid_tracker
;
1574 return &session
->gid_tracker
;
1576 return &session
->vgid_tracker
;
1583 int lttng_session_track_id(struct lttng_kernel_session
*session
,
1584 enum tracker_type tracker_type
, int id
)
1586 struct lttng_kernel_id_tracker
*tracker
;
1589 tracker
= get_tracker(session
, tracker_type
);
1594 mutex_lock(&sessions_mutex
);
1596 /* track all ids: destroy tracker. */
1597 lttng_id_tracker_destroy(tracker
, true);
1600 ret
= lttng_id_tracker_add(tracker
, id
);
1602 mutex_unlock(&sessions_mutex
);
1606 int lttng_session_untrack_id(struct lttng_kernel_session
*session
,
1607 enum tracker_type tracker_type
, int id
)
1609 struct lttng_kernel_id_tracker
*tracker
;
1612 tracker
= get_tracker(session
, tracker_type
);
1617 mutex_lock(&sessions_mutex
);
1619 /* untrack all ids: replace by empty tracker. */
1620 ret
= lttng_id_tracker_empty_set(tracker
);
1622 ret
= lttng_id_tracker_del(tracker
, id
);
1624 mutex_unlock(&sessions_mutex
);
1629 void *id_list_start(struct seq_file
*m
, loff_t
*pos
)
1631 struct lttng_kernel_id_tracker
*id_tracker
= m
->private;
1632 struct lttng_kernel_id_tracker_rcu
*id_tracker_p
= id_tracker
->p
;
1633 struct lttng_id_hash_node
*e
;
1636 mutex_lock(&sessions_mutex
);
1638 for (i
= 0; i
< LTTNG_ID_TABLE_SIZE
; i
++) {
1639 struct hlist_head
*head
= &id_tracker_p
->id_hash
[i
];
1641 lttng_hlist_for_each_entry(e
, head
, hlist
) {
1647 /* ID tracker disabled. */
1648 if (iter
>= *pos
&& iter
== 0) {
1649 return id_tracker_p
; /* empty tracker */
1657 /* Called with sessions_mutex held. */
1659 void *id_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
1661 struct lttng_kernel_id_tracker
*id_tracker
= m
->private;
1662 struct lttng_kernel_id_tracker_rcu
*id_tracker_p
= id_tracker
->p
;
1663 struct lttng_id_hash_node
*e
;
1668 for (i
= 0; i
< LTTNG_ID_TABLE_SIZE
; i
++) {
1669 struct hlist_head
*head
= &id_tracker_p
->id_hash
[i
];
1671 lttng_hlist_for_each_entry(e
, head
, hlist
) {
1672 if (iter
++ >= *ppos
)
1677 /* ID tracker disabled. */
1678 if (iter
>= *ppos
&& iter
== 0)
1679 return p
; /* empty tracker */
1688 void id_list_stop(struct seq_file
*m
, void *p
)
1690 mutex_unlock(&sessions_mutex
);
1694 int id_list_show(struct seq_file
*m
, void *p
)
1696 struct lttng_kernel_id_tracker
*id_tracker
= m
->private;
1697 struct lttng_kernel_id_tracker_rcu
*id_tracker_p
= id_tracker
->p
;
1700 if (p
== id_tracker_p
) {
1701 /* Tracker disabled. */
1704 const struct lttng_id_hash_node
*e
= p
;
1706 id
= lttng_id_tracker_get_node_id(e
);
1708 switch (id_tracker
->priv
->tracker_type
) {
1710 seq_printf(m
, "process { pid = %d; };\n", id
);
1713 seq_printf(m
, "process { vpid = %d; };\n", id
);
1716 seq_printf(m
, "user { uid = %d; };\n", id
);
1719 seq_printf(m
, "user { vuid = %d; };\n", id
);
1722 seq_printf(m
, "group { gid = %d; };\n", id
);
1725 seq_printf(m
, "group { vgid = %d; };\n", id
);
1728 seq_printf(m
, "UNKNOWN { field = %d };\n", id
);
1734 const struct seq_operations lttng_tracker_ids_list_seq_ops
= {
1735 .start
= id_list_start
,
1736 .next
= id_list_next
,
1737 .stop
= id_list_stop
,
1738 .show
= id_list_show
,
1742 int lttng_tracker_ids_list_open(struct inode
*inode
, struct file
*file
)
1744 return seq_open(file
, <tng_tracker_ids_list_seq_ops
);
1748 int lttng_tracker_ids_list_release(struct inode
*inode
, struct file
*file
)
1750 struct seq_file
*m
= file
->private_data
;
1751 struct lttng_kernel_id_tracker
*id_tracker
= m
->private;
1754 WARN_ON_ONCE(!id_tracker
);
1755 ret
= seq_release(inode
, file
);
1757 fput(id_tracker
->priv
->session
->priv
->file
);
1761 const struct file_operations lttng_tracker_ids_list_fops
= {
1762 .owner
= THIS_MODULE
,
1763 .open
= lttng_tracker_ids_list_open
,
1765 .llseek
= seq_lseek
,
1766 .release
= lttng_tracker_ids_list_release
,
1769 int lttng_session_list_tracker_ids(struct lttng_kernel_session
*session
,
1770 enum tracker_type tracker_type
)
1772 struct file
*tracker_ids_list_file
;
1776 file_fd
= lttng_get_unused_fd();
1782 tracker_ids_list_file
= anon_inode_getfile("[lttng_tracker_ids_list]",
1783 <tng_tracker_ids_list_fops
,
1785 if (IS_ERR(tracker_ids_list_file
)) {
1786 ret
= PTR_ERR(tracker_ids_list_file
);
1789 if (!atomic_long_add_unless(&session
->priv
->file
->f_count
, 1, LONG_MAX
)) {
1791 goto refcount_error
;
1793 ret
= lttng_tracker_ids_list_fops
.open(NULL
, tracker_ids_list_file
);
1796 m
= tracker_ids_list_file
->private_data
;
1798 m
->private = get_tracker(session
, tracker_type
);
1799 BUG_ON(!m
->private);
1800 fd_install(file_fd
, tracker_ids_list_file
);
1805 atomic_long_dec(&session
->priv
->file
->f_count
);
1807 fput(tracker_ids_list_file
);
1809 put_unused_fd(file_fd
);
1815 * Enabler management.
1818 int lttng_match_enabler_star_glob(const char *desc_name
,
1819 const char *pattern
)
1821 if (!strutils_star_glob_match(pattern
, LTTNG_SIZE_MAX
,
1822 desc_name
, LTTNG_SIZE_MAX
))
1828 int lttng_match_enabler_name(const char *desc_name
,
1831 if (strcmp(desc_name
, name
))
1837 int lttng_desc_match_enabler_check(const struct lttng_kernel_event_desc
*desc
,
1838 struct lttng_event_enabler_common
*enabler
)
1840 const char *desc_name
, *enabler_name
;
1841 bool compat
= false, entry
= false;
1843 enabler_name
= enabler
->event_param
.name
;
1844 switch (enabler
->event_param
.instrumentation
) {
1845 case LTTNG_KERNEL_ABI_TRACEPOINT
:
1846 desc_name
= desc
->event_name
;
1847 switch (enabler
->format_type
) {
1848 case LTTNG_ENABLER_FORMAT_STAR_GLOB
:
1849 return lttng_match_enabler_star_glob(desc_name
, enabler_name
);
1850 case LTTNG_ENABLER_FORMAT_NAME
:
1851 return lttng_match_enabler_name(desc_name
, enabler_name
);
1857 case LTTNG_KERNEL_ABI_SYSCALL
:
1858 desc_name
= desc
->event_name
;
1859 if (!strncmp(desc_name
, "compat_", strlen("compat_"))) {
1860 desc_name
+= strlen("compat_");
1863 if (!strncmp(desc_name
, "syscall_exit_",
1864 strlen("syscall_exit_"))) {
1865 desc_name
+= strlen("syscall_exit_");
1866 } else if (!strncmp(desc_name
, "syscall_entry_",
1867 strlen("syscall_entry_"))) {
1868 desc_name
+= strlen("syscall_entry_");
1874 switch (enabler
->event_param
.u
.syscall
.entryexit
) {
1875 case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
:
1877 case LTTNG_KERNEL_ABI_SYSCALL_ENTRY
:
1881 case LTTNG_KERNEL_ABI_SYSCALL_EXIT
:
1888 switch (enabler
->event_param
.u
.syscall
.abi
) {
1889 case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL
:
1891 case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
:
1895 case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
:
1902 switch (enabler
->event_param
.u
.syscall
.match
) {
1903 case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME
:
1904 switch (enabler
->format_type
) {
1905 case LTTNG_ENABLER_FORMAT_STAR_GLOB
:
1906 return lttng_match_enabler_star_glob(desc_name
, enabler_name
);
1907 case LTTNG_ENABLER_FORMAT_NAME
:
1908 return lttng_match_enabler_name(desc_name
, enabler_name
);
1913 case LTTNG_KERNEL_ABI_SYSCALL_MATCH_NR
:
1914 return -EINVAL
; /* Not implemented. */
1926 bool lttng_desc_match_enabler(const struct lttng_kernel_event_desc
*desc
,
1927 struct lttng_event_enabler_common
*enabler
)
1931 ret
= lttng_desc_match_enabler_check(desc
, enabler
);
1939 bool lttng_event_enabler_match_event(struct lttng_event_enabler_common
*event_enabler
,
1940 struct lttng_kernel_event_common
*event
)
1942 if (event_enabler
->event_param
.instrumentation
!= event
->priv
->instrumentation
)
1945 switch (event_enabler
->enabler_type
) {
1946 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
1948 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
1949 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
1950 struct lttng_kernel_event_recorder
*event_recorder
=
1951 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
1953 if (lttng_desc_match_enabler(event
->priv
->desc
, event_enabler
)
1954 && event_recorder
->chan
== event_recorder_enabler
->chan
)
1959 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
1961 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
1962 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
1963 struct lttng_kernel_event_notifier
*event_notifier
=
1964 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
1966 if (lttng_desc_match_enabler(event
->priv
->desc
, event_enabler
)
1967 && event_notifier
->priv
->group
== event_notifier_enabler
->group
1968 && event
->priv
->user_token
== event_enabler
->user_token
)
1979 bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common
*event_enabler
,
1980 const struct lttng_kernel_event_desc
*desc
,
1981 struct lttng_kernel_event_common
*event
)
1983 if (event_enabler
->event_param
.instrumentation
!= event
->priv
->instrumentation
)
1986 switch (event_enabler
->enabler_type
) {
1987 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
1989 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
1990 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
1991 struct lttng_kernel_event_recorder
*event_recorder
=
1992 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
1994 if (event
->priv
->desc
== desc
&& event_recorder
->chan
== event_recorder_enabler
->chan
)
1999 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
2001 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2002 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
2003 struct lttng_kernel_event_notifier
*event_notifier
=
2004 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
2006 if (event
->priv
->desc
== desc
2007 && event_notifier
->priv
->group
== event_notifier_enabler
->group
2008 && event
->priv
->user_token
== event_enabler
->user_token
)
2019 bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common
*event_enabler
,
2020 const char *event_name
,
2021 struct lttng_kernel_event_common
*event
)
2023 if (event_enabler
->event_param
.instrumentation
!= event
->priv
->instrumentation
)
2026 switch (event_enabler
->enabler_type
) {
2027 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
2029 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
2030 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
2031 struct lttng_kernel_event_recorder
*event_recorder
=
2032 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
2034 if (!strncmp(event
->priv
->desc
->event_name
, event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1)
2035 && event_recorder
->chan
== event_recorder_enabler
->chan
)
2040 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
2042 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2043 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
2044 struct lttng_kernel_event_notifier
*event_notifier
=
2045 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
2047 if (!strncmp(event
->priv
->desc
->event_name
, event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1)
2048 && event_notifier
->priv
->group
== event_notifier_enabler
->group
2049 && event
->priv
->user_token
== event_enabler
->user_token
)
2061 struct lttng_enabler_ref
*lttng_enabler_ref(
2062 struct list_head
*enablers_ref_list
,
2063 struct lttng_event_enabler_common
*enabler
)
2065 struct lttng_enabler_ref
*enabler_ref
;
2067 list_for_each_entry(enabler_ref
, enablers_ref_list
, node
) {
2068 if (enabler_ref
->ref
== enabler
)
2075 void lttng_event_enabler_create_tracepoint_events_if_missing(struct lttng_event_enabler_common
*event_enabler
)
2077 struct lttng_event_ht
*events_ht
= lttng_get_event_ht_from_enabler(event_enabler
);
2078 struct lttng_kernel_probe_desc
*probe_desc
;
2079 const struct lttng_kernel_event_desc
*desc
;
2080 struct list_head
*probe_list
;
2083 probe_list
= lttng_get_probe_list_head();
2085 * For each probe event, if we find that a probe event matches
2086 * our enabler, create an associated lttng_event if not
2089 list_for_each_entry(probe_desc
, probe_list
, head
) {
2090 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
2092 struct hlist_head
*head
;
2093 struct lttng_kernel_event_common
*event
;
2094 struct lttng_kernel_event_common_private
*event_priv
;
2096 desc
= probe_desc
->event_desc
[i
];
2097 if (!lttng_desc_match_enabler(desc
, event_enabler
))
2101 * Check if already created.
2103 head
= utils_borrow_hash_table_bucket(events_ht
->table
, LTTNG_EVENT_HT_SIZE
, desc
->event_name
);
2104 lttng_hlist_for_each_entry(event_priv
, head
, hlist_node
) {
2105 if (lttng_event_enabler_desc_match_event(event_enabler
, desc
, event_priv
->pub
)) {
2114 * We need to create an event for this event probe.
2116 event
= _lttng_kernel_event_create(event_enabler
, desc
);
2117 if (IS_ERR(event
)) {
2118 printk(KERN_INFO
"LTTng: Unable to create event %s\n",
2119 probe_desc
->event_desc
[i
]->event_name
);
2126 * Create event if it is missing and present in the list of tracepoint probes.
2127 * Should be called with sessions mutex held.
2130 void lttng_event_enabler_create_events_if_missing(struct lttng_event_enabler_common
*event_enabler
)
2134 switch (event_enabler
->event_param
.instrumentation
) {
2135 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2136 lttng_event_enabler_create_tracepoint_events_if_missing(event_enabler
);
2139 case LTTNG_KERNEL_ABI_SYSCALL
:
2140 ret
= lttng_event_enabler_create_syscall_events_if_missing(event_enabler
);
2151 void lttng_event_enabler_init_event_filter(struct lttng_event_enabler_common
*event_enabler
,
2152 struct lttng_kernel_event_common
*event
)
2154 /* Link filter bytecodes if not linked yet. */
2155 lttng_enabler_link_bytecode(event
->priv
->desc
, lttng_static_ctx
,
2156 &event
->priv
->filter_bytecode_runtime_head
, &event_enabler
->filter_bytecode_head
);
2160 void lttng_event_enabler_init_event_capture(struct lttng_event_enabler_common
*event_enabler
,
2161 struct lttng_kernel_event_common
*event
)
2163 switch (event_enabler
->enabler_type
) {
2164 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
2166 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
2168 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2169 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
2170 struct lttng_kernel_event_notifier
*event_notifier
=
2171 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
2173 /* Link capture bytecodes if not linked yet. */
2174 lttng_enabler_link_bytecode(event
->priv
->desc
,
2175 lttng_static_ctx
, &event_notifier
->priv
->capture_bytecode_runtime_head
,
2176 &event_notifier_enabler
->capture_bytecode_head
);
2177 event_notifier
->priv
->num_captures
= event_notifier_enabler
->num_captures
;
2186 * Create events associated with an event_enabler (if not already present),
2187 * and add backward reference from the event to the enabler.
2188 * Should be called with sessions mutex held.
2191 int lttng_event_enabler_ref_events(struct lttng_event_enabler_common
*event_enabler
)
2193 struct list_head
*event_list_head
= lttng_get_event_list_head_from_enabler(event_enabler
);
2194 struct lttng_kernel_event_common_private
*event_priv
;
2196 lttng_syscall_table_set_wildcard_all(event_enabler
);
2198 /* First ensure that probe events are created for this enabler. */
2199 lttng_event_enabler_create_events_if_missing(event_enabler
);
2201 /* Link the created event with its associated enabler. */
2202 list_for_each_entry(event_priv
, event_list_head
, node
) {
2203 struct lttng_kernel_event_common
*event
= event_priv
->pub
;
2204 struct lttng_enabler_ref
*enabler_ref
;
2206 if (!lttng_event_enabler_match_event(event_enabler
, event
))
2209 enabler_ref
= lttng_enabler_ref(&event_priv
->enablers_ref_head
, event_enabler
);
2212 * If no backward ref, create it.
2213 * Add backward ref from event_notifier to enabler.
2215 enabler_ref
= kzalloc(sizeof(*enabler_ref
), GFP_KERNEL
);
2219 enabler_ref
->ref
= event_enabler
;
2220 list_add(&enabler_ref
->node
, &event_priv
->enablers_ref_head
);
2223 lttng_event_enabler_init_event_filter(event_enabler
, event
);
2224 lttng_event_enabler_init_event_capture(event_enabler
, event
);
2230 * Called at module load: connect the probe on all enablers matching
2232 * Called with sessions lock held.
2234 int lttng_fix_pending_events(void)
2236 struct lttng_kernel_session_private
*session_priv
;
2238 list_for_each_entry(session_priv
, &sessions
, list
)
2239 lttng_session_lazy_sync_event_enablers(session_priv
->pub
);
2243 static bool lttng_event_notifier_group_has_active_event_notifiers(
2244 struct lttng_event_notifier_group
*event_notifier_group
)
2246 struct lttng_event_enabler_common
*event_enabler
;
2248 list_for_each_entry(event_enabler
, &event_notifier_group
->enablers_head
, node
) {
2249 if (event_enabler
->enabled
)
2255 bool lttng_event_notifier_active(void)
2257 struct lttng_event_notifier_group
*event_notifier_group
;
2259 list_for_each_entry(event_notifier_group
, &event_notifier_groups
, node
) {
2260 if (lttng_event_notifier_group_has_active_event_notifiers(event_notifier_group
))
2266 int lttng_fix_pending_event_notifiers(void)
2268 struct lttng_event_notifier_group
*event_notifier_group
;
2270 list_for_each_entry(event_notifier_group
, &event_notifier_groups
, node
)
2271 lttng_event_notifier_group_sync_enablers(event_notifier_group
);
2275 struct lttng_event_recorder_enabler
*lttng_event_recorder_enabler_create(
2276 enum lttng_enabler_format_type format_type
,
2277 struct lttng_kernel_abi_event
*event_param
,
2278 struct lttng_kernel_channel_buffer
*chan
)
2280 struct lttng_event_recorder_enabler
*event_enabler
;
2282 event_enabler
= kzalloc(sizeof(*event_enabler
), GFP_KERNEL
);
2285 event_enabler
->parent
.enabler_type
= LTTNG_EVENT_ENABLER_TYPE_RECORDER
;
2286 event_enabler
->parent
.format_type
= format_type
;
2287 INIT_LIST_HEAD(&event_enabler
->parent
.filter_bytecode_head
);
2288 memcpy(&event_enabler
->parent
.event_param
, event_param
,
2289 sizeof(event_enabler
->parent
.event_param
));
2290 event_enabler
->chan
= chan
;
2292 event_enabler
->parent
.enabled
= 0;
2293 return event_enabler
;
2296 void lttng_event_enabler_session_add(struct lttng_kernel_session
*session
,
2297 struct lttng_event_recorder_enabler
*event_enabler
)
2299 mutex_lock(&sessions_mutex
);
2300 list_add(&event_enabler
->parent
.node
, &session
->priv
->enablers_head
);
2301 event_enabler
->parent
.published
= true;
2302 lttng_session_lazy_sync_event_enablers(session
);
2303 mutex_unlock(&sessions_mutex
);
2306 int lttng_event_enabler_enable(struct lttng_event_enabler_common
*event_enabler
)
2308 mutex_lock(&sessions_mutex
);
2309 event_enabler
->enabled
= 1;
2310 lttng_event_enabler_sync(event_enabler
);
2311 mutex_unlock(&sessions_mutex
);
2315 int lttng_event_enabler_disable(struct lttng_event_enabler_common
*event_enabler
)
2317 mutex_lock(&sessions_mutex
);
2318 event_enabler
->enabled
= 0;
2319 lttng_event_enabler_sync(event_enabler
);
2320 mutex_unlock(&sessions_mutex
);
2325 int lttng_enabler_attach_filter_bytecode(struct lttng_event_enabler_common
*enabler
,
2326 struct lttng_kernel_abi_filter_bytecode __user
*bytecode
)
2328 struct lttng_kernel_bytecode_node
*bytecode_node
;
2329 uint32_t bytecode_len
;
2332 ret
= get_user(bytecode_len
, &bytecode
->len
);
2335 bytecode_node
= lttng_kvzalloc(sizeof(*bytecode_node
) + bytecode_len
,
2339 ret
= copy_from_user(&bytecode_node
->bc
, bytecode
,
2340 sizeof(*bytecode
) + bytecode_len
);
2344 bytecode_node
->type
= LTTNG_KERNEL_BYTECODE_TYPE_FILTER
;
2345 bytecode_node
->enabler
= enabler
;
2346 /* Enforce length based on allocated size */
2347 bytecode_node
->bc
.len
= bytecode_len
;
2348 list_add_tail(&bytecode_node
->node
, &enabler
->filter_bytecode_head
);
2353 lttng_kvfree(bytecode_node
);
2357 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler_common
*event_enabler
,
2358 struct lttng_kernel_abi_filter_bytecode __user
*bytecode
)
2361 ret
= lttng_enabler_attach_filter_bytecode(event_enabler
, bytecode
);
2364 lttng_event_enabler_sync(event_enabler
);
2371 int lttng_event_add_callsite(struct lttng_kernel_event_common
*event
,
2372 struct lttng_kernel_abi_event_callsite __user
*callsite
)
2375 switch (event
->priv
->instrumentation
) {
2376 case LTTNG_KERNEL_ABI_UPROBE
:
2377 return lttng_uprobes_event_add_callsite(event
, callsite
);
2384 void lttng_enabler_destroy(struct lttng_event_enabler_common
*enabler
)
2386 struct lttng_kernel_bytecode_node
*filter_node
, *tmp_filter_node
;
2388 /* Destroy filter bytecode */
2389 list_for_each_entry_safe(filter_node
, tmp_filter_node
,
2390 &enabler
->filter_bytecode_head
, node
) {
2391 lttng_kvfree(filter_node
);
2395 void lttng_event_enabler_destroy(struct lttng_event_enabler_common
*event_enabler
)
2397 lttng_enabler_destroy(event_enabler
);
2398 if (event_enabler
->published
)
2399 list_del(&event_enabler
->node
);
2401 switch (event_enabler
->enabler_type
) {
2402 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
2404 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
2405 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
2407 kfree(event_recorder_enabler
);
2410 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
2412 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2413 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
2415 kfree(event_notifier_enabler
);
2423 struct lttng_event_notifier_enabler
*lttng_event_notifier_enabler_create(
2424 enum lttng_enabler_format_type format_type
,
2425 struct lttng_kernel_abi_event_notifier
*event_notifier_param
,
2426 struct lttng_event_notifier_group
*event_notifier_group
)
2428 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
2430 event_notifier_enabler
= kzalloc(sizeof(*event_notifier_enabler
), GFP_KERNEL
);
2431 if (!event_notifier_enabler
)
2434 event_notifier_enabler
->parent
.enabler_type
= LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
;
2435 event_notifier_enabler
->parent
.format_type
= format_type
;
2436 INIT_LIST_HEAD(&event_notifier_enabler
->parent
.filter_bytecode_head
);
2437 INIT_LIST_HEAD(&event_notifier_enabler
->capture_bytecode_head
);
2439 event_notifier_enabler
->error_counter_index
= event_notifier_param
->error_counter_index
;
2440 event_notifier_enabler
->num_captures
= 0;
2442 memcpy(&event_notifier_enabler
->parent
.event_param
, &event_notifier_param
->event
,
2443 sizeof(event_notifier_enabler
->parent
.event_param
));
2445 event_notifier_enabler
->parent
.enabled
= 0;
2446 event_notifier_enabler
->parent
.user_token
= event_notifier_param
->event
.token
;
2447 event_notifier_enabler
->group
= event_notifier_group
;
2448 return event_notifier_enabler
;
2451 void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group
*event_notifier_group
,
2452 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
2454 mutex_lock(&sessions_mutex
);
2455 list_add(&event_notifier_enabler
->parent
.node
, &event_notifier_enabler
->group
->enablers_head
);
2456 event_notifier_enabler
->parent
.published
= true;
2457 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
2458 mutex_unlock(&sessions_mutex
);
2461 int lttng_event_notifier_enabler_enable(
2462 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
2464 mutex_lock(&sessions_mutex
);
2465 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->enabled
= 1;
2466 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
2467 mutex_unlock(&sessions_mutex
);
2471 int lttng_event_notifier_enabler_disable(
2472 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
2474 mutex_lock(&sessions_mutex
);
2475 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->enabled
= 0;
2476 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
2477 mutex_unlock(&sessions_mutex
);
2481 int lttng_event_notifier_enabler_attach_capture_bytecode(
2482 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
2483 struct lttng_kernel_abi_capture_bytecode __user
*bytecode
)
2485 struct lttng_kernel_bytecode_node
*bytecode_node
;
2486 struct lttng_event_enabler_common
*enabler
=
2487 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
);
2488 uint32_t bytecode_len
;
2491 ret
= get_user(bytecode_len
, &bytecode
->len
);
2495 bytecode_node
= lttng_kvzalloc(sizeof(*bytecode_node
) + bytecode_len
,
2500 ret
= copy_from_user(&bytecode_node
->bc
, bytecode
,
2501 sizeof(*bytecode
) + bytecode_len
);
2505 bytecode_node
->type
= LTTNG_KERNEL_BYTECODE_TYPE_CAPTURE
;
2506 bytecode_node
->enabler
= enabler
;
2508 /* Enforce length based on allocated size */
2509 bytecode_node
->bc
.len
= bytecode_len
;
2510 list_add_tail(&bytecode_node
->node
, &event_notifier_enabler
->capture_bytecode_head
);
2512 event_notifier_enabler
->num_captures
++;
2514 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
2518 lttng_kvfree(bytecode_node
);
2524 void lttng_event_sync_filter_state(struct lttng_kernel_event_common
*event
)
2526 int has_enablers_without_filter_bytecode
= 0, nr_filters
= 0;
2527 struct lttng_kernel_bytecode_runtime
*runtime
;
2528 struct lttng_enabler_ref
*enabler_ref
;
2530 /* Check if has enablers without bytecode enabled */
2531 list_for_each_entry(enabler_ref
, &event
->priv
->enablers_ref_head
, node
) {
2532 if (enabler_ref
->ref
->enabled
2533 && list_empty(&enabler_ref
->ref
->filter_bytecode_head
)) {
2534 has_enablers_without_filter_bytecode
= 1;
2538 event
->priv
->has_enablers_without_filter_bytecode
= has_enablers_without_filter_bytecode
;
2540 /* Enable filters */
2541 list_for_each_entry(runtime
, &event
->priv
->filter_bytecode_runtime_head
, node
) {
2542 lttng_bytecode_sync_state(runtime
);
2545 WRITE_ONCE(event
->eval_filter
, !(has_enablers_without_filter_bytecode
|| !nr_filters
));
2549 void lttng_event_sync_capture_state(struct lttng_kernel_event_common
*event
)
2551 switch (event
->type
) {
2552 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
2554 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
2556 struct lttng_kernel_event_notifier
*event_notifier
=
2557 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
2558 struct lttng_kernel_bytecode_runtime
*runtime
;
2559 int nr_captures
= 0;
2561 /* Enable captures */
2562 list_for_each_entry(runtime
, &event_notifier
->priv
->capture_bytecode_runtime_head
, node
) {
2563 lttng_bytecode_sync_state(runtime
);
2566 WRITE_ONCE(event_notifier
->eval_capture
, !!nr_captures
);
2575 bool lttng_get_event_enabled_state(struct lttng_kernel_event_common
*event
)
2577 struct lttng_enabler_ref
*enabler_ref
;
2578 bool enabled
= false;
2580 switch (event
->priv
->instrumentation
) {
2581 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2583 case LTTNG_KERNEL_ABI_SYSCALL
:
2585 list_for_each_entry(enabler_ref
, &event
->priv
->enablers_ref_head
, node
) {
2586 if (enabler_ref
->ref
->enabled
) {
2597 switch (event
->type
) {
2598 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
2600 struct lttng_kernel_event_recorder
*event_recorder
=
2601 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
2604 * Enabled state is based on union of enablers, with
2605 * intersection of session and channel transient enable
2608 return enabled
&& event_recorder
->chan
->parent
.session
->priv
->tstate
&& event_recorder
->chan
->priv
->parent
.tstate
;
2610 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
2619 bool lttng_event_is_lazy_sync(struct lttng_kernel_event_common
*event
)
2621 switch (event
->priv
->instrumentation
) {
2622 case LTTNG_KERNEL_ABI_TRACEPOINT
:
2624 case LTTNG_KERNEL_ABI_SYSCALL
:
2628 /* Not handled with lazy sync. */
2634 * Should be called with sessions mutex held.
2637 void lttng_sync_event_list(struct list_head
*event_enabler_list
,
2638 struct list_head
*event_list
)
2640 struct lttng_kernel_event_common_private
*event_priv
;
2641 struct lttng_event_enabler_common
*event_enabler
;
2643 list_for_each_entry(event_enabler
, event_enabler_list
, node
)
2644 lttng_event_enabler_ref_events(event_enabler
);
2647 * For each event, if at least one of its enablers is enabled,
2648 * and its channel and session transient states are enabled, we
2649 * enable the event, else we disable it.
2651 list_for_each_entry(event_priv
, event_list
, node
) {
2652 struct lttng_kernel_event_common
*event
= event_priv
->pub
;
2655 if (!lttng_event_is_lazy_sync(event
))
2658 enabled
= lttng_get_event_enabled_state(event
);
2659 WRITE_ONCE(event
->enabled
, enabled
);
2661 * Sync tracepoint registration with event enabled state.
2664 if (!event_priv
->registered
)
2665 register_event(event
);
2667 if (event_priv
->registered
)
2668 unregister_event(event
);
2671 lttng_event_sync_filter_state(event
);
2672 lttng_event_sync_capture_state(event
);
2677 * lttng_session_sync_event_enablers should be called just before starting a
2681 void lttng_session_sync_event_enablers(struct lttng_kernel_session
*session
)
2683 lttng_sync_event_list(&session
->priv
->enablers_head
, &session
->priv
->events
);
2687 * Apply enablers to session events, adding events to session if need
2688 * be. It is required after each modification applied to an active
2689 * session, and right before session "start".
2690 * "lazy" sync means we only sync if required.
2691 * Should be called with sessions mutex held.
2694 void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session
*session
)
2696 /* We can skip if session is not active */
2697 if (!session
->active
)
2699 lttng_session_sync_event_enablers(session
);
2703 void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
*event_notifier_group
)
2705 lttng_sync_event_list(&event_notifier_group
->enablers_head
, &event_notifier_group
->event_notifiers_head
);
2709 void lttng_event_enabler_sync(struct lttng_event_enabler_common
*event_enabler
)
2711 switch (event_enabler
->enabler_type
) {
2712 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
2714 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
2715 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
2716 lttng_session_lazy_sync_event_enablers(event_recorder_enabler
->chan
->parent
.session
);
2719 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
2721 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
2722 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
2723 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
2732 * Serialize at most one packet worth of metadata into a metadata
2734 * We grab the metadata cache mutex to get exclusive access to our metadata
2735 * buffer and to the metadata cache. Exclusive access to the metadata buffer
2736 * allows us to do racy operations such as looking for remaining space left in
2737 * packet and write, since mutual exclusion protects us from concurrent writes.
2738 * Mutual exclusion on the metadata cache allow us to read the cache content
2739 * without racing against reallocation of the cache by updates.
2740 * Returns the number of bytes written in the channel, 0 if no data
2741 * was written and a negative value on error.
2743 int lttng_metadata_output_channel(struct lttng_metadata_stream
*stream
,
2744 struct lttng_kernel_ring_buffer_channel
*chan
, bool *coherent
)
2746 struct lttng_kernel_ring_buffer_ctx ctx
;
2748 size_t len
, reserve_len
;
2751 * Ensure we support mutiple get_next / put sequences followed by
2752 * put_next. The metadata cache lock protects reading the metadata
2753 * cache. It can indeed be read concurrently by "get_next_subbuf" and
2754 * "flush" operations on the buffer invoked by different processes.
2755 * Moreover, since the metadata cache memory can be reallocated, we
2756 * need to have exclusive access against updates even though we only
2759 mutex_lock(&stream
->metadata_cache
->lock
);
2760 WARN_ON(stream
->metadata_in
< stream
->metadata_out
);
2761 if (stream
->metadata_in
!= stream
->metadata_out
)
2764 /* Metadata regenerated, change the version. */
2765 if (stream
->metadata_cache
->version
!= stream
->version
)
2766 stream
->version
= stream
->metadata_cache
->version
;
2768 len
= stream
->metadata_cache
->metadata_written
-
2769 stream
->metadata_in
;
2772 reserve_len
= min_t(size_t,
2773 stream
->transport
->ops
.priv
->packet_avail_size(chan
),
2775 lib_ring_buffer_ctx_init(&ctx
, chan
, reserve_len
,
2776 sizeof(char), NULL
);
2778 * If reservation failed, return an error to the caller.
2780 ret
= stream
->transport
->ops
.event_reserve(&ctx
);
2782 printk(KERN_WARNING
"LTTng: Metadata event reservation failed\n");
2783 stream
->coherent
= false;
2786 stream
->transport
->ops
.event_write(&ctx
,
2787 stream
->metadata_cache
->data
+ stream
->metadata_in
,
2789 stream
->transport
->ops
.event_commit(&ctx
);
2790 stream
->metadata_in
+= reserve_len
;
2791 if (reserve_len
< len
)
2792 stream
->coherent
= false;
2794 stream
->coherent
= true;
2799 *coherent
= stream
->coherent
;
2800 mutex_unlock(&stream
->metadata_cache
->lock
);
2805 void lttng_metadata_begin(struct lttng_kernel_session
*session
)
2807 if (atomic_inc_return(&session
->priv
->metadata_cache
->producing
) == 1)
2808 mutex_lock(&session
->priv
->metadata_cache
->lock
);
2812 void lttng_metadata_end(struct lttng_kernel_session
*session
)
2814 WARN_ON_ONCE(!atomic_read(&session
->priv
->metadata_cache
->producing
));
2815 if (atomic_dec_return(&session
->priv
->metadata_cache
->producing
) == 0) {
2816 struct lttng_metadata_stream
*stream
;
2818 list_for_each_entry(stream
, &session
->priv
->metadata_cache
->metadata_stream
, list
)
2819 wake_up_interruptible(&stream
->read_wait
);
2820 mutex_unlock(&session
->priv
->metadata_cache
->lock
);
2825 * Write the metadata to the metadata cache.
2826 * Must be called with sessions_mutex held.
2827 * The metadata cache lock protects us from concurrent read access from
2828 * thread outputting metadata content to ring buffer.
2829 * The content of the printf is printed as a single atomic metadata
2832 int lttng_metadata_printf(struct lttng_kernel_session
*session
,
2833 const char *fmt
, ...)
2839 WARN_ON_ONCE(!LTTNG_READ_ONCE(session
->active
));
2842 str
= kvasprintf(GFP_KERNEL
, fmt
, ap
);
2848 WARN_ON_ONCE(!atomic_read(&session
->priv
->metadata_cache
->producing
));
2849 if (session
->priv
->metadata_cache
->metadata_written
+ len
>
2850 session
->priv
->metadata_cache
->cache_alloc
) {
2851 char *tmp_cache_realloc
;
2852 unsigned int tmp_cache_alloc_size
;
2854 tmp_cache_alloc_size
= max_t(unsigned int,
2855 session
->priv
->metadata_cache
->cache_alloc
+ len
,
2856 session
->priv
->metadata_cache
->cache_alloc
<< 1);
2857 tmp_cache_realloc
= vzalloc(tmp_cache_alloc_size
);
2858 if (!tmp_cache_realloc
)
2860 if (session
->priv
->metadata_cache
->data
) {
2861 memcpy(tmp_cache_realloc
,
2862 session
->priv
->metadata_cache
->data
,
2863 session
->priv
->metadata_cache
->cache_alloc
);
2864 vfree(session
->priv
->metadata_cache
->data
);
2867 session
->priv
->metadata_cache
->cache_alloc
= tmp_cache_alloc_size
;
2868 session
->priv
->metadata_cache
->data
= tmp_cache_realloc
;
2870 memcpy(session
->priv
->metadata_cache
->data
+
2871 session
->priv
->metadata_cache
->metadata_written
,
2873 session
->priv
->metadata_cache
->metadata_written
+= len
;
2884 int print_tabs(struct lttng_kernel_session
*session
, size_t nesting
)
2888 for (i
= 0; i
< nesting
; i
++) {
2891 ret
= lttng_metadata_printf(session
, " ");
2900 int lttng_field_name_statedump(struct lttng_kernel_session
*session
,
2901 const struct lttng_kernel_event_field
*field
,
2904 return lttng_metadata_printf(session
, " _%s;\n", field
->name
);
2908 int _lttng_integer_type_statedump(struct lttng_kernel_session
*session
,
2909 const struct lttng_kernel_type_integer
*type
,
2910 enum lttng_kernel_string_encoding parent_encoding
,
2915 ret
= print_tabs(session
, nesting
);
2918 ret
= lttng_metadata_printf(session
,
2919 "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s }",
2923 (parent_encoding
== lttng_kernel_string_encoding_none
)
2925 : (parent_encoding
== lttng_kernel_string_encoding_UTF8
)
2929 #if __BYTE_ORDER == __BIG_ENDIAN
2930 type
->reverse_byte_order
? " byte_order = le;" : ""
2932 type
->reverse_byte_order
? " byte_order = be;" : ""
2939 * Must be called with sessions_mutex held.
2942 int _lttng_struct_type_statedump(struct lttng_kernel_session
*session
,
2943 const struct lttng_kernel_type_struct
*type
,
2946 const char *prev_field_name
= NULL
;
2948 uint32_t i
, nr_fields
;
2949 unsigned int alignment
;
2951 ret
= print_tabs(session
, nesting
);
2954 ret
= lttng_metadata_printf(session
,
2958 nr_fields
= type
->nr_fields
;
2959 for (i
= 0; i
< nr_fields
; i
++) {
2960 const struct lttng_kernel_event_field
*iter_field
;
2962 iter_field
= type
->fields
[i
];
2963 ret
= _lttng_field_statedump(session
, iter_field
, nesting
+ 1, &prev_field_name
);
2967 ret
= print_tabs(session
, nesting
);
2970 alignment
= type
->alignment
;
2972 ret
= lttng_metadata_printf(session
,
2976 ret
= lttng_metadata_printf(session
,
2983 * Must be called with sessions_mutex held.
2986 int _lttng_struct_field_statedump(struct lttng_kernel_session
*session
,
2987 const struct lttng_kernel_event_field
*field
,
2992 ret
= _lttng_struct_type_statedump(session
,
2993 lttng_kernel_get_type_struct(field
->type
), nesting
);
2996 return lttng_field_name_statedump(session
, field
, nesting
);
3000 * Must be called with sessions_mutex held.
3003 int _lttng_variant_type_statedump(struct lttng_kernel_session
*session
,
3004 const struct lttng_kernel_type_variant
*type
,
3006 const char *prev_field_name
)
3008 const char *tag_name
;
3010 uint32_t i
, nr_choices
;
3012 tag_name
= type
->tag_name
;
3014 tag_name
= prev_field_name
;
3018 * CTF 1.8 does not allow expressing nonzero variant alignment in a nestable way.
3020 if (type
->alignment
!= 0)
3022 ret
= print_tabs(session
, nesting
);
3025 ret
= lttng_metadata_printf(session
,
3026 "variant <_%s> {\n",
3030 nr_choices
= type
->nr_choices
;
3031 for (i
= 0; i
< nr_choices
; i
++) {
3032 const struct lttng_kernel_event_field
*iter_field
;
3034 iter_field
= type
->choices
[i
];
3035 ret
= _lttng_field_statedump(session
, iter_field
, nesting
+ 1, NULL
);
3039 ret
= print_tabs(session
, nesting
);
3042 ret
= lttng_metadata_printf(session
,
3048 * Must be called with sessions_mutex held.
3051 int _lttng_variant_field_statedump(struct lttng_kernel_session
*session
,
3052 const struct lttng_kernel_event_field
*field
,
3054 const char *prev_field_name
)
3058 ret
= _lttng_variant_type_statedump(session
,
3059 lttng_kernel_get_type_variant(field
->type
), nesting
,
3063 return lttng_field_name_statedump(session
, field
, nesting
);
3067 * Must be called with sessions_mutex held.
3070 int _lttng_array_field_statedump(struct lttng_kernel_session
*session
,
3071 const struct lttng_kernel_event_field
*field
,
3075 const struct lttng_kernel_type_array
*array_type
;
3076 const struct lttng_kernel_type_common
*elem_type
;
3078 array_type
= lttng_kernel_get_type_array(field
->type
);
3079 WARN_ON_ONCE(!array_type
);
3081 if (array_type
->alignment
) {
3082 ret
= print_tabs(session
, nesting
);
3085 ret
= lttng_metadata_printf(session
,
3086 "struct { } align(%u) _%s_padding;\n",
3087 array_type
->alignment
* CHAR_BIT
,
3093 * Nested compound types: Only array of structures and variants are
3094 * currently supported.
3096 elem_type
= array_type
->elem_type
;
3097 switch (elem_type
->type
) {
3098 case lttng_kernel_type_integer
:
3099 case lttng_kernel_type_struct
:
3100 case lttng_kernel_type_variant
:
3101 ret
= _lttng_type_statedump(session
, elem_type
,
3102 array_type
->encoding
, nesting
);
3110 ret
= lttng_metadata_printf(session
,
3113 array_type
->length
);
3118 * Must be called with sessions_mutex held.
3121 int _lttng_sequence_field_statedump(struct lttng_kernel_session
*session
,
3122 const struct lttng_kernel_event_field
*field
,
3124 const char *prev_field_name
)
3127 const char *length_name
;
3128 const struct lttng_kernel_type_sequence
*sequence_type
;
3129 const struct lttng_kernel_type_common
*elem_type
;
3131 sequence_type
= lttng_kernel_get_type_sequence(field
->type
);
3132 WARN_ON_ONCE(!sequence_type
);
3134 length_name
= sequence_type
->length_name
;
3136 length_name
= prev_field_name
;
3140 if (sequence_type
->alignment
) {
3141 ret
= print_tabs(session
, nesting
);
3144 ret
= lttng_metadata_printf(session
,
3145 "struct { } align(%u) _%s_padding;\n",
3146 sequence_type
->alignment
* CHAR_BIT
,
3153 * Nested compound types: Only array of structures and variants are
3154 * currently supported.
3156 elem_type
= sequence_type
->elem_type
;
3157 switch (elem_type
->type
) {
3158 case lttng_kernel_type_integer
:
3159 case lttng_kernel_type_struct
:
3160 case lttng_kernel_type_variant
:
3161 ret
= _lttng_type_statedump(session
, elem_type
,
3162 sequence_type
->encoding
, nesting
);
3170 ret
= lttng_metadata_printf(session
,
3178 * Must be called with sessions_mutex held.
3181 int _lttng_enum_type_statedump(struct lttng_kernel_session
*session
,
3182 const struct lttng_kernel_type_enum
*type
,
3185 const struct lttng_kernel_enum_desc
*enum_desc
;
3186 const struct lttng_kernel_type_common
*container_type
;
3188 unsigned int i
, nr_entries
;
3190 container_type
= type
->container_type
;
3191 if (container_type
->type
!= lttng_kernel_type_integer
) {
3195 enum_desc
= type
->desc
;
3196 nr_entries
= enum_desc
->nr_entries
;
3198 ret
= print_tabs(session
, nesting
);
3201 ret
= lttng_metadata_printf(session
, "enum : ");
3204 ret
= _lttng_integer_type_statedump(session
, lttng_kernel_get_type_integer(container_type
),
3205 lttng_kernel_string_encoding_none
, 0);
3208 ret
= lttng_metadata_printf(session
, " {\n");
3211 /* Dump all entries */
3212 for (i
= 0; i
< nr_entries
; i
++) {
3213 const struct lttng_kernel_enum_entry
*entry
= enum_desc
->entries
[i
];
3216 ret
= print_tabs(session
, nesting
+ 1);
3219 ret
= lttng_metadata_printf(session
,
3223 len
= strlen(entry
->string
);
3224 /* Escape the character '"' */
3225 for (j
= 0; j
< len
; j
++) {
3226 char c
= entry
->string
[j
];
3230 ret
= lttng_metadata_printf(session
,
3234 ret
= lttng_metadata_printf(session
,
3238 ret
= lttng_metadata_printf(session
,
3245 ret
= lttng_metadata_printf(session
, "\"");
3249 if (entry
->options
.is_auto
) {
3250 ret
= lttng_metadata_printf(session
, ",\n");
3254 ret
= lttng_metadata_printf(session
,
3258 if (entry
->start
.signedness
)
3259 ret
= lttng_metadata_printf(session
,
3260 "%lld", (long long) entry
->start
.value
);
3262 ret
= lttng_metadata_printf(session
,
3263 "%llu", entry
->start
.value
);
3266 if (entry
->start
.signedness
== entry
->end
.signedness
&&
3268 == entry
->end
.value
) {
3269 ret
= lttng_metadata_printf(session
,
3272 if (entry
->end
.signedness
) {
3273 ret
= lttng_metadata_printf(session
,
3275 (long long) entry
->end
.value
);
3277 ret
= lttng_metadata_printf(session
,
3286 ret
= print_tabs(session
, nesting
);
3289 ret
= lttng_metadata_printf(session
, "}");
3295 * Must be called with sessions_mutex held.
3298 int _lttng_enum_field_statedump(struct lttng_kernel_session
*session
,
3299 const struct lttng_kernel_event_field
*field
,
3303 const struct lttng_kernel_type_enum
*enum_type
;
3305 enum_type
= lttng_kernel_get_type_enum(field
->type
);
3306 WARN_ON_ONCE(!enum_type
);
3307 ret
= _lttng_enum_type_statedump(session
, enum_type
, nesting
);
3310 return lttng_field_name_statedump(session
, field
, nesting
);
3314 int _lttng_integer_field_statedump(struct lttng_kernel_session
*session
,
3315 const struct lttng_kernel_event_field
*field
,
3320 ret
= _lttng_integer_type_statedump(session
, lttng_kernel_get_type_integer(field
->type
),
3321 lttng_kernel_string_encoding_none
, nesting
);
3324 return lttng_field_name_statedump(session
, field
, nesting
);
3328 int _lttng_string_type_statedump(struct lttng_kernel_session
*session
,
3329 const struct lttng_kernel_type_string
*type
,
3334 /* Default encoding is UTF8 */
3335 ret
= print_tabs(session
, nesting
);
3338 ret
= lttng_metadata_printf(session
,
3340 type
->encoding
== lttng_kernel_string_encoding_ASCII
?
3341 " { encoding = ASCII; }" : "");
3346 int _lttng_string_field_statedump(struct lttng_kernel_session
*session
,
3347 const struct lttng_kernel_event_field
*field
,
3350 const struct lttng_kernel_type_string
*string_type
;
3353 string_type
= lttng_kernel_get_type_string(field
->type
);
3354 WARN_ON_ONCE(!string_type
);
3355 ret
= _lttng_string_type_statedump(session
, string_type
, nesting
);
3358 return lttng_field_name_statedump(session
, field
, nesting
);
3362 * Must be called with sessions_mutex held.
3365 int _lttng_type_statedump(struct lttng_kernel_session
*session
,
3366 const struct lttng_kernel_type_common
*type
,
3367 enum lttng_kernel_string_encoding parent_encoding
,
3372 switch (type
->type
) {
3373 case lttng_kernel_type_integer
:
3374 ret
= _lttng_integer_type_statedump(session
,
3375 lttng_kernel_get_type_integer(type
),
3376 parent_encoding
, nesting
);
3378 case lttng_kernel_type_enum
:
3379 ret
= _lttng_enum_type_statedump(session
,
3380 lttng_kernel_get_type_enum(type
),
3383 case lttng_kernel_type_string
:
3384 ret
= _lttng_string_type_statedump(session
,
3385 lttng_kernel_get_type_string(type
),
3388 case lttng_kernel_type_struct
:
3389 ret
= _lttng_struct_type_statedump(session
,
3390 lttng_kernel_get_type_struct(type
),
3393 case lttng_kernel_type_variant
:
3394 ret
= _lttng_variant_type_statedump(session
,
3395 lttng_kernel_get_type_variant(type
),
3399 /* Nested arrays and sequences are not supported yet. */
3400 case lttng_kernel_type_array
:
3401 case lttng_kernel_type_sequence
:
3410 * Must be called with sessions_mutex held.
3413 int _lttng_field_statedump(struct lttng_kernel_session
*session
,
3414 const struct lttng_kernel_event_field
*field
,
3416 const char **prev_field_name_p
)
3418 const char *prev_field_name
= NULL
;
3421 if (prev_field_name_p
)
3422 prev_field_name
= *prev_field_name_p
;
3423 switch (field
->type
->type
) {
3424 case lttng_kernel_type_integer
:
3425 ret
= _lttng_integer_field_statedump(session
, field
, nesting
);
3427 case lttng_kernel_type_enum
:
3428 ret
= _lttng_enum_field_statedump(session
, field
, nesting
);
3430 case lttng_kernel_type_string
:
3431 ret
= _lttng_string_field_statedump(session
, field
, nesting
);
3433 case lttng_kernel_type_struct
:
3434 ret
= _lttng_struct_field_statedump(session
, field
, nesting
);
3436 case lttng_kernel_type_array
:
3437 ret
= _lttng_array_field_statedump(session
, field
, nesting
);
3439 case lttng_kernel_type_sequence
:
3440 ret
= _lttng_sequence_field_statedump(session
, field
, nesting
, prev_field_name
);
3442 case lttng_kernel_type_variant
:
3443 ret
= _lttng_variant_field_statedump(session
, field
, nesting
, prev_field_name
);
3450 if (prev_field_name_p
)
3451 *prev_field_name_p
= field
->name
;
3456 int _lttng_context_metadata_statedump(struct lttng_kernel_session
*session
,
3457 struct lttng_kernel_ctx
*ctx
)
3459 const char *prev_field_name
= NULL
;
3465 for (i
= 0; i
< ctx
->nr_fields
; i
++) {
3466 const struct lttng_kernel_ctx_field
*field
= &ctx
->fields
[i
];
3468 ret
= _lttng_field_statedump(session
, field
->event_field
, 2, &prev_field_name
);
3476 int _lttng_fields_metadata_statedump(struct lttng_kernel_session
*session
,
3477 struct lttng_kernel_event_recorder
*event_recorder
)
3479 const char *prev_field_name
= NULL
;
3480 const struct lttng_kernel_event_desc
*desc
= event_recorder
->priv
->parent
.desc
;
3484 for (i
= 0; i
< desc
->tp_class
->nr_fields
; i
++) {
3485 const struct lttng_kernel_event_field
*field
= desc
->tp_class
->fields
[i
];
3487 ret
= _lttng_field_statedump(session
, field
, 2, &prev_field_name
);
3495 * Must be called with sessions_mutex held.
3496 * The entire event metadata is printed as a single atomic metadata
3500 int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common
*event
)
3502 struct lttng_kernel_event_recorder
*event_recorder
;
3503 struct lttng_kernel_channel_buffer
*chan
;
3504 struct lttng_kernel_session
*session
;
3507 if (event
->type
!= LTTNG_KERNEL_EVENT_TYPE_RECORDER
)
3509 event_recorder
= container_of(event
, struct lttng_kernel_event_recorder
, parent
);
3510 chan
= event_recorder
->chan
;
3511 session
= chan
->parent
.session
;
3513 if (event_recorder
->priv
->metadata_dumped
|| !LTTNG_READ_ONCE(session
->active
))
3515 if (chan
->priv
->channel_type
== METADATA_CHANNEL
)
3518 lttng_metadata_begin(session
);
3520 ret
= lttng_metadata_printf(session
,
3524 " stream_id = %u;\n",
3525 event_recorder
->priv
->parent
.desc
->event_name
,
3526 event_recorder
->priv
->id
,
3527 event_recorder
->chan
->priv
->id
);
3531 ret
= lttng_metadata_printf(session
,
3532 " fields := struct {\n"
3537 ret
= _lttng_fields_metadata_statedump(session
, event_recorder
);
3542 * LTTng space reservation can only reserve multiples of the
3545 ret
= lttng_metadata_printf(session
,
3551 event_recorder
->priv
->metadata_dumped
= 1;
3553 lttng_metadata_end(session
);
3559 * Must be called with sessions_mutex held.
3560 * The entire channel metadata is printed as a single atomic metadata
3564 int _lttng_channel_metadata_statedump(struct lttng_kernel_session
*session
,
3565 struct lttng_kernel_channel_buffer
*chan
)
3569 if (chan
->priv
->metadata_dumped
|| !LTTNG_READ_ONCE(session
->active
))
3572 if (chan
->priv
->channel_type
== METADATA_CHANNEL
)
3575 lttng_metadata_begin(session
);
3577 WARN_ON_ONCE(!chan
->priv
->header_type
);
3578 ret
= lttng_metadata_printf(session
,
3581 " event.header := %s;\n"
3582 " packet.context := struct packet_context;\n",
3584 chan
->priv
->header_type
== 1 ? "struct event_header_compact" :
3585 "struct event_header_large");
3589 if (chan
->priv
->ctx
) {
3590 ret
= lttng_metadata_printf(session
,
3591 " event.context := struct {\n");
3595 ret
= _lttng_context_metadata_statedump(session
, chan
->priv
->ctx
);
3598 if (chan
->priv
->ctx
) {
3599 ret
= lttng_metadata_printf(session
,
3605 ret
= lttng_metadata_printf(session
,
3608 chan
->priv
->metadata_dumped
= 1;
3610 lttng_metadata_end(session
);
3615 * Must be called with sessions_mutex held.
3618 int _lttng_stream_packet_context_declare(struct lttng_kernel_session
*session
)
3620 return lttng_metadata_printf(session
,
3621 "struct packet_context {\n"
3622 " uint64_clock_monotonic_t timestamp_begin;\n"
3623 " uint64_clock_monotonic_t timestamp_end;\n"
3624 " uint64_t content_size;\n"
3625 " uint64_t packet_size;\n"
3626 " uint64_t packet_seq_num;\n"
3627 " unsigned long events_discarded;\n"
3628 " uint32_t cpu_id;\n"
3635 * id: range: 0 - 30.
3636 * id 31 is reserved to indicate an extended header.
3639 * id: range: 0 - 65534.
3640 * id 65535 is reserved to indicate an extended header.
3642 * Must be called with sessions_mutex held.
3645 int _lttng_event_header_declare(struct lttng_kernel_session
*session
)
3647 return lttng_metadata_printf(session
,
3648 "struct event_header_compact {\n"
3649 " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
3652 " uint27_clock_monotonic_t timestamp;\n"
3656 " uint64_clock_monotonic_t timestamp;\n"
3661 "struct event_header_large {\n"
3662 " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
3665 " uint32_clock_monotonic_t timestamp;\n"
3669 " uint64_clock_monotonic_t timestamp;\n"
3673 lttng_alignof(uint32_t) * CHAR_BIT
,
3674 lttng_alignof(uint16_t) * CHAR_BIT
3679 * Approximation of NTP time of day to clock monotonic correlation,
3680 * taken at start of trace.
3681 * Yes, this is only an approximation. Yes, we can (and will) do better
3682 * in future versions.
3683 * This function may return a negative offset. It may happen if the
3684 * system sets the REALTIME clock to 0 after boot.
3686 * Use 64bit timespec on kernels that have it, this makes 32bit arch
3690 int64_t measure_clock_offset(void)
3692 uint64_t monotonic_avg
, monotonic
[2], realtime
;
3693 uint64_t tcf
= trace_clock_freq();
3695 unsigned long flags
;
3696 #ifdef LTTNG_KERNEL_HAS_TIMESPEC64
3697 struct timespec64 rts
= { 0, 0 };
3699 struct timespec rts
= { 0, 0 };
3702 /* Disable interrupts to increase correlation precision. */
3703 local_irq_save(flags
);
3704 monotonic
[0] = trace_clock_read64();
3705 #ifdef LTTNG_KERNEL_HAS_TIMESPEC64
3706 ktime_get_real_ts64(&rts
);
3708 getnstimeofday(&rts
);
3710 monotonic
[1] = trace_clock_read64();
3711 local_irq_restore(flags
);
3713 monotonic_avg
= (monotonic
[0] + monotonic
[1]) >> 1;
3714 realtime
= (uint64_t) rts
.tv_sec
* tcf
;
3715 if (tcf
== NSEC_PER_SEC
) {
3716 realtime
+= rts
.tv_nsec
;
3718 uint64_t n
= rts
.tv_nsec
* tcf
;
3720 do_div(n
, NSEC_PER_SEC
);
3723 offset
= (int64_t) realtime
- monotonic_avg
;
3728 int print_escaped_ctf_string(struct lttng_kernel_session
*session
, const char *string
)
3736 while (cur
!= '\0') {
3739 ret
= lttng_metadata_printf(session
, "%s", "\\n");
3743 ret
= lttng_metadata_printf(session
, "%c", '\\');
3746 /* We still print the current char */
3749 ret
= lttng_metadata_printf(session
, "%c", cur
);
3763 int print_metadata_escaped_field(struct lttng_kernel_session
*session
, const char *field
,
3764 const char *field_value
)
3768 ret
= lttng_metadata_printf(session
, " %s = \"", field
);
3772 ret
= print_escaped_ctf_string(session
, field_value
);
3776 ret
= lttng_metadata_printf(session
, "\";\n");
3783 * Output metadata into this session's metadata buffers.
3784 * Must be called with sessions_mutex held.
3787 int _lttng_session_metadata_statedump(struct lttng_kernel_session
*session
)
3789 unsigned char *uuid_c
= session
->priv
->uuid
.b
;
3790 unsigned char uuid_s
[37], clock_uuid_s
[BOOT_ID_LEN
];
3791 const char *product_uuid
;
3792 struct lttng_kernel_channel_buffer_private
*chan_priv
;
3793 struct lttng_kernel_event_recorder_private
*event_recorder_priv
;
3796 if (!LTTNG_READ_ONCE(session
->active
))
3799 lttng_metadata_begin(session
);
3801 if (session
->priv
->metadata_dumped
)
3804 snprintf(uuid_s
, sizeof(uuid_s
),
3805 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
3806 uuid_c
[0], uuid_c
[1], uuid_c
[2], uuid_c
[3],
3807 uuid_c
[4], uuid_c
[5], uuid_c
[6], uuid_c
[7],
3808 uuid_c
[8], uuid_c
[9], uuid_c
[10], uuid_c
[11],
3809 uuid_c
[12], uuid_c
[13], uuid_c
[14], uuid_c
[15]);
3811 ret
= lttng_metadata_printf(session
,
3812 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
3813 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
3814 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
3815 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
3816 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
3817 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
3818 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
3824 " byte_order = %s;\n"
3825 " packet.header := struct {\n"
3826 " uint32_t magic;\n"
3827 " uint8_t uuid[16];\n"
3828 " uint32_t stream_id;\n"
3829 " uint64_t stream_instance_id;\n"
3832 lttng_alignof(uint8_t) * CHAR_BIT
,
3833 lttng_alignof(uint16_t) * CHAR_BIT
,
3834 lttng_alignof(uint32_t) * CHAR_BIT
,
3835 lttng_alignof(uint64_t) * CHAR_BIT
,
3836 sizeof(unsigned long) * CHAR_BIT
,
3837 lttng_alignof(unsigned long) * CHAR_BIT
,
3841 #if __BYTE_ORDER == __BIG_ENDIAN
3850 ret
= lttng_metadata_printf(session
,
3852 " hostname = \"%s\";\n"
3853 " domain = \"kernel\";\n"
3854 " sysname = \"%s\";\n"
3855 " kernel_release = \"%s\";\n"
3856 " kernel_version = \"%s\";\n"
3857 " tracer_name = \"lttng-modules\";\n"
3858 " tracer_major = %d;\n"
3859 " tracer_minor = %d;\n"
3860 " tracer_patchlevel = %d;\n"
3861 " trace_buffering_scheme = \"global\";\n",
3862 current
->nsproxy
->uts_ns
->name
.nodename
,
3866 LTTNG_MODULES_MAJOR_VERSION
,
3867 LTTNG_MODULES_MINOR_VERSION
,
3868 LTTNG_MODULES_PATCHLEVEL_VERSION
3873 ret
= print_metadata_escaped_field(session
, "trace_name", session
->priv
->name
);
3876 ret
= print_metadata_escaped_field(session
, "trace_creation_datetime",
3877 session
->priv
->creation_time
);
3881 /* Add the product UUID to the 'env' section */
3882 product_uuid
= dmi_get_system_info(DMI_PRODUCT_UUID
);
3884 ret
= lttng_metadata_printf(session
,
3885 " product_uuid = \"%s\";\n",
3892 /* Close the 'env' section */
3893 ret
= lttng_metadata_printf(session
, "};\n\n");
3897 ret
= lttng_metadata_printf(session
,
3899 " name = \"%s\";\n",
3905 if (!trace_clock_uuid(clock_uuid_s
)) {
3906 ret
= lttng_metadata_printf(session
,
3907 " uuid = \"%s\";\n",
3914 ret
= lttng_metadata_printf(session
,
3915 " description = \"%s\";\n"
3916 " freq = %llu; /* Frequency, in Hz */\n"
3917 " /* clock value offset from Epoch is: offset * (1/freq) */\n"
3920 trace_clock_description(),
3921 (unsigned long long) trace_clock_freq(),
3922 (long long) measure_clock_offset()
3927 ret
= lttng_metadata_printf(session
,
3928 "typealias integer {\n"
3929 " size = 27; align = 1; signed = false;\n"
3930 " map = clock.%s.value;\n"
3931 "} := uint27_clock_monotonic_t;\n"
3933 "typealias integer {\n"
3934 " size = 32; align = %u; signed = false;\n"
3935 " map = clock.%s.value;\n"
3936 "} := uint32_clock_monotonic_t;\n"
3938 "typealias integer {\n"
3939 " size = 64; align = %u; signed = false;\n"
3940 " map = clock.%s.value;\n"
3941 "} := uint64_clock_monotonic_t;\n\n",
3943 lttng_alignof(uint32_t) * CHAR_BIT
,
3945 lttng_alignof(uint64_t) * CHAR_BIT
,
3951 ret
= _lttng_stream_packet_context_declare(session
);
3955 ret
= _lttng_event_header_declare(session
);
3960 list_for_each_entry(chan_priv
, &session
->priv
->chan
, node
) {
3961 ret
= _lttng_channel_metadata_statedump(session
, chan_priv
->pub
);
3966 list_for_each_entry(event_recorder_priv
, &session
->priv
->events
, parent
.node
) {
3967 ret
= _lttng_event_recorder_metadata_statedump(&event_recorder_priv
->pub
->parent
);
3971 session
->priv
->metadata_dumped
= 1;
3973 lttng_metadata_end(session
);
3978 * lttng_transport_register - LTT transport registration
3979 * @transport: transport structure
3981 * Registers a transport which can be used as output to extract the data out of
3982 * LTTng. The module calling this registration function must ensure that no
3983 * trap-inducing code will be executed by the transport functions. E.g.
3984 * vmalloc_sync_mappings() must be called between a vmalloc and the moment the memory
3985 * is made visible to the transport function. This registration acts as a
3986 * vmalloc_sync_mappings. Therefore, only if the module allocates virtual memory
3987 * after its registration must it synchronize the TLBs.
3989 void lttng_transport_register(struct lttng_transport
*transport
)
3992 * Make sure no page fault can be triggered by the module about to be
3993 * registered. We deal with this here so we don't have to call
3994 * vmalloc_sync_mappings() in each module's init.
3996 wrapper_vmalloc_sync_mappings();
3998 mutex_lock(&sessions_mutex
);
3999 list_add_tail(&transport
->node
, <tng_transport_list
);
4000 mutex_unlock(&sessions_mutex
);
4002 EXPORT_SYMBOL_GPL(lttng_transport_register
);
4005 * lttng_transport_unregister - LTT transport unregistration
4006 * @transport: transport structure
4008 void lttng_transport_unregister(struct lttng_transport
*transport
)
4010 mutex_lock(&sessions_mutex
);
4011 list_del(&transport
->node
);
4012 mutex_unlock(&sessions_mutex
);
4014 EXPORT_SYMBOL_GPL(lttng_transport_unregister
);
4016 void lttng_counter_transport_register(struct lttng_counter_transport
*transport
)
4019 * Make sure no page fault can be triggered by the module about to be
4020 * registered. We deal with this here so we don't have to call
4021 * vmalloc_sync_mappings() in each module's init.
4023 wrapper_vmalloc_sync_mappings();
4025 mutex_lock(&sessions_mutex
);
4026 list_add_tail(&transport
->node
, <tng_counter_transport_list
);
4027 mutex_unlock(&sessions_mutex
);
4029 EXPORT_SYMBOL_GPL(lttng_counter_transport_register
);
4031 void lttng_counter_transport_unregister(struct lttng_counter_transport
*transport
)
4033 mutex_lock(&sessions_mutex
);
4034 list_del(&transport
->node
);
4035 mutex_unlock(&sessions_mutex
);
4037 EXPORT_SYMBOL_GPL(lttng_counter_transport_unregister
);
4039 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
4041 enum cpuhp_state lttng_hp_prepare
;
4042 enum cpuhp_state lttng_hp_online
;
4044 static int lttng_hotplug_prepare(unsigned int cpu
, struct hlist_node
*node
)
4046 struct lttng_cpuhp_node
*lttng_node
;
4048 lttng_node
= container_of(node
, struct lttng_cpuhp_node
, node
);
4049 switch (lttng_node
->component
) {
4050 case LTTNG_RING_BUFFER_FRONTEND
:
4052 case LTTNG_RING_BUFFER_BACKEND
:
4053 return lttng_cpuhp_rb_backend_prepare(cpu
, lttng_node
);
4054 case LTTNG_RING_BUFFER_ITER
:
4056 case LTTNG_CONTEXT_PERF_COUNTERS
:
4063 static int lttng_hotplug_dead(unsigned int cpu
, struct hlist_node
*node
)
4065 struct lttng_cpuhp_node
*lttng_node
;
4067 lttng_node
= container_of(node
, struct lttng_cpuhp_node
, node
);
4068 switch (lttng_node
->component
) {
4069 case LTTNG_RING_BUFFER_FRONTEND
:
4070 return lttng_cpuhp_rb_frontend_dead(cpu
, lttng_node
);
4071 case LTTNG_RING_BUFFER_BACKEND
:
4073 case LTTNG_RING_BUFFER_ITER
:
4075 case LTTNG_CONTEXT_PERF_COUNTERS
:
4076 return lttng_cpuhp_perf_counter_dead(cpu
, lttng_node
);
4082 static int lttng_hotplug_online(unsigned int cpu
, struct hlist_node
*node
)
4084 struct lttng_cpuhp_node
*lttng_node
;
4086 lttng_node
= container_of(node
, struct lttng_cpuhp_node
, node
);
4087 switch (lttng_node
->component
) {
4088 case LTTNG_RING_BUFFER_FRONTEND
:
4089 return lttng_cpuhp_rb_frontend_online(cpu
, lttng_node
);
4090 case LTTNG_RING_BUFFER_BACKEND
:
4092 case LTTNG_RING_BUFFER_ITER
:
4093 return lttng_cpuhp_rb_iter_online(cpu
, lttng_node
);
4094 case LTTNG_CONTEXT_PERF_COUNTERS
:
4095 return lttng_cpuhp_perf_counter_online(cpu
, lttng_node
);
4101 static int lttng_hotplug_offline(unsigned int cpu
, struct hlist_node
*node
)
4103 struct lttng_cpuhp_node
*lttng_node
;
4105 lttng_node
= container_of(node
, struct lttng_cpuhp_node
, node
);
4106 switch (lttng_node
->component
) {
4107 case LTTNG_RING_BUFFER_FRONTEND
:
4108 return lttng_cpuhp_rb_frontend_offline(cpu
, lttng_node
);
4109 case LTTNG_RING_BUFFER_BACKEND
:
4111 case LTTNG_RING_BUFFER_ITER
:
4113 case LTTNG_CONTEXT_PERF_COUNTERS
:
4120 static int __init
lttng_init_cpu_hotplug(void)
4124 ret
= cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN
, "lttng:prepare",
4125 lttng_hotplug_prepare
,
4126 lttng_hotplug_dead
);
4130 lttng_hp_prepare
= ret
;
4131 lttng_rb_set_hp_prepare(ret
);
4133 ret
= cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN
, "lttng:online",
4134 lttng_hotplug_online
,
4135 lttng_hotplug_offline
);
4137 cpuhp_remove_multi_state(lttng_hp_prepare
);
4138 lttng_hp_prepare
= 0;
4141 lttng_hp_online
= ret
;
4142 lttng_rb_set_hp_online(ret
);
4147 static void __exit
lttng_exit_cpu_hotplug(void)
4149 lttng_rb_set_hp_online(0);
4150 cpuhp_remove_multi_state(lttng_hp_online
);
4151 lttng_rb_set_hp_prepare(0);
4152 cpuhp_remove_multi_state(lttng_hp_prepare
);
4155 #else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
4156 static int lttng_init_cpu_hotplug(void)
4160 static void lttng_exit_cpu_hotplug(void)
4163 #endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
4165 static int __init
lttng_events_init(void)
4169 ret
= wrapper_lttng_fixup_sig(THIS_MODULE
);
4172 ret
= wrapper_get_pfnblock_flags_mask_init();
4175 ret
= wrapper_get_pageblock_flags_mask_init();
4178 ret
= lttng_probes_init();
4181 ret
= lttng_context_init();
4184 ret
= lttng_tracepoint_init();
4187 event_recorder_cache
= KMEM_CACHE(lttng_kernel_event_recorder
, 0);
4188 if (!event_recorder_cache
) {
4190 goto error_kmem_event_recorder
;
4192 event_recorder_private_cache
= KMEM_CACHE(lttng_kernel_event_recorder_private
, 0);
4193 if (!event_recorder_private_cache
) {
4195 goto error_kmem_event_recorder_private
;
4197 event_notifier_cache
= KMEM_CACHE(lttng_kernel_event_notifier
, 0);
4198 if (!event_notifier_cache
) {
4200 goto error_kmem_event_notifier
;
4202 event_notifier_private_cache
= KMEM_CACHE(lttng_kernel_event_notifier_private
, 0);
4203 if (!event_notifier_private_cache
) {
4205 goto error_kmem_event_notifier_private
;
4207 ret
= lttng_abi_init();
4210 ret
= lttng_logger_init();
4213 ret
= lttng_init_cpu_hotplug();
4216 printk(KERN_NOTICE
"LTTng: Loaded modules v%s.%s.%s%s (%s)%s%s\n",
4217 __stringify(LTTNG_MODULES_MAJOR_VERSION
),
4218 __stringify(LTTNG_MODULES_MINOR_VERSION
),
4219 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
),
4220 LTTNG_MODULES_EXTRAVERSION
,
4222 #ifdef LTTNG_EXTRA_VERSION_GIT
4223 LTTNG_EXTRA_VERSION_GIT
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT
,
4227 #ifdef LTTNG_EXTRA_VERSION_NAME
4228 LTTNG_EXTRA_VERSION_NAME
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME
);
4232 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
4233 printk(KERN_NOTICE
"LTTng: Experimental bitwise enum enabled.\n");
4234 #endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
4238 lttng_logger_exit();
4242 kmem_cache_destroy(event_notifier_private_cache
);
4243 error_kmem_event_notifier_private
:
4244 kmem_cache_destroy(event_notifier_cache
);
4245 error_kmem_event_notifier
:
4246 kmem_cache_destroy(event_recorder_private_cache
);
4247 error_kmem_event_recorder_private
:
4248 kmem_cache_destroy(event_recorder_cache
);
4249 error_kmem_event_recorder
:
4250 lttng_tracepoint_exit();
4252 lttng_context_exit();
4253 printk(KERN_NOTICE
"LTTng: Failed to load modules v%s.%s.%s%s (%s)%s%s\n",
4254 __stringify(LTTNG_MODULES_MAJOR_VERSION
),
4255 __stringify(LTTNG_MODULES_MINOR_VERSION
),
4256 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
),
4257 LTTNG_MODULES_EXTRAVERSION
,
4259 #ifdef LTTNG_EXTRA_VERSION_GIT
4260 LTTNG_EXTRA_VERSION_GIT
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT
,
4264 #ifdef LTTNG_EXTRA_VERSION_NAME
4265 LTTNG_EXTRA_VERSION_NAME
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME
);
4272 module_init(lttng_events_init
);
4274 static void __exit
lttng_events_exit(void)
4276 struct lttng_kernel_session_private
*session_priv
, *tmpsession_priv
;
4278 lttng_exit_cpu_hotplug();
4279 lttng_logger_exit();
4281 list_for_each_entry_safe(session_priv
, tmpsession_priv
, &sessions
, list
)
4282 lttng_session_destroy(session_priv
->pub
);
4283 kmem_cache_destroy(event_recorder_cache
);
4284 kmem_cache_destroy(event_recorder_private_cache
);
4285 kmem_cache_destroy(event_notifier_cache
);
4286 kmem_cache_destroy(event_notifier_private_cache
);
4287 lttng_tracepoint_exit();
4288 lttng_context_exit();
4289 printk(KERN_NOTICE
"LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",
4290 __stringify(LTTNG_MODULES_MAJOR_VERSION
),
4291 __stringify(LTTNG_MODULES_MINOR_VERSION
),
4292 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
),
4293 LTTNG_MODULES_EXTRAVERSION
,
4295 #ifdef LTTNG_EXTRA_VERSION_GIT
4296 LTTNG_EXTRA_VERSION_GIT
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT
,
4300 #ifdef LTTNG_EXTRA_VERSION_NAME
4301 LTTNG_EXTRA_VERSION_NAME
[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME
);
4307 module_exit(lttng_events_exit
);
4309 #include <generated/patches.h>
4310 #ifdef LTTNG_EXTRA_VERSION_GIT
4311 MODULE_INFO(extra_version_git
, LTTNG_EXTRA_VERSION_GIT
);
4313 #ifdef LTTNG_EXTRA_VERSION_NAME
4314 MODULE_INFO(extra_version_name
, LTTNG_EXTRA_VERSION_NAME
);
4316 MODULE_LICENSE("GPL and additional rights");
4317 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
4318 MODULE_DESCRIPTION("LTTng tracer");
4319 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
4320 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
4321 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
4322 LTTNG_MODULES_EXTRAVERSION
);