2 * SPDX-License-Identifier: LGPL-2.1-only
4 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 * Holds LTTng per-session event registry.
24 #include <lttng/ust-endian.h>
26 #include <urcu/arch.h>
27 #include <urcu/compiler.h>
28 #include <urcu/hlist.h>
29 #include <urcu/list.h>
30 #include <urcu/uatomic.h>
32 #include <lttng/tracepoint.h>
33 #include <lttng/ust-events.h>
35 #include "common/logging.h"
36 #include "common/macros.h"
37 #include <lttng/ust-ctl.h>
38 #include "common/ustcomm.h"
39 #include "common/ust-fd.h"
40 #include "common/dynamic-type.h"
41 #include "common/ust-context-provider.h"
43 #include "common/tracepoint.h"
44 #include "common/strutils.h"
45 #include "lttng-bytecode.h"
46 #include "common/tracer.h"
47 #include "lttng-tracer-core.h"
48 #include "lttng-ust-statedump.h"
49 #include "context-internal.h"
50 #include "lib/lttng-ust/events.h"
51 #include "common/ringbuffer/shm.h"
52 #include "common/ringbuffer/frontend_types.h"
53 #include "common/ringbuffer/frontend.h"
54 #include "common/counter/counter.h"
55 #include "common/jhash.h"
56 #include <lttng/ust-abi.h>
57 #include "context-provider-internal.h"
60 * All operations within this file are called by the communication
61 * thread, under ust_lock protection.
64 static CDS_LIST_HEAD(sessions
);
65 static CDS_LIST_HEAD(event_notifier_groups
);
67 struct cds_list_head
*lttng_get_sessions(void)
72 static void _lttng_event_destroy(struct lttng_ust_event_common
*event
);
73 static void _lttng_enum_destroy(struct lttng_enum
*_enum
);
76 void lttng_session_lazy_sync_event_enablers(struct lttng_ust_session
*session
);
78 void lttng_session_sync_event_enablers(struct lttng_ust_session
*session
);
80 void lttng_event_notifier_group_sync_enablers(
81 struct lttng_event_notifier_group
*event_notifier_group
);
83 void lttng_enabler_destroy(struct lttng_enabler
*enabler
);
85 bool lttng_ust_validate_event_name(const struct lttng_ust_event_desc
*desc
)
87 if (strlen(desc
->probe_desc
->provider_name
) + 1 +
88 strlen(desc
->event_name
) >= LTTNG_UST_ABI_SYM_NAME_LEN
)
93 void lttng_ust_format_event_name(const struct lttng_ust_event_desc
*desc
,
96 strcpy(name
, desc
->probe_desc
->provider_name
);
98 strcat(name
, desc
->event_name
);
102 void lttng_event_enabler_unsync(struct lttng_event_enabler
*event_enabler
)
104 cds_list_move(&event_enabler
->node
,
105 &event_enabler
->chan
->parent
->session
->priv
->unsync_enablers_head
);
109 void lttng_session_unsync_enablers(struct lttng_ust_session
*session
)
111 cds_list_splice(&session
->priv
->sync_enablers_head
,
112 &session
->priv
->unsync_enablers_head
);
113 CDS_INIT_LIST_HEAD(&session
->priv
->sync_enablers_head
);
117 void lttng_event_notifier_enabler_unsync(struct lttng_event_notifier_enabler
*event_notifier_enabler
)
119 cds_list_move(&event_notifier_enabler
->node
,
120 &event_notifier_enabler
->group
->unsync_enablers_head
);
124 void lttng_event_notifier_group_unsync_enablers(struct lttng_event_notifier_group
*event_notifier_group
)
126 cds_list_splice(&event_notifier_group
->sync_enablers_head
,
127 &event_notifier_group
->unsync_enablers_head
);
128 CDS_INIT_LIST_HEAD(&event_notifier_group
->sync_enablers_head
);
132 * Called with ust lock held.
134 int lttng_session_active(void)
136 struct lttng_ust_session_private
*iter
;
138 cds_list_for_each_entry(iter
, &sessions
, node
) {
139 if (iter
->pub
->active
)
146 int lttng_loglevel_match(int loglevel
,
147 unsigned int has_loglevel
,
148 enum lttng_ust_abi_loglevel_type req_type
,
152 loglevel
= LTTNG_UST_TRACEPOINT_LOGLEVEL_DEFAULT
;
154 case LTTNG_UST_ABI_LOGLEVEL_RANGE
:
155 if (loglevel
<= req_loglevel
156 || (req_loglevel
== -1 && loglevel
<= LTTNG_UST_TRACEPOINT_LOGLEVEL_DEBUG
))
160 case LTTNG_UST_ABI_LOGLEVEL_SINGLE
:
161 if (loglevel
== req_loglevel
162 || (req_loglevel
== -1 && loglevel
<= LTTNG_UST_TRACEPOINT_LOGLEVEL_DEBUG
))
166 case LTTNG_UST_ABI_LOGLEVEL_ALL
:
168 if (loglevel
<= LTTNG_UST_TRACEPOINT_LOGLEVEL_DEBUG
)
175 struct lttng_ust_session
*lttng_session_create(void)
177 struct lttng_ust_session
*session
;
178 struct lttng_ust_session_private
*session_priv
;
181 session
= zmalloc(sizeof(struct lttng_ust_session
));
184 session
->struct_size
= sizeof(struct lttng_ust_session
);
185 session_priv
= zmalloc(sizeof(struct lttng_ust_session_private
));
190 session
->priv
= session_priv
;
191 session_priv
->pub
= session
;
192 if (lttng_context_init_all(&session
->priv
->ctx
)) {
197 CDS_INIT_LIST_HEAD(&session
->priv
->chan_head
);
198 CDS_INIT_LIST_HEAD(&session
->priv
->events_head
);
199 CDS_INIT_LIST_HEAD(&session
->priv
->enums_head
);
200 CDS_INIT_LIST_HEAD(&session
->priv
->unsync_enablers_head
);
201 CDS_INIT_LIST_HEAD(&session
->priv
->sync_enablers_head
);
202 for (i
= 0; i
< LTTNG_UST_EVENT_HT_SIZE
; i
++)
203 CDS_INIT_HLIST_HEAD(&session
->priv
->events_ht
.table
[i
]);
204 for (i
= 0; i
< LTTNG_UST_ENUM_HT_SIZE
; i
++)
205 CDS_INIT_HLIST_HEAD(&session
->priv
->enums_ht
.table
[i
]);
206 cds_list_add(&session
->priv
->node
, &sessions
);
210 struct lttng_counter
*lttng_ust_counter_create(
211 const char *counter_transport_name
,
212 size_t number_dimensions
, const struct lttng_counter_dimension
*dimensions
)
214 struct lttng_counter_transport
*counter_transport
= NULL
;
215 struct lttng_counter
*counter
= NULL
;
217 counter_transport
= lttng_counter_transport_find(counter_transport_name
);
218 if (!counter_transport
)
220 counter
= zmalloc(sizeof(struct lttng_counter
));
224 counter
->ops
= &counter_transport
->ops
;
225 counter
->transport
= counter_transport
;
227 counter
->counter
= counter
->ops
->counter_create(
228 number_dimensions
, dimensions
, 0,
230 if (!counter
->counter
) {
244 void lttng_ust_counter_destroy(struct lttng_counter
*counter
)
246 counter
->ops
->counter_destroy(counter
->counter
);
250 struct lttng_event_notifier_group
*lttng_event_notifier_group_create(void)
252 struct lttng_event_notifier_group
*event_notifier_group
;
255 event_notifier_group
= zmalloc(sizeof(struct lttng_event_notifier_group
));
256 if (!event_notifier_group
)
259 /* Add all contexts. */
260 if (lttng_context_init_all(&event_notifier_group
->ctx
)) {
261 free(event_notifier_group
);
265 CDS_INIT_LIST_HEAD(&event_notifier_group
->sync_enablers_head
);
266 CDS_INIT_LIST_HEAD(&event_notifier_group
->unsync_enablers_head
);
267 CDS_INIT_LIST_HEAD(&event_notifier_group
->event_notifiers_head
);
268 for (i
= 0; i
< LTTNG_UST_EVENT_NOTIFIER_HT_SIZE
; i
++)
269 CDS_INIT_HLIST_HEAD(&event_notifier_group
->event_notifiers_ht
.table
[i
]);
271 cds_list_add(&event_notifier_group
->node
, &event_notifier_groups
);
273 return event_notifier_group
;
277 * Only used internally at session destruction.
280 void _lttng_channel_unmap(struct lttng_ust_channel_buffer
*lttng_chan
)
282 struct lttng_ust_ring_buffer_channel
*chan
;
283 struct lttng_ust_shm_handle
*handle
;
285 cds_list_del(<tng_chan
->priv
->node
);
286 lttng_destroy_context(lttng_chan
->priv
->ctx
);
287 chan
= lttng_chan
->priv
->rb_chan
;
288 handle
= chan
->handle
;
289 channel_destroy(chan
, handle
, 0);
290 free(lttng_chan
->parent
);
291 free(lttng_chan
->priv
);
296 void register_event(struct lttng_ust_event_common
*event
)
299 const struct lttng_ust_event_desc
*desc
;
301 assert(event
->priv
->registered
== 0);
302 desc
= event
->priv
->desc
;
303 ret
= lttng_ust_tp_probe_register_queue_release(desc
->probe_desc
->provider_name
,
305 desc
->tp_class
->probe_callback
,
306 event
, desc
->tp_class
->signature
);
309 event
->priv
->registered
= 1;
313 void unregister_event(struct lttng_ust_event_common
*event
)
316 const struct lttng_ust_event_desc
*desc
;
318 assert(event
->priv
->registered
== 1);
319 desc
= event
->priv
->desc
;
320 ret
= lttng_ust_tp_probe_unregister_queue_release(desc
->probe_desc
->provider_name
,
322 desc
->tp_class
->probe_callback
,
326 event
->priv
->registered
= 0;
330 void _lttng_event_unregister(struct lttng_ust_event_common
*event
)
332 if (event
->priv
->registered
)
333 unregister_event(event
);
336 void lttng_session_destroy(struct lttng_ust_session
*session
)
338 struct lttng_ust_channel_buffer_private
*chan
, *tmpchan
;
339 struct lttng_ust_event_recorder_private
*event_recorder_priv
, *tmpevent_recorder_priv
;
340 struct lttng_enum
*_enum
, *tmp_enum
;
341 struct lttng_event_enabler
*event_enabler
, *event_tmpenabler
;
343 CMM_ACCESS_ONCE(session
->active
) = 0;
344 cds_list_for_each_entry(event_recorder_priv
, &session
->priv
->events_head
, node
) {
345 _lttng_event_unregister(event_recorder_priv
->parent
.pub
);
347 lttng_ust_urcu_synchronize_rcu(); /* Wait for in-flight events to complete */
348 lttng_ust_tp_probe_prune_release_queue();
349 cds_list_for_each_entry_safe(event_enabler
, event_tmpenabler
,
350 &session
->priv
->unsync_enablers_head
, node
)
351 lttng_event_enabler_destroy(event_enabler
);
352 cds_list_for_each_entry_safe(event_enabler
, event_tmpenabler
,
353 &session
->priv
->sync_enablers_head
, node
)
354 lttng_event_enabler_destroy(event_enabler
);
355 cds_list_for_each_entry_safe(event_recorder_priv
, tmpevent_recorder_priv
,
356 &session
->priv
->events_head
, node
)
357 _lttng_event_destroy(event_recorder_priv
->parent
.pub
);
358 cds_list_for_each_entry_safe(_enum
, tmp_enum
,
359 &session
->priv
->enums_head
, node
)
360 _lttng_enum_destroy(_enum
);
361 cds_list_for_each_entry_safe(chan
, tmpchan
, &session
->priv
->chan_head
, node
)
362 _lttng_channel_unmap(chan
->pub
);
363 cds_list_del(&session
->priv
->node
);
364 lttng_destroy_context(session
->priv
->ctx
);
369 void lttng_event_notifier_group_destroy(
370 struct lttng_event_notifier_group
*event_notifier_group
)
373 struct lttng_event_notifier_enabler
*notifier_enabler
, *tmpnotifier_enabler
;
374 struct lttng_ust_event_notifier_private
*event_notifier_priv
, *tmpevent_notifier_priv
;
376 if (!event_notifier_group
) {
380 cds_list_for_each_entry(event_notifier_priv
,
381 &event_notifier_group
->event_notifiers_head
, node
)
382 _lttng_event_unregister(event_notifier_priv
->parent
.pub
);
384 lttng_ust_urcu_synchronize_rcu();
386 cds_list_for_each_entry_safe(notifier_enabler
, tmpnotifier_enabler
,
387 &event_notifier_group
->sync_enablers_head
, node
)
388 lttng_event_notifier_enabler_destroy(notifier_enabler
);
389 cds_list_for_each_entry_safe(notifier_enabler
, tmpnotifier_enabler
,
390 &event_notifier_group
->unsync_enablers_head
, node
)
391 lttng_event_notifier_enabler_destroy(notifier_enabler
);
393 cds_list_for_each_entry_safe(event_notifier_priv
, tmpevent_notifier_priv
,
394 &event_notifier_group
->event_notifiers_head
, node
)
395 _lttng_event_destroy(event_notifier_priv
->parent
.pub
);
397 if (event_notifier_group
->error_counter
)
398 lttng_ust_counter_destroy(event_notifier_group
->error_counter
);
400 /* Close the notification fd to the listener of event_notifiers. */
402 lttng_ust_lock_fd_tracker();
403 close_ret
= close(event_notifier_group
->notification_fd
);
405 lttng_ust_delete_fd_from_tracker(
406 event_notifier_group
->notification_fd
);
411 lttng_ust_unlock_fd_tracker();
413 cds_list_del(&event_notifier_group
->node
);
414 lttng_destroy_context(event_notifier_group
->ctx
);
415 free(event_notifier_group
);
419 void lttng_enabler_destroy(struct lttng_enabler
*enabler
)
421 struct lttng_ust_bytecode_node
*filter_node
, *tmp_filter_node
;
422 struct lttng_ust_excluder_node
*excluder_node
, *tmp_excluder_node
;
428 /* Destroy filter bytecode */
429 cds_list_for_each_entry_safe(filter_node
, tmp_filter_node
,
430 &enabler
->filter_bytecode_head
, node
) {
434 /* Destroy excluders */
435 cds_list_for_each_entry_safe(excluder_node
, tmp_excluder_node
,
436 &enabler
->excluder_head
, node
) {
441 void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler
*event_notifier_enabler
)
443 if (!event_notifier_enabler
) {
447 cds_list_del(&event_notifier_enabler
->node
);
449 lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
));
451 free(event_notifier_enabler
);
455 int lttng_enum_create(const struct lttng_ust_enum_desc
*desc
,
456 struct lttng_ust_session
*session
)
458 const char *enum_name
= desc
->name
;
459 struct lttng_enum
*_enum
;
460 struct cds_hlist_head
*head
;
462 size_t name_len
= strlen(enum_name
);
466 /* Check if this enum is already registered for this session. */
467 hash
= jhash(enum_name
, name_len
, 0);
468 head
= &session
->priv
->enums_ht
.table
[hash
& (LTTNG_UST_ENUM_HT_SIZE
- 1)];
470 _enum
= lttng_ust_enum_get_from_desc(session
, desc
);
476 notify_socket
= lttng_get_notify_socket(session
->priv
->owner
);
477 if (notify_socket
< 0) {
482 _enum
= zmalloc(sizeof(*_enum
));
487 _enum
->session
= session
;
490 ret
= ustcomm_register_enum(notify_socket
,
497 DBG("Error (%d) registering enumeration to sessiond", ret
);
498 goto sessiond_register_error
;
500 cds_list_add(&_enum
->node
, &session
->priv
->enums_head
);
501 cds_hlist_add_head(&_enum
->hlist
, head
);
504 sessiond_register_error
:
513 int lttng_create_enum_check(const struct lttng_ust_type_common
*type
,
514 struct lttng_ust_session
*session
)
516 switch (type
->type
) {
517 case lttng_ust_type_enum
:
519 const struct lttng_ust_enum_desc
*enum_desc
;
522 enum_desc
= lttng_ust_get_type_enum(type
)->desc
;
523 ret
= lttng_enum_create(enum_desc
, session
);
524 if (ret
&& ret
!= -EEXIST
) {
525 DBG("Unable to create enum error: (%d)", ret
);
530 case lttng_ust_type_dynamic
:
532 const struct lttng_ust_event_field
*tag_field_generic
;
533 const struct lttng_ust_enum_desc
*enum_desc
;
536 tag_field_generic
= lttng_ust_dynamic_type_tag_field();
537 enum_desc
= lttng_ust_get_type_enum(tag_field_generic
->type
)->desc
;
538 ret
= lttng_enum_create(enum_desc
, session
);
539 if (ret
&& ret
!= -EEXIST
) {
540 DBG("Unable to create enum error: (%d)", ret
);
546 /* TODO: nested types when they become supported. */
553 int lttng_create_all_event_enums(size_t nr_fields
,
554 const struct lttng_ust_event_field
* const *event_fields
,
555 struct lttng_ust_session
*session
)
560 /* For each field, ensure enum is part of the session. */
561 for (i
= 0; i
< nr_fields
; i
++) {
562 const struct lttng_ust_type_common
*type
= event_fields
[i
]->type
;
564 ret
= lttng_create_enum_check(type
, session
);
572 int lttng_create_all_ctx_enums(size_t nr_fields
,
573 struct lttng_ust_ctx_field
*ctx_fields
,
574 struct lttng_ust_session
*session
)
579 /* For each field, ensure enum is part of the session. */
580 for (i
= 0; i
< nr_fields
; i
++) {
581 const struct lttng_ust_type_common
*type
= ctx_fields
[i
].event_field
->type
;
583 ret
= lttng_create_enum_check(type
, session
);
591 * Ensure that a state-dump will be performed for this session at the end
592 * of the current handle_message().
594 int lttng_session_statedump(struct lttng_ust_session
*session
)
596 session
->priv
->statedump_pending
= 1;
597 lttng_ust_sockinfo_session_enabled(session
->priv
->owner
);
601 int lttng_session_enable(struct lttng_ust_session
*session
)
604 struct lttng_ust_channel_buffer_private
*chan
;
607 if (session
->active
) {
612 notify_socket
= lttng_get_notify_socket(session
->priv
->owner
);
613 if (notify_socket
< 0)
614 return notify_socket
;
616 /* Set transient enabler state to "enabled" */
617 session
->priv
->tstate
= 1;
619 /* We need to sync enablers with session before activation. */
620 lttng_session_sync_event_enablers(session
);
623 * Snapshot the number of events per channel to know the type of header
626 cds_list_for_each_entry(chan
, &session
->priv
->chan_head
, node
) {
627 struct lttng_ust_ctx
*ctx
;
628 struct lttng_ust_ctx_field
*fields
= NULL
;
629 size_t nr_fields
= 0;
632 /* don't change it if session stop/restart */
633 if (chan
->header_type
)
637 nr_fields
= ctx
->nr_fields
;
638 fields
= ctx
->fields
;
639 ret
= lttng_create_all_ctx_enums(nr_fields
, fields
,
642 DBG("Error (%d) adding enum to session", ret
);
646 ret
= ustcomm_register_channel(notify_socket
,
655 DBG("Error (%d) registering channel to sessiond", ret
);
658 if (chan_id
!= chan
->id
) {
659 DBG("Error: channel registration id (%u) does not match id assigned at creation (%u)",
665 /* Set atomically the state to "active" */
666 CMM_ACCESS_ONCE(session
->active
) = 1;
667 CMM_ACCESS_ONCE(session
->priv
->been_active
) = 1;
669 ret
= lttng_session_statedump(session
);
676 int lttng_session_disable(struct lttng_ust_session
*session
)
680 if (!session
->active
) {
684 /* Set atomically the state to "inactive" */
685 CMM_ACCESS_ONCE(session
->active
) = 0;
687 /* Set transient enabler state to "disabled" */
688 session
->priv
->tstate
= 0;
689 lttng_session_sync_event_enablers(session
);
694 int lttng_channel_enable(struct lttng_ust_channel_common
*lttng_channel
)
698 if (lttng_channel
->enabled
) {
702 /* Set transient enabler state to "enabled" */
703 lttng_channel
->priv
->tstate
= 1;
704 lttng_session_sync_event_enablers(lttng_channel
->session
);
705 /* Set atomically the state to "enabled" */
706 CMM_ACCESS_ONCE(lttng_channel
->enabled
) = 1;
711 int lttng_channel_disable(struct lttng_ust_channel_common
*lttng_channel
)
715 if (!lttng_channel
->enabled
) {
719 /* Set atomically the state to "disabled" */
720 CMM_ACCESS_ONCE(lttng_channel
->enabled
) = 0;
721 /* Set transient enabler state to "enabled" */
722 lttng_channel
->priv
->tstate
= 0;
723 lttng_session_sync_event_enablers(lttng_channel
->session
);
729 struct cds_hlist_head
*borrow_hash_table_bucket(
730 struct cds_hlist_head
*hash_table
,
731 unsigned int hash_table_size
,
732 const struct lttng_ust_event_desc
*desc
)
734 char name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
738 lttng_ust_format_event_name(desc
, name
);
739 name_len
= strlen(name
);
741 hash
= jhash(name
, name_len
, 0);
742 return &hash_table
[hash
& (hash_table_size
- 1)];
746 * Supports event creation while tracing session is active.
749 int lttng_event_recorder_create(const struct lttng_ust_event_desc
*desc
,
750 struct lttng_ust_channel_buffer
*chan
)
752 char name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
753 struct lttng_ust_event_recorder
*event_recorder
;
754 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
755 struct lttng_ust_session
*session
= chan
->parent
->session
;
756 struct cds_hlist_head
*head
;
758 int notify_socket
, loglevel
;
761 head
= borrow_hash_table_bucket(chan
->parent
->session
->priv
->events_ht
.table
,
762 LTTNG_UST_EVENT_HT_SIZE
, desc
);
764 notify_socket
= lttng_get_notify_socket(session
->priv
->owner
);
765 if (notify_socket
< 0) {
770 ret
= lttng_create_all_event_enums(desc
->tp_class
->nr_fields
, desc
->tp_class
->fields
,
773 DBG("Error (%d) adding enum to session", ret
);
774 goto create_enum_error
;
778 * Check if loglevel match. Refuse to connect event if not.
780 event_recorder
= zmalloc(sizeof(struct lttng_ust_event_recorder
));
781 if (!event_recorder
) {
785 event_recorder
->struct_size
= sizeof(struct lttng_ust_event_recorder
);
787 event_recorder
->parent
= zmalloc(sizeof(struct lttng_ust_event_common
));
788 if (!event_recorder
->parent
) {
792 event_recorder
->parent
->struct_size
= sizeof(struct lttng_ust_event_common
);
793 event_recorder
->parent
->type
= LTTNG_UST_EVENT_TYPE_RECORDER
;
794 event_recorder
->parent
->child
= event_recorder
;
796 event_recorder_priv
= zmalloc(sizeof(struct lttng_ust_event_recorder_private
));
797 if (!event_recorder_priv
) {
801 event_recorder
->priv
= event_recorder_priv
;
802 event_recorder_priv
->pub
= event_recorder
;
803 event_recorder
->parent
->priv
= &event_recorder_priv
->parent
;
804 event_recorder_priv
->parent
.pub
= event_recorder
->parent
;
806 event_recorder
->chan
= chan
;
808 /* Event will be enabled by enabler sync. */
809 event_recorder
->parent
->run_filter
= lttng_ust_interpret_event_filter
;
810 event_recorder
->parent
->enabled
= 0;
811 event_recorder
->parent
->priv
->registered
= 0;
812 CDS_INIT_LIST_HEAD(&event_recorder
->parent
->priv
->filter_bytecode_runtime_head
);
813 CDS_INIT_LIST_HEAD(&event_recorder
->parent
->priv
->enablers_ref_head
);
814 event_recorder
->parent
->priv
->desc
= desc
;
817 loglevel
= *(*desc
->loglevel
);
819 loglevel
= LTTNG_UST_TRACEPOINT_LOGLEVEL_DEFAULT
;
820 if (desc
->model_emf_uri
)
821 uri
= *(desc
->model_emf_uri
);
825 lttng_ust_format_event_name(desc
, name
);
827 /* Fetch event ID from sessiond */
828 ret
= ustcomm_register_event(notify_socket
,
831 chan
->priv
->parent
.objd
,
834 desc
->tp_class
->signature
,
835 desc
->tp_class
->nr_fields
,
836 desc
->tp_class
->fields
,
838 &event_recorder
->priv
->id
);
840 DBG("Error (%d) registering event to sessiond", ret
);
841 goto sessiond_register_error
;
844 cds_list_add(&event_recorder_priv
->node
, &chan
->parent
->session
->priv
->events_head
);
845 cds_hlist_add_head(&event_recorder_priv
->hlist
, head
);
848 sessiond_register_error
:
849 free(event_recorder_priv
);
851 free(event_recorder
->parent
);
853 free(event_recorder
);
861 int lttng_event_notifier_create(const struct lttng_ust_event_desc
*desc
,
862 uint64_t token
, uint64_t error_counter_index
,
863 struct lttng_event_notifier_group
*event_notifier_group
)
865 struct lttng_ust_event_notifier
*event_notifier
;
866 struct lttng_ust_event_notifier_private
*event_notifier_priv
;
867 struct cds_hlist_head
*head
;
871 * Get the hashtable bucket the created lttng_event_notifier object
872 * should be inserted.
874 head
= borrow_hash_table_bucket(
875 event_notifier_group
->event_notifiers_ht
.table
,
876 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE
, desc
);
878 event_notifier
= zmalloc(sizeof(struct lttng_ust_event_notifier
));
879 if (!event_notifier
) {
883 event_notifier
->struct_size
= sizeof(struct lttng_ust_event_notifier
);
885 event_notifier
->parent
= zmalloc(sizeof(struct lttng_ust_event_common
));
886 if (!event_notifier
->parent
) {
890 event_notifier
->parent
->struct_size
= sizeof(struct lttng_ust_event_common
);
891 event_notifier
->parent
->type
= LTTNG_UST_EVENT_TYPE_NOTIFIER
;
892 event_notifier
->parent
->child
= event_notifier
;
894 event_notifier_priv
= zmalloc(sizeof(struct lttng_ust_event_notifier_private
));
895 if (!event_notifier_priv
) {
899 event_notifier
->priv
= event_notifier_priv
;
900 event_notifier_priv
->pub
= event_notifier
;
901 event_notifier
->parent
->priv
= &event_notifier_priv
->parent
;
902 event_notifier_priv
->parent
.pub
= event_notifier
->parent
;
904 event_notifier_priv
->group
= event_notifier_group
;
905 event_notifier_priv
->parent
.user_token
= token
;
906 event_notifier_priv
->error_counter_index
= error_counter_index
;
908 /* Event notifier will be enabled by enabler sync. */
909 event_notifier
->parent
->run_filter
= lttng_ust_interpret_event_filter
;
910 event_notifier
->parent
->enabled
= 0;
911 event_notifier_priv
->parent
.registered
= 0;
913 CDS_INIT_LIST_HEAD(&event_notifier
->parent
->priv
->filter_bytecode_runtime_head
);
914 CDS_INIT_LIST_HEAD(&event_notifier
->priv
->capture_bytecode_runtime_head
);
915 CDS_INIT_LIST_HEAD(&event_notifier_priv
->parent
.enablers_ref_head
);
916 event_notifier_priv
->parent
.desc
= desc
;
917 event_notifier
->notification_send
= lttng_event_notifier_notification_send
;
919 cds_list_add(&event_notifier_priv
->node
,
920 &event_notifier_group
->event_notifiers_head
);
921 cds_hlist_add_head(&event_notifier_priv
->hlist
, head
);
926 free(event_notifier
->parent
);
928 free(event_notifier
);
934 int lttng_desc_match_star_glob_enabler(const struct lttng_ust_event_desc
*desc
,
935 struct lttng_enabler
*enabler
)
937 char name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
939 unsigned int has_loglevel
= 0;
941 lttng_ust_format_event_name(desc
, name
);
942 assert(enabler
->format_type
== LTTNG_ENABLER_FORMAT_STAR_GLOB
);
943 if (!strutils_star_glob_match(enabler
->event_param
.name
, SIZE_MAX
,
946 if (desc
->loglevel
) {
947 loglevel
= *(*desc
->loglevel
);
950 if (!lttng_loglevel_match(loglevel
,
952 enabler
->event_param
.loglevel_type
,
953 enabler
->event_param
.loglevel
))
959 int lttng_desc_match_event_enabler(const struct lttng_ust_event_desc
*desc
,
960 struct lttng_enabler
*enabler
)
962 char name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
964 unsigned int has_loglevel
= 0;
966 lttng_ust_format_event_name(desc
, name
);
967 assert(enabler
->format_type
== LTTNG_ENABLER_FORMAT_EVENT
);
968 if (strcmp(name
, enabler
->event_param
.name
))
970 if (desc
->loglevel
) {
971 loglevel
= *(*desc
->loglevel
);
974 if (!lttng_loglevel_match(loglevel
,
976 enabler
->event_param
.loglevel_type
,
977 enabler
->event_param
.loglevel
))
983 int lttng_desc_match_enabler(const struct lttng_ust_event_desc
*desc
,
984 struct lttng_enabler
*enabler
)
986 switch (enabler
->format_type
) {
987 case LTTNG_ENABLER_FORMAT_STAR_GLOB
:
989 struct lttng_ust_excluder_node
*excluder
;
991 if (!lttng_desc_match_star_glob_enabler(desc
, enabler
)) {
996 * If the matching event matches with an excluder,
997 * return 'does not match'
999 cds_list_for_each_entry(excluder
, &enabler
->excluder_head
, node
) {
1002 for (count
= 0; count
< excluder
->excluder
.count
; count
++) {
1004 char *excluder_name
;
1006 excluder_name
= (char *) (excluder
->excluder
.names
)
1007 + count
* LTTNG_UST_ABI_SYM_NAME_LEN
;
1008 len
= strnlen(excluder_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1010 char name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
1012 lttng_ust_format_event_name(desc
, name
);
1013 if (strutils_star_glob_match(excluder_name
, len
, name
, SIZE_MAX
)) {
1021 case LTTNG_ENABLER_FORMAT_EVENT
:
1022 return lttng_desc_match_event_enabler(desc
, enabler
);
1029 int lttng_event_enabler_match_event(struct lttng_event_enabler
*event_enabler
,
1030 struct lttng_ust_event_recorder
*event_recorder
)
1032 if (lttng_desc_match_enabler(event_recorder
->parent
->priv
->desc
,
1033 lttng_event_enabler_as_enabler(event_enabler
))
1034 && event_recorder
->chan
== event_enabler
->chan
)
1041 int lttng_event_notifier_enabler_match_event_notifier(
1042 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
1043 struct lttng_ust_event_notifier
*event_notifier
)
1045 int desc_matches
= lttng_desc_match_enabler(event_notifier
->priv
->parent
.desc
,
1046 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
));
1048 if (desc_matches
&& event_notifier
->priv
->group
== event_notifier_enabler
->group
&&
1049 event_notifier
->priv
->parent
.user_token
== event_notifier_enabler
->user_token
)
1056 struct lttng_enabler_ref
*lttng_enabler_ref(
1057 struct cds_list_head
*enabler_ref_list
,
1058 struct lttng_enabler
*enabler
)
1060 struct lttng_enabler_ref
*enabler_ref
;
1062 cds_list_for_each_entry(enabler_ref
, enabler_ref_list
, node
) {
1063 if (enabler_ref
->ref
== enabler
)
1070 * Create struct lttng_event if it is missing and present in the list of
1071 * tracepoint probes.
1074 void lttng_create_event_recorder_if_missing(struct lttng_event_enabler
*event_enabler
)
1076 struct lttng_ust_session
*session
= event_enabler
->chan
->parent
->session
;
1077 struct lttng_ust_registered_probe
*reg_probe
;
1078 const struct lttng_ust_event_desc
*desc
;
1079 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
1081 struct cds_list_head
*probe_list
;
1083 probe_list
= lttng_get_probe_list_head();
1085 * For each probe event, if we find that a probe event matches
1086 * our enabler, create an associated lttng_event if not
1089 cds_list_for_each_entry(reg_probe
, probe_list
, head
) {
1090 const struct lttng_ust_probe_desc
*probe_desc
= reg_probe
->desc
;
1092 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
1095 struct cds_hlist_head
*head
;
1096 struct cds_hlist_node
*node
;
1098 desc
= probe_desc
->event_desc
[i
];
1099 if (!lttng_desc_match_enabler(desc
,
1100 lttng_event_enabler_as_enabler(event_enabler
)))
1103 head
= borrow_hash_table_bucket(
1104 session
->priv
->events_ht
.table
,
1105 LTTNG_UST_EVENT_HT_SIZE
, desc
);
1107 cds_hlist_for_each_entry(event_recorder_priv
, node
, head
, hlist
) {
1108 if (event_recorder_priv
->parent
.desc
== desc
1109 && event_recorder_priv
->pub
->chan
== event_enabler
->chan
) {
1118 * We need to create an event for this
1121 ret
= lttng_event_recorder_create(probe_desc
->event_desc
[i
],
1122 event_enabler
->chan
);
1124 DBG("Unable to create event \"%s:%s\", error %d\n",
1125 probe_desc
->provider_name
,
1126 probe_desc
->event_desc
[i
]->event_name
, ret
);
1133 void probe_provider_event_for_each(const struct lttng_ust_probe_desc
*provider_desc
,
1134 void (*event_func
)(struct lttng_ust_event_common
*event
))
1136 struct cds_hlist_node
*node
, *tmp_node
;
1137 struct cds_list_head
*sessionsp
;
1140 /* Get handle on list of sessions. */
1141 sessionsp
= lttng_get_sessions();
1144 * Iterate over all events in the probe provider descriptions and
1145 * sessions to queue the unregistration of the events.
1147 for (i
= 0; i
< provider_desc
->nr_events
; i
++) {
1148 const struct lttng_ust_event_desc
*event_desc
;
1149 struct lttng_event_notifier_group
*event_notifier_group
;
1150 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
1151 struct lttng_ust_event_notifier_private
*event_notifier_priv
;
1152 struct lttng_ust_session_private
*session_priv
;
1153 struct cds_hlist_head
*head
;
1155 event_desc
= provider_desc
->event_desc
[i
];
1158 * Iterate over all session to find the current event
1161 cds_list_for_each_entry(session_priv
, sessionsp
, node
) {
1163 * Get the list of events in the hashtable bucket and
1164 * iterate to find the event matching this descriptor.
1166 head
= borrow_hash_table_bucket(
1167 session_priv
->events_ht
.table
,
1168 LTTNG_UST_EVENT_HT_SIZE
, event_desc
);
1170 cds_hlist_for_each_entry_safe(event_recorder_priv
, node
, tmp_node
, head
, hlist
) {
1171 if (event_desc
== event_recorder_priv
->parent
.desc
) {
1172 event_func(event_recorder_priv
->parent
.pub
);
1179 * Iterate over all event_notifier groups to find the current event
1182 cds_list_for_each_entry(event_notifier_group
, &event_notifier_groups
, node
) {
1184 * Get the list of event_notifiers in the hashtable bucket and
1185 * iterate to find the event_notifier matching this
1188 head
= borrow_hash_table_bucket(
1189 event_notifier_group
->event_notifiers_ht
.table
,
1190 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE
, event_desc
);
1192 cds_hlist_for_each_entry_safe(event_notifier_priv
, node
, tmp_node
, head
, hlist
) {
1193 if (event_desc
== event_notifier_priv
->parent
.desc
) {
1194 event_func(event_notifier_priv
->parent
.pub
);
1203 void _event_enum_destroy(struct lttng_ust_event_common
*event
)
1206 switch (event
->type
) {
1207 case LTTNG_UST_EVENT_TYPE_RECORDER
:
1209 struct lttng_ust_event_recorder
*event_recorder
= event
->child
;
1210 struct lttng_ust_session
*session
= event_recorder
->chan
->parent
->session
;
1213 /* Destroy enums of the current event. */
1214 for (i
= 0; i
< event_recorder
->parent
->priv
->desc
->tp_class
->nr_fields
; i
++) {
1215 const struct lttng_ust_enum_desc
*enum_desc
;
1216 const struct lttng_ust_event_field
*field
;
1217 struct lttng_enum
*curr_enum
;
1219 field
= event_recorder
->parent
->priv
->desc
->tp_class
->fields
[i
];
1220 switch (field
->type
->type
) {
1221 case lttng_ust_type_enum
:
1222 enum_desc
= lttng_ust_get_type_enum(field
->type
)->desc
;
1228 curr_enum
= lttng_ust_enum_get_from_desc(session
, enum_desc
);
1230 _lttng_enum_destroy(curr_enum
);
1235 case LTTNG_UST_EVENT_TYPE_NOTIFIER
:
1240 /* Destroy event. */
1241 _lttng_event_destroy(event
);
1245 * Iterate over all the UST sessions to unregister and destroy all probes from
1246 * the probe provider descriptor received as argument. Must me called with the
1249 void lttng_probe_provider_unregister_events(
1250 const struct lttng_ust_probe_desc
*provider_desc
)
1253 * Iterate over all events in the probe provider descriptions and sessions
1254 * to queue the unregistration of the events.
1256 probe_provider_event_for_each(provider_desc
, _lttng_event_unregister
);
1258 /* Wait for grace period. */
1259 lttng_ust_urcu_synchronize_rcu();
1260 /* Prune the unregistration queue. */
1261 lttng_ust_tp_probe_prune_release_queue();
1264 * It is now safe to destroy the events and remove them from the event list
1267 probe_provider_event_for_each(provider_desc
, _event_enum_destroy
);
1271 * Create events associated with an event enabler (if not already present),
1272 * and add backward reference from the event to the enabler.
1275 int lttng_event_enabler_ref_event_recorders(struct lttng_event_enabler
*event_enabler
)
1277 struct lttng_ust_session
*session
= event_enabler
->chan
->parent
->session
;
1278 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
1280 if (!lttng_event_enabler_as_enabler(event_enabler
)->enabled
)
1283 /* First ensure that probe events are created for this enabler. */
1284 lttng_create_event_recorder_if_missing(event_enabler
);
1286 /* For each event matching enabler in session event list. */
1287 cds_list_for_each_entry(event_recorder_priv
, &session
->priv
->events_head
, node
) {
1288 struct lttng_enabler_ref
*enabler_ref
;
1290 if (!lttng_event_enabler_match_event(event_enabler
, event_recorder_priv
->pub
))
1293 enabler_ref
= lttng_enabler_ref(&event_recorder_priv
->parent
.enablers_ref_head
,
1294 lttng_event_enabler_as_enabler(event_enabler
));
1297 * If no backward ref, create it.
1298 * Add backward ref from event to enabler.
1300 enabler_ref
= zmalloc(sizeof(*enabler_ref
));
1303 enabler_ref
->ref
= lttng_event_enabler_as_enabler(
1305 cds_list_add(&enabler_ref
->node
,
1306 &event_recorder_priv
->parent
.enablers_ref_head
);
1310 * Link filter bytecodes if not linked yet.
1312 lttng_enabler_link_bytecode(event_recorder_priv
->parent
.desc
,
1313 &session
->priv
->ctx
,
1314 &event_recorder_priv
->parent
.filter_bytecode_runtime_head
,
1315 <tng_event_enabler_as_enabler(event_enabler
)->filter_bytecode_head
);
1317 /* TODO: merge event context. */
1324 * Called at library load: connect the probe on all enablers matching
1326 * Called with session mutex held.
1328 int lttng_fix_pending_events(void)
1330 struct lttng_ust_session_private
*session_priv
;
1332 cds_list_for_each_entry(session_priv
, &sessions
, node
) {
1334 * New probes have appeared, we need to re-sync all
1337 lttng_session_unsync_enablers(session_priv
->pub
);
1338 lttng_session_lazy_sync_event_enablers(session_priv
->pub
);
1343 int lttng_fix_pending_event_notifiers(void)
1345 struct lttng_event_notifier_group
*event_notifier_group
;
1347 cds_list_for_each_entry(event_notifier_group
, &event_notifier_groups
, node
) {
1349 * New probes have appeared, we need to re-sync all
1352 lttng_event_notifier_group_unsync_enablers(event_notifier_group
);
1353 lttng_event_notifier_group_sync_enablers(event_notifier_group
);
1359 * For each session of the owner thread, execute pending statedump.
1360 * Only dump state for the sessions owned by the caller thread, because
1361 * we don't keep ust_lock across the entire iteration.
1363 void lttng_handle_pending_statedump(void *owner
)
1365 struct lttng_ust_session_private
*session_priv
;
1367 /* Execute state dump */
1368 do_lttng_ust_statedump(owner
);
1370 /* Clear pending state dump */
1374 cds_list_for_each_entry(session_priv
, &sessions
, node
) {
1375 if (session_priv
->owner
!= owner
)
1377 if (!session_priv
->statedump_pending
)
1379 session_priv
->statedump_pending
= 0;
1387 void _lttng_event_destroy(struct lttng_ust_event_common
*event
)
1389 struct lttng_enabler_ref
*enabler_ref
, *tmp_enabler_ref
;
1391 lttng_free_event_filter_runtime(event
);
1392 /* Free event enabler refs */
1393 cds_list_for_each_entry_safe(enabler_ref
, tmp_enabler_ref
,
1394 &event
->priv
->enablers_ref_head
, node
)
1397 switch (event
->type
) {
1398 case LTTNG_UST_EVENT_TYPE_RECORDER
:
1400 struct lttng_ust_event_recorder
*event_recorder
= event
->child
;
1402 /* Remove from event list. */
1403 cds_list_del(&event_recorder
->priv
->node
);
1404 /* Remove from event hash table. */
1405 cds_hlist_del(&event_recorder
->priv
->hlist
);
1407 lttng_destroy_context(event_recorder
->priv
->ctx
);
1408 free(event_recorder
->parent
);
1409 free(event_recorder
->priv
);
1410 free(event_recorder
);
1413 case LTTNG_UST_EVENT_TYPE_NOTIFIER
:
1415 struct lttng_ust_event_notifier
*event_notifier
= event
->child
;
1417 /* Remove from event list. */
1418 cds_list_del(&event_notifier
->priv
->node
);
1419 /* Remove from event hash table. */
1420 cds_hlist_del(&event_notifier
->priv
->hlist
);
1422 free(event_notifier
->priv
);
1423 free(event_notifier
->parent
);
1424 free(event_notifier
);
1433 void _lttng_enum_destroy(struct lttng_enum
*_enum
)
1435 cds_list_del(&_enum
->node
);
1436 cds_hlist_del(&_enum
->hlist
);
1440 void lttng_ust_abi_events_exit(void)
1442 struct lttng_ust_session_private
*session_priv
, *tmpsession_priv
;
1444 cds_list_for_each_entry_safe(session_priv
, tmpsession_priv
, &sessions
, node
)
1445 lttng_session_destroy(session_priv
->pub
);
1449 * Enabler management.
1451 struct lttng_event_enabler
*lttng_event_enabler_create(
1452 enum lttng_enabler_format_type format_type
,
1453 struct lttng_ust_abi_event
*event_param
,
1454 struct lttng_ust_channel_buffer
*chan
)
1456 struct lttng_event_enabler
*event_enabler
;
1458 event_enabler
= zmalloc(sizeof(*event_enabler
));
1461 event_enabler
->base
.format_type
= format_type
;
1462 CDS_INIT_LIST_HEAD(&event_enabler
->base
.filter_bytecode_head
);
1463 CDS_INIT_LIST_HEAD(&event_enabler
->base
.excluder_head
);
1464 memcpy(&event_enabler
->base
.event_param
, event_param
,
1465 sizeof(event_enabler
->base
.event_param
));
1466 event_enabler
->chan
= chan
;
1468 event_enabler
->base
.enabled
= 0;
1469 cds_list_add(&event_enabler
->node
, &event_enabler
->chan
->parent
->session
->priv
->unsync_enablers_head
);
1470 lttng_session_lazy_sync_event_enablers(event_enabler
->chan
->parent
->session
);
1472 return event_enabler
;
1475 struct lttng_event_notifier_enabler
*lttng_event_notifier_enabler_create(
1476 struct lttng_event_notifier_group
*event_notifier_group
,
1477 enum lttng_enabler_format_type format_type
,
1478 struct lttng_ust_abi_event_notifier
*event_notifier_param
)
1480 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
1482 event_notifier_enabler
= zmalloc(sizeof(*event_notifier_enabler
));
1483 if (!event_notifier_enabler
)
1485 event_notifier_enabler
->base
.format_type
= format_type
;
1486 CDS_INIT_LIST_HEAD(&event_notifier_enabler
->base
.filter_bytecode_head
);
1487 CDS_INIT_LIST_HEAD(&event_notifier_enabler
->capture_bytecode_head
);
1488 CDS_INIT_LIST_HEAD(&event_notifier_enabler
->base
.excluder_head
);
1490 event_notifier_enabler
->user_token
= event_notifier_param
->event
.token
;
1491 event_notifier_enabler
->error_counter_index
= event_notifier_param
->error_counter_index
;
1492 event_notifier_enabler
->num_captures
= 0;
1494 memcpy(&event_notifier_enabler
->base
.event_param
.name
,
1495 event_notifier_param
->event
.name
,
1496 sizeof(event_notifier_enabler
->base
.event_param
.name
));
1497 event_notifier_enabler
->base
.event_param
.instrumentation
=
1498 event_notifier_param
->event
.instrumentation
;
1499 event_notifier_enabler
->base
.event_param
.loglevel
=
1500 event_notifier_param
->event
.loglevel
;
1501 event_notifier_enabler
->base
.event_param
.loglevel_type
=
1502 event_notifier_param
->event
.loglevel_type
;
1504 event_notifier_enabler
->base
.enabled
= 0;
1505 event_notifier_enabler
->group
= event_notifier_group
;
1507 cds_list_add(&event_notifier_enabler
->node
,
1508 &event_notifier_group
->unsync_enablers_head
);
1510 lttng_event_notifier_group_sync_enablers(event_notifier_group
);
1512 return event_notifier_enabler
;
1515 int lttng_event_enabler_enable(struct lttng_event_enabler
*event_enabler
)
1517 lttng_event_enabler_as_enabler(event_enabler
)->enabled
= 1;
1518 lttng_event_enabler_unsync(event_enabler
);
1519 lttng_session_lazy_sync_event_enablers(event_enabler
->chan
->parent
->session
);
1524 int lttng_event_enabler_disable(struct lttng_event_enabler
*event_enabler
)
1526 lttng_event_enabler_as_enabler(event_enabler
)->enabled
= 0;
1527 lttng_event_enabler_unsync(event_enabler
);
1528 lttng_session_lazy_sync_event_enablers(event_enabler
->chan
->parent
->session
);
1534 void _lttng_enabler_attach_filter_bytecode(struct lttng_enabler
*enabler
,
1535 struct lttng_ust_bytecode_node
**bytecode
)
1537 (*bytecode
)->enabler
= enabler
;
1538 cds_list_add_tail(&(*bytecode
)->node
, &enabler
->filter_bytecode_head
);
1539 /* Take ownership of bytecode */
1543 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler
*event_enabler
,
1544 struct lttng_ust_bytecode_node
**bytecode
)
1546 _lttng_enabler_attach_filter_bytecode(
1547 lttng_event_enabler_as_enabler(event_enabler
), bytecode
);
1548 lttng_event_enabler_unsync(event_enabler
);
1549 lttng_session_lazy_sync_event_enablers(event_enabler
->chan
->parent
->session
);
1554 void _lttng_enabler_attach_exclusion(struct lttng_enabler
*enabler
,
1555 struct lttng_ust_excluder_node
**excluder
)
1557 (*excluder
)->enabler
= enabler
;
1558 cds_list_add_tail(&(*excluder
)->node
, &enabler
->excluder_head
);
1559 /* Take ownership of excluder */
1563 int lttng_event_enabler_attach_exclusion(struct lttng_event_enabler
*event_enabler
,
1564 struct lttng_ust_excluder_node
**excluder
)
1566 _lttng_enabler_attach_exclusion(
1567 lttng_event_enabler_as_enabler(event_enabler
), excluder
);
1568 lttng_event_enabler_unsync(event_enabler
);
1569 lttng_session_lazy_sync_event_enablers(event_enabler
->chan
->parent
->session
);
1573 int lttng_event_notifier_enabler_enable(
1574 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
1576 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->enabled
= 1;
1577 lttng_event_notifier_enabler_unsync(event_notifier_enabler
);
1578 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
1583 int lttng_event_notifier_enabler_disable(
1584 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
1586 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->enabled
= 0;
1587 lttng_event_notifier_enabler_unsync(event_notifier_enabler
);
1588 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
1593 int lttng_event_notifier_enabler_attach_filter_bytecode(
1594 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
1595 struct lttng_ust_bytecode_node
**bytecode
)
1597 _lttng_enabler_attach_filter_bytecode(
1598 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
),
1600 lttng_event_notifier_enabler_unsync(event_notifier_enabler
);
1601 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
1605 int lttng_event_notifier_enabler_attach_capture_bytecode(
1606 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
1607 struct lttng_ust_bytecode_node
**bytecode
)
1609 (*bytecode
)->enabler
= lttng_event_notifier_enabler_as_enabler(
1610 event_notifier_enabler
);
1611 cds_list_add_tail(&(*bytecode
)->node
,
1612 &event_notifier_enabler
->capture_bytecode_head
);
1613 /* Take ownership of bytecode */
1615 event_notifier_enabler
->num_captures
++;
1616 lttng_event_notifier_enabler_unsync(event_notifier_enabler
);
1617 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
1621 int lttng_event_notifier_enabler_attach_exclusion(
1622 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
1623 struct lttng_ust_excluder_node
**excluder
)
1625 _lttng_enabler_attach_exclusion(
1626 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
),
1628 lttng_event_notifier_enabler_unsync(event_notifier_enabler
);
1629 lttng_event_notifier_group_sync_enablers(event_notifier_enabler
->group
);
1633 int lttng_attach_context(struct lttng_ust_abi_context
*context_param
,
1634 union lttng_ust_abi_args
*uargs
,
1635 struct lttng_ust_ctx
**ctx
, struct lttng_ust_session
*session
)
1638 * We cannot attach a context after trace has been started for a
1639 * session because the metadata does not allow expressing this
1640 * information outside of the original channel scope.
1642 if (session
->priv
->been_active
)
1645 switch (context_param
->ctx
) {
1646 case LTTNG_UST_ABI_CONTEXT_PTHREAD_ID
:
1647 return lttng_add_pthread_id_to_ctx(ctx
);
1648 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
1650 struct lttng_ust_abi_perf_counter_ctx
*perf_ctx_param
;
1652 perf_ctx_param
= &context_param
->u
.perf_counter
;
1653 return lttng_add_perf_counter_to_ctx(
1654 perf_ctx_param
->type
,
1655 perf_ctx_param
->config
,
1656 perf_ctx_param
->name
,
1659 case LTTNG_UST_ABI_CONTEXT_VTID
:
1660 return lttng_add_vtid_to_ctx(ctx
);
1661 case LTTNG_UST_ABI_CONTEXT_VPID
:
1662 return lttng_add_vpid_to_ctx(ctx
);
1663 case LTTNG_UST_ABI_CONTEXT_PROCNAME
:
1664 return lttng_add_procname_to_ctx(ctx
);
1665 case LTTNG_UST_ABI_CONTEXT_IP
:
1666 return lttng_add_ip_to_ctx(ctx
);
1667 case LTTNG_UST_ABI_CONTEXT_CPU_ID
:
1668 return lttng_add_cpu_id_to_ctx(ctx
);
1669 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
1670 return lttng_ust_add_app_context_to_ctx_rcu(uargs
->app_context
.ctxname
,
1672 case LTTNG_UST_ABI_CONTEXT_CGROUP_NS
:
1673 return lttng_add_cgroup_ns_to_ctx(ctx
);
1674 case LTTNG_UST_ABI_CONTEXT_IPC_NS
:
1675 return lttng_add_ipc_ns_to_ctx(ctx
);
1676 case LTTNG_UST_ABI_CONTEXT_MNT_NS
:
1677 return lttng_add_mnt_ns_to_ctx(ctx
);
1678 case LTTNG_UST_ABI_CONTEXT_NET_NS
:
1679 return lttng_add_net_ns_to_ctx(ctx
);
1680 case LTTNG_UST_ABI_CONTEXT_PID_NS
:
1681 return lttng_add_pid_ns_to_ctx(ctx
);
1682 case LTTNG_UST_ABI_CONTEXT_TIME_NS
:
1683 return lttng_add_time_ns_to_ctx(ctx
);
1684 case LTTNG_UST_ABI_CONTEXT_USER_NS
:
1685 return lttng_add_user_ns_to_ctx(ctx
);
1686 case LTTNG_UST_ABI_CONTEXT_UTS_NS
:
1687 return lttng_add_uts_ns_to_ctx(ctx
);
1688 case LTTNG_UST_ABI_CONTEXT_VUID
:
1689 return lttng_add_vuid_to_ctx(ctx
);
1690 case LTTNG_UST_ABI_CONTEXT_VEUID
:
1691 return lttng_add_veuid_to_ctx(ctx
);
1692 case LTTNG_UST_ABI_CONTEXT_VSUID
:
1693 return lttng_add_vsuid_to_ctx(ctx
);
1694 case LTTNG_UST_ABI_CONTEXT_VGID
:
1695 return lttng_add_vgid_to_ctx(ctx
);
1696 case LTTNG_UST_ABI_CONTEXT_VEGID
:
1697 return lttng_add_vegid_to_ctx(ctx
);
1698 case LTTNG_UST_ABI_CONTEXT_VSGID
:
1699 return lttng_add_vsgid_to_ctx(ctx
);
1705 int lttng_event_enabler_attach_context(
1706 struct lttng_event_enabler
*enabler
__attribute__((unused
)),
1707 struct lttng_ust_abi_context
*context_param
__attribute__((unused
)))
1712 void lttng_event_enabler_destroy(struct lttng_event_enabler
*event_enabler
)
1714 if (!event_enabler
) {
1717 cds_list_del(&event_enabler
->node
);
1719 lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler
));
1721 lttng_destroy_context(event_enabler
->ctx
);
1722 free(event_enabler
);
1726 * lttng_session_sync_event_enablers should be called just before starting a
1730 void lttng_session_sync_event_enablers(struct lttng_ust_session
*session
)
1732 struct lttng_event_enabler
*event_enabler
;
1733 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
1734 struct cds_list_head iter_list
;
1737 * lttng_event_enabler_ref_event_recorders can cause lazy probes
1738 * to add items to the unsync_enablers_head list. Iterate on a
1739 * local copy of that list until it is stable (empty).
1742 CDS_INIT_LIST_HEAD(&iter_list
);
1743 cds_list_splice(&session
->priv
->unsync_enablers_head
, &iter_list
);
1744 CDS_INIT_LIST_HEAD(&session
->priv
->unsync_enablers_head
);
1745 cds_list_for_each_entry(event_enabler
, &iter_list
, node
)
1746 lttng_event_enabler_ref_event_recorders(event_enabler
);
1747 cds_list_splice(&iter_list
, &session
->priv
->sync_enablers_head
);
1748 } while (!cds_list_empty(&session
->priv
->unsync_enablers_head
));
1751 * For each event, if at least one of its enablers is enabled,
1752 * and its channel and session transient states are enabled, we
1753 * enable the event, else we disable it.
1755 cds_list_for_each_entry(event_recorder_priv
, &session
->priv
->events_head
, node
) {
1756 struct lttng_enabler_ref
*enabler_ref
;
1757 struct lttng_ust_bytecode_runtime
*runtime
;
1758 int enabled
= 0, has_enablers_without_filter_bytecode
= 0;
1762 cds_list_for_each_entry(enabler_ref
,
1763 &event_recorder_priv
->parent
.enablers_ref_head
, node
) {
1764 if (enabler_ref
->ref
->enabled
) {
1770 * Enabled state is based on union of enablers, with
1771 * intesection of session and channel transient enable
1774 enabled
= enabled
&& session
->priv
->tstate
&& event_recorder_priv
->pub
->chan
->priv
->parent
.tstate
;
1776 CMM_STORE_SHARED(event_recorder_priv
->pub
->parent
->enabled
, enabled
);
1778 * Sync tracepoint registration with event enabled
1782 if (!event_recorder_priv
->parent
.registered
)
1783 register_event(event_recorder_priv
->parent
.pub
);
1785 if (event_recorder_priv
->parent
.registered
)
1786 unregister_event(event_recorder_priv
->parent
.pub
);
1789 /* Check if has enablers without bytecode enabled */
1790 cds_list_for_each_entry(enabler_ref
,
1791 &event_recorder_priv
->parent
.enablers_ref_head
, node
) {
1792 if (enabler_ref
->ref
->enabled
1793 && cds_list_empty(&enabler_ref
->ref
->filter_bytecode_head
)) {
1794 has_enablers_without_filter_bytecode
= 1;
1798 event_recorder_priv
->parent
.has_enablers_without_filter_bytecode
=
1799 has_enablers_without_filter_bytecode
;
1801 /* Enable filters */
1802 cds_list_for_each_entry(runtime
,
1803 &event_recorder_priv
->parent
.filter_bytecode_runtime_head
, node
) {
1804 lttng_bytecode_sync_state(runtime
);
1807 CMM_STORE_SHARED(event_recorder_priv
->parent
.pub
->eval_filter
,
1808 !(has_enablers_without_filter_bytecode
|| !nr_filters
));
1810 lttng_ust_tp_probe_prune_release_queue();
1814 void lttng_create_event_notifier_if_missing(
1815 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
1817 struct lttng_event_notifier_group
*event_notifier_group
= event_notifier_enabler
->group
;
1818 struct lttng_ust_registered_probe
*reg_probe
;
1819 struct cds_list_head
*probe_list
;
1822 probe_list
= lttng_get_probe_list_head();
1824 cds_list_for_each_entry(reg_probe
, probe_list
, head
) {
1825 const struct lttng_ust_probe_desc
*probe_desc
= reg_probe
->desc
;
1827 for (i
= 0; i
< probe_desc
->nr_events
; i
++) {
1830 const struct lttng_ust_event_desc
*desc
;
1831 struct lttng_ust_event_notifier_private
*event_notifier_priv
;
1832 struct cds_hlist_head
*head
;
1833 struct cds_hlist_node
*node
;
1835 desc
= probe_desc
->event_desc
[i
];
1837 if (!lttng_desc_match_enabler(desc
,
1838 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)))
1842 * Given the current event_notifier group, get the bucket that
1843 * the target event_notifier would be if it was already
1846 head
= borrow_hash_table_bucket(
1847 event_notifier_group
->event_notifiers_ht
.table
,
1848 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE
, desc
);
1850 cds_hlist_for_each_entry(event_notifier_priv
, node
, head
, hlist
) {
1852 * Check if event_notifier already exists by checking
1853 * if the event_notifier and enabler share the same
1854 * description and id.
1856 if (event_notifier_priv
->parent
.desc
== desc
&&
1857 event_notifier_priv
->parent
.user_token
== event_notifier_enabler
->user_token
) {
1867 * We need to create a event_notifier for this event probe.
1869 ret
= lttng_event_notifier_create(desc
,
1870 event_notifier_enabler
->user_token
,
1871 event_notifier_enabler
->error_counter_index
,
1872 event_notifier_group
);
1874 DBG("Unable to create event_notifier \"%s:%s\", error %d\n",
1875 probe_desc
->provider_name
,
1876 probe_desc
->event_desc
[i
]->event_name
, ret
);
1883 * Create event_notifiers associated with a event_notifier enabler (if not already present).
1886 int lttng_event_notifier_enabler_ref_event_notifiers(
1887 struct lttng_event_notifier_enabler
*event_notifier_enabler
)
1889 struct lttng_event_notifier_group
*event_notifier_group
= event_notifier_enabler
->group
;
1890 struct lttng_ust_event_notifier_private
*event_notifier_priv
;
1893 * Only try to create event_notifiers for enablers that are enabled, the user
1894 * might still be attaching filter or exclusion to the
1895 * event_notifier_enabler.
1897 if (!lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->enabled
)
1900 /* First, ensure that probe event_notifiers are created for this enabler. */
1901 lttng_create_event_notifier_if_missing(event_notifier_enabler
);
1903 /* Link the created event_notifier with its associated enabler. */
1904 cds_list_for_each_entry(event_notifier_priv
, &event_notifier_group
->event_notifiers_head
, node
) {
1905 struct lttng_enabler_ref
*enabler_ref
;
1907 if (!lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler
, event_notifier_priv
->pub
))
1910 enabler_ref
= lttng_enabler_ref(&event_notifier_priv
->parent
.enablers_ref_head
,
1911 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler
));
1914 * If no backward ref, create it.
1915 * Add backward ref from event_notifier to enabler.
1917 enabler_ref
= zmalloc(sizeof(*enabler_ref
));
1921 enabler_ref
->ref
= lttng_event_notifier_enabler_as_enabler(
1922 event_notifier_enabler
);
1923 cds_list_add(&enabler_ref
->node
,
1924 &event_notifier_priv
->parent
.enablers_ref_head
);
1928 * Link filter bytecodes if not linked yet.
1930 lttng_enabler_link_bytecode(event_notifier_priv
->parent
.desc
,
1931 &event_notifier_group
->ctx
,
1932 &event_notifier_priv
->parent
.filter_bytecode_runtime_head
,
1933 <tng_event_notifier_enabler_as_enabler(event_notifier_enabler
)->filter_bytecode_head
);
1936 * Link capture bytecodes if not linked yet.
1938 lttng_enabler_link_bytecode(event_notifier_priv
->parent
.desc
,
1939 &event_notifier_group
->ctx
, &event_notifier_priv
->capture_bytecode_runtime_head
,
1940 &event_notifier_enabler
->capture_bytecode_head
);
1942 event_notifier_priv
->num_captures
= event_notifier_enabler
->num_captures
;
1949 void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
*event_notifier_group
)
1951 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
1952 struct lttng_ust_event_notifier_private
*event_notifier_priv
;
1953 struct cds_list_head iter_list
;
1956 * lttng_event_notifier_enabler_ref_event_notifiers can cause
1957 * lazy probes to add items to the unsync_enablers_head list.
1958 * Iterate on a local copy of that list until it is stable
1962 CDS_INIT_LIST_HEAD(&iter_list
);
1963 cds_list_splice(&event_notifier_group
->unsync_enablers_head
, &iter_list
);
1964 CDS_INIT_LIST_HEAD(&event_notifier_group
->unsync_enablers_head
);
1965 cds_list_for_each_entry(event_notifier_enabler
, &iter_list
, node
)
1966 lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_enabler
);
1967 cds_list_splice(&iter_list
, &event_notifier_group
->sync_enablers_head
);
1968 } while (!cds_list_empty(&event_notifier_group
->unsync_enablers_head
));
1971 * For each event_notifier, if at least one of its enablers is enabled,
1972 * we enable the event_notifier, else we disable it.
1974 cds_list_for_each_entry(event_notifier_priv
, &event_notifier_group
->event_notifiers_head
, node
) {
1975 struct lttng_enabler_ref
*enabler_ref
;
1976 struct lttng_ust_bytecode_runtime
*runtime
;
1977 int enabled
= 0, has_enablers_without_filter_bytecode
= 0;
1978 int nr_filters
= 0, nr_captures
= 0;
1980 /* Enable event_notifiers */
1981 cds_list_for_each_entry(enabler_ref
,
1982 &event_notifier_priv
->parent
.enablers_ref_head
, node
) {
1983 if (enabler_ref
->ref
->enabled
) {
1989 CMM_STORE_SHARED(event_notifier_priv
->pub
->parent
->enabled
, enabled
);
1991 * Sync tracepoint registration with event_notifier enabled
1995 if (!event_notifier_priv
->parent
.registered
)
1996 register_event(event_notifier_priv
->parent
.pub
);
1998 if (event_notifier_priv
->parent
.registered
)
1999 unregister_event(event_notifier_priv
->parent
.pub
);
2002 /* Check if has enablers without bytecode enabled */
2003 cds_list_for_each_entry(enabler_ref
,
2004 &event_notifier_priv
->parent
.enablers_ref_head
, node
) {
2005 if (enabler_ref
->ref
->enabled
2006 && cds_list_empty(&enabler_ref
->ref
->filter_bytecode_head
)) {
2007 has_enablers_without_filter_bytecode
= 1;
2011 event_notifier_priv
->parent
.has_enablers_without_filter_bytecode
=
2012 has_enablers_without_filter_bytecode
;
2014 /* Enable filters */
2015 cds_list_for_each_entry(runtime
,
2016 &event_notifier_priv
->parent
.filter_bytecode_runtime_head
, node
) {
2017 lttng_bytecode_sync_state(runtime
);
2020 CMM_STORE_SHARED(event_notifier_priv
->parent
.pub
->eval_filter
,
2021 !(has_enablers_without_filter_bytecode
|| !nr_filters
));
2023 /* Enable captures. */
2024 cds_list_for_each_entry(runtime
,
2025 &event_notifier_priv
->capture_bytecode_runtime_head
, node
) {
2026 lttng_bytecode_sync_state(runtime
);
2029 CMM_STORE_SHARED(event_notifier_priv
->pub
->eval_capture
,
2032 lttng_ust_tp_probe_prune_release_queue();
2036 * Apply enablers to session events, adding events to session if need
2037 * be. It is required after each modification applied to an active
2038 * session, and right before session "start".
2039 * "lazy" sync means we only sync if required.
2042 void lttng_session_lazy_sync_event_enablers(struct lttng_ust_session
*session
)
2044 /* We can skip if session is not active */
2045 if (!session
->active
)
2047 lttng_session_sync_event_enablers(session
);
2051 * Update all sessions with the given app context.
2052 * Called with ust lock held.
2053 * This is invoked when an application context gets loaded/unloaded. It
2054 * ensures the context callbacks are in sync with the application
2055 * context (either app context callbacks, or dummy callbacks).
2057 void lttng_ust_context_set_session_provider(const char *name
,
2058 size_t (*get_size
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2060 void (*record
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2061 struct lttng_ust_ring_buffer_ctx
*ctx
,
2062 struct lttng_ust_channel_buffer
*chan
),
2063 void (*get_value
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2064 struct lttng_ust_ctx_value
*value
))
2066 struct lttng_ust_session_private
*session_priv
;
2068 cds_list_for_each_entry(session_priv
, &sessions
, node
) {
2069 struct lttng_ust_channel_buffer_private
*chan
;
2070 struct lttng_ust_event_recorder_private
*event_recorder_priv
;
2073 ret
= lttng_ust_context_set_provider_rcu(&session_priv
->ctx
,
2074 name
, get_size
, record
, get_value
);
2077 cds_list_for_each_entry(chan
, &session_priv
->chan_head
, node
) {
2078 ret
= lttng_ust_context_set_provider_rcu(&chan
->ctx
,
2079 name
, get_size
, record
, get_value
);
2083 cds_list_for_each_entry(event_recorder_priv
, &session_priv
->events_head
, node
) {
2084 ret
= lttng_ust_context_set_provider_rcu(&event_recorder_priv
->ctx
,
2085 name
, get_size
, record
, get_value
);
2093 * Update all event_notifier groups with the given app context.
2094 * Called with ust lock held.
2095 * This is invoked when an application context gets loaded/unloaded. It
2096 * ensures the context callbacks are in sync with the application
2097 * context (either app context callbacks, or dummy callbacks).
2099 void lttng_ust_context_set_event_notifier_group_provider(const char *name
,
2100 size_t (*get_size
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2102 void (*record
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2103 struct lttng_ust_ring_buffer_ctx
*ctx
,
2104 struct lttng_ust_channel_buffer
*chan
),
2105 void (*get_value
)(void *priv
, struct lttng_ust_probe_ctx
*probe_ctx
,
2106 struct lttng_ust_ctx_value
*value
))
2108 struct lttng_event_notifier_group
*event_notifier_group
;
2110 cds_list_for_each_entry(event_notifier_group
, &event_notifier_groups
, node
) {
2113 ret
= lttng_ust_context_set_provider_rcu(
2114 &event_notifier_group
->ctx
,
2115 name
, get_size
, record
, get_value
);
2121 int lttng_ust_session_uuid_validate(struct lttng_ust_session
*session
,
2122 unsigned char *uuid
)
2126 /* Compare UUID with session. */
2127 if (session
->priv
->uuid_set
) {
2128 if (memcmp(session
->priv
->uuid
, uuid
, LTTNG_UST_UUID_LEN
)) {
2132 memcpy(session
->priv
->uuid
, uuid
, LTTNG_UST_UUID_LEN
);
2133 session
->priv
->uuid_set
= true;