2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
10 #include <urcu/list.h>
13 #include <common/compat/errno.h>
14 #include <lttng/lttng.h>
15 #include <lttng/condition/condition.h>
16 #include <lttng/condition/on-event.h>
17 #include <lttng/event-rule/event-rule.h>
18 #include <lttng/event-rule/event-rule-internal.h>
19 #include <common/bytecode/bytecode.h>
20 #include <common/error.h>
21 #include <common/sessiond-comm/sessiond-comm.h>
22 #include <common/filter.h>
23 #include <common/kernel-ctl/kernel-ctl.h>
24 #include <common/context.h>
29 #include "lttng-sessiond.h"
30 #include "lttng-ust-ctl.h"
31 #include "lttng-ust-error.h"
33 #include "trace-kernel.h"
34 #include "trace-ust.h"
39 * Add unique UST event based on the event name, filter bytecode and loglevel.
41 static void add_unique_ust_event(struct lttng_ht
*ht
,
42 struct ltt_ust_event
*event
, struct lttng_map_key
*map_key
)
44 struct cds_lfht_node
*node_ptr
;
45 struct ltt_ust_ht_key key
;
51 key
.name
= event
->attr
.name
;
52 key
.filter
= (struct lttng_bytecode
*) event
->filter
;
53 key
.loglevel_type
= event
->attr
.loglevel_type
;
54 key
.loglevel_value
= event
->attr
.loglevel
;
55 key
.exclusion
= event
->exclusion
;
58 node_ptr
= cds_lfht_add_unique(ht
->ht
,
59 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
60 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
61 assert(node_ptr
== &event
->node
.node
);
65 * Disable kernel tracepoint events for a channel from the kernel session of
66 * a specified event_name and event type.
67 * On type LTTNG_EVENT_ALL all events with event_name are disabled.
68 * If event_name is NULL all events of the specified type are disabled.
70 int event_kernel_disable_event(struct ltt_kernel_channel
*kchan
,
71 const char *event_name
, enum lttng_event_type type
)
73 int ret
, error
= 0, found
= 0;
74 struct ltt_kernel_event
*kevent
;
78 /* For each event in the kernel session */
79 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
80 if (type
!= LTTNG_EVENT_ALL
&& kevent
->type
!= type
)
82 if (event_name
!= NULL
&& strcmp(event_name
, kevent
->event
->name
)) {
86 ret
= kernel_disable_event(kevent
);
92 DBG("Disable kernel event: found %d events with name: %s and type: %d",
93 found
, event_name
? event_name
: "NULL", type
);
95 if (event_name
!= NULL
&& !found
) {
96 ret
= LTTNG_ERR_NO_EVENT
;
98 ret
= error
? LTTNG_ERR_KERN_DISABLE_FAIL
: LTTNG_OK
;
105 * Enable kernel tracepoint event for a channel from the kernel session.
106 * We own filter_expression and filter.
108 int event_kernel_enable_event(struct ltt_kernel_channel
*kchan
,
109 struct lttng_event
*event
, char *filter_expression
,
110 struct lttng_bytecode
*filter
)
113 struct ltt_kernel_event
*kevent
;
118 kevent
= trace_kernel_find_event(&kchan
->events_list
,
119 0, event
->name
, event
->type
, filter
);
120 if (kevent
== NULL
) {
121 ret
= kernel_create_event(event
, kchan
, filter_expression
, filter
);
122 /* We have passed ownership */
123 filter_expression
= NULL
;
128 } else if (kevent
->enabled
== 0) {
129 ret
= kernel_enable_event(kevent
);
131 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
135 /* At this point, the event is considered enabled */
136 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
142 free(filter_expression
);
148 * Disable kernel tracepoint events for a map from the kernel session of
149 * a specified event_name and event type.
150 * On type LTTNG_EVENT_ALL all events with event_name are disabled.
151 * If event_name is NULL all events of the specified type are disabled.
153 int map_event_kernel_disable_event(struct ltt_kernel_map
*kmap
,
154 uint64_t action_tracer_token
)
156 struct ltt_kernel_event_counter
*kevent_counter
;
157 struct lttng_ht_iter iter
;
158 const struct lttng_ht_node_u64
*node
;
159 enum lttng_error_code ret_code
;
164 lttng_ht_lookup(kmap
->event_counters_ht
, (void *) &action_tracer_token
, &iter
);
165 node
= lttng_ht_iter_get_node_u64(&iter
);
167 kevent_counter
= caa_container_of(node
,
168 struct ltt_kernel_event_counter
, ht_node
);
169 ret
= kernctl_disable(kevent_counter
->fd
);
171 ret_code
= LTTNG_ERR_KERN_DISABLE_FAIL
;
174 kevent_counter
->enabled
= false;
175 DBG("Disable kernel event counter");
177 ret_code
= LTTNG_ERR_NO_EVENT
;
187 * Enable kernel tracepoint event for a map from the kernel session.
188 * We own filter_expression and filter.
190 int map_event_kernel_enable_event(struct ltt_kernel_map
*kmap
,
191 const struct lttng_credentials
*creds
,
192 uint64_t action_tracer_token
,
193 const struct lttng_event_rule
*event_rule
,
194 struct lttng_map_key
*key
)
197 enum lttng_error_code ret_code
;
198 struct ltt_kernel_event_counter
*kevent_counter
;
199 struct lttng_ht_iter iter
;
200 const struct lttng_ht_node_u64
*node
;
206 lttng_ht_lookup(kmap
->event_counters_ht
, (void *) &action_tracer_token
, &iter
);
207 node
= lttng_ht_iter_get_node_u64(&iter
);
209 kevent_counter
= caa_container_of(node
,
210 struct ltt_kernel_event_counter
, ht_node
);
211 if (kevent_counter
->enabled
) {
212 /* At this point, the event is considered enabled */
213 ret_code
= LTTNG_ERR_KERN_EVENT_EXIST
;
217 err
= kernctl_enable(kevent_counter
->fd
);
221 ret_code
= LTTNG_ERR_KERN_EVENT_EXIST
;
224 PERROR("enable kernel event counter");
225 ret_code
= LTTNG_ERR_KERN_ENABLE_FAIL
;
233 ret_code
= kernel_create_event_counter(kmap
, creds
,
234 action_tracer_token
, event_rule
, key
);
235 if (ret_code
!= LTTNG_OK
) {
246 * ============================
247 * UST : The Ultimate Frontier!
248 * ============================
252 * Enable UST tracepoint event for a channel from a UST session.
253 * We own filter_expression, filter, and exclusion.
255 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
256 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
257 char *filter_expression
,
258 struct lttng_bytecode
*filter
,
259 struct lttng_event_exclusion
*exclusion
,
262 int ret
= LTTNG_OK
, to_create
= 0;
263 struct ltt_ust_event
*uevent
;
266 * FIXME: Frdeso. The tracer token should probably me set for regular
269 uint64_t tracer_token
= 0;
277 uevent
= trace_ust_find_event(uchan
->events
, 0, event
->name
, filter
,
278 (enum lttng_ust_loglevel_type
) event
->loglevel_type
,
279 event
->loglevel
, exclusion
, NULL
);
281 ret
= trace_ust_create_event(tracer_token
, event
->name
, NULL
, event
->type
,
282 event
->loglevel_type
, event
->loglevel
,
283 filter_expression
, filter
, exclusion
,
284 internal_event
, &uevent
);
285 /* We have passed ownership */
286 filter_expression
= NULL
;
289 if (ret
!= LTTNG_OK
) {
293 /* Valid to set it after the goto error since uevent is still NULL */
297 if (uevent
->enabled
) {
298 /* It's already enabled so everything is OK */
300 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
306 /* Add ltt ust event to channel */
307 add_unique_ust_event(uchan
->events
, uevent
, NULL
);
310 if (!usess
->active
) {
315 /* Create event on all UST registered apps for session */
316 ret
= ust_app_create_channel_event_glb(usess
, uchan
, uevent
);
318 /* Enable event on all UST registered apps for session */
319 ret
= ust_app_enable_channel_event_glb(usess
, uchan
, uevent
);
323 if (ret
== -LTTNG_UST_ERR_EXIST
) {
324 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
327 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
332 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
333 to_create
? "created" : "enabled", uchan
->name
);
339 free(filter_expression
);
346 * Only destroy event on creation time (not enabling time) because if the
347 * event is found in the channel (to_create == 0), it means that at some
348 * point the enable_event worked and it's thus valid to keep it alive.
349 * Destroying it also implies that we also destroy it's shadow copy to sync
353 /* In this code path, the uevent was not added to the hash table */
354 trace_ust_destroy_event(uevent
);
357 free(filter_expression
);
364 * Enable UST tracepoint event for a map from a UST session.
366 enum lttng_error_code
map_event_ust_enable_tracepoint(
367 struct ltt_ust_session
*usess
,
368 struct ltt_ust_map
*umap
,
369 uint64_t tracer_token
,
371 struct lttng_map_key
*key
,
372 enum lttng_event_type ev_type
,
373 enum lttng_loglevel_type ev_loglevel_type
,
374 int ev_loglevel_value
,
375 char *_filter_expression
,
376 struct lttng_bytecode
*_filter
,
377 struct lttng_event_exclusion
*exclusion
,
380 enum lttng_error_code ret_code
= LTTNG_OK
;
381 int ret
, to_create
= 0;
382 struct ltt_ust_event
*uevent
;
383 struct lttng_bytecode
*filter
= NULL
;
384 char *filter_expression
= NULL
;
391 * FIXME: FRDESO: this function was copied from ust-app.c
393 if (_filter_expression
) {
394 filter_expression
= strdup(_filter_expression
);
398 filter
= zmalloc(sizeof(*filter
) + _filter
->len
);
400 PERROR("Failed to allocate lttng_ust_filter_bytecode: bytecode len = %" PRIu32
" bytes", _filter
->len
);
404 assert(sizeof(struct lttng_bytecode
) ==
405 sizeof(struct lttng_ust_filter_bytecode
));
406 memcpy(filter
, _filter
, sizeof(*filter
) + _filter
->len
);
411 uevent
= trace_ust_find_event(umap
->events
, tracer_token
, ev_name
, filter
,
412 (enum lttng_ust_loglevel_type
) ev_loglevel_type
,
413 ev_loglevel_value
, exclusion
, key
);
415 ret_code
= trace_ust_create_event(tracer_token
, ev_name
, key
, ev_type
,
416 ev_loglevel_type
, ev_loglevel_value
,
417 filter_expression
, filter
, exclusion
,
418 internal_event
, &uevent
);
419 /* We have passed ownership */
420 filter_expression
= NULL
;
423 if (ret_code
!= LTTNG_OK
) {
427 /* Valid to set it after the goto error since uevent is still NULL */
431 if (uevent
->enabled
) {
432 /* It's already enabled so everything is OK */
434 ret_code
= LTTNG_ERR_UST_EVENT_ENABLED
;
440 /* Add ltt ust event to map */
441 add_unique_ust_event(umap
->events
, uevent
, key
);
444 if (!usess
->active
) {
449 /* Create event on all UST registered apps for session */
450 ret
= ust_app_create_map_event_glb(usess
, umap
, uevent
);
452 /* Enable event on all UST registered apps for session */
453 ret
= ust_app_enable_map_event_glb(usess
, umap
, uevent
);
457 if (ret
== -LTTNG_UST_ERR_EXIST
) {
458 ret_code
= LTTNG_ERR_UST_EVENT_EXIST
;
461 ret_code
= LTTNG_ERR_UST_ENABLE_FAIL
;
466 DBG("Event UST %s %s in map %s", uevent
->attr
.name
,
467 to_create
? "created" : "enabled", umap
->name
);
473 free(filter_expression
);
480 * Only destroy event on creation time (not enabling time) because if the
481 * event is found in the map (to_create == 0), it means that at some
482 * point the enable_event worked and it's thus valid to keep it alive.
483 * Destroying it also implies that we also destroy it's shadow copy to sync
487 /* In this code path, the uevent was not added to the hash table */
488 trace_ust_destroy_event(uevent
);
491 free(filter_expression
);
498 * Disable UST tracepoint of a channel from a UST session.
500 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
501 struct ltt_ust_channel
*uchan
, const char *event_name
)
504 struct ltt_ust_event
*uevent
;
505 struct lttng_ht_node_str
*node
;
506 struct lttng_ht_iter iter
;
518 * We use a custom lookup since we need the iterator for the next_duplicate
519 * call in the do while loop below.
521 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
522 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
523 node
= lttng_ht_iter_get_node_str(&iter
);
525 DBG2("Trace UST event NOT found by name %s", event_name
);
526 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
531 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
534 if (uevent
->enabled
== 0) {
535 /* It's already disabled so everything is OK */
539 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
542 if (!usess
->active
) {
545 ret
= ust_app_disable_channel_event_glb(usess
, uchan
, uevent
);
546 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
547 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
551 /* Get next duplicate event by name. */
552 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
553 event_name
, &iter
.iter
);
554 node
= lttng_ht_iter_get_node_str(&iter
);
565 * Disable UST tracepoint of a map from a UST session.
567 enum lttng_error_code
map_event_ust_disable_tracepoint(
568 struct ltt_ust_session
*usess
,
569 struct ltt_ust_map
*umap
,
570 uint64_t tracer_token
,
572 struct lttng_map_key
*key
,
573 enum lttng_event_type ev_type
,
574 enum lttng_loglevel_type ev_loglevel_type
,
575 int ev_loglevel_value
,
576 char *filter_expression
,
577 struct lttng_bytecode
*filter
,
578 struct lttng_event_exclusion
*exclusion
,
582 enum lttng_error_code ret_code
;
583 struct ltt_ust_event
*uevent
;
592 * FIXME: frdeso: We need to pass all the parameters to find the right
595 uevent
= trace_ust_find_event(umap
->events
, tracer_token
, event_name
, filter
,
596 (enum lttng_ust_loglevel_type
) ev_loglevel_type
,
597 ev_loglevel_value
, exclusion
, key
);
600 if (uevent
->enabled
== 0) {
606 DBG2("Event UST %s disabled in map %s", uevent
->attr
.name
,
609 if (!usess
->active
) {
614 ret
= ust_app_disable_map_event_glb(usess
, umap
, uevent
);
615 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
616 ret_code
= LTTNG_ERR_UST_DISABLE_FAIL
;
628 * Disable all UST tracepoints for a channel from a UST session.
630 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
631 struct ltt_ust_channel
*uchan
)
633 int ret
, i
, size
, error
= 0;
634 struct lttng_ht_iter iter
;
635 struct ltt_ust_event
*uevent
= NULL
;
636 struct lttng_event
*events
= NULL
;
643 /* Disabling existing events */
644 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
646 if (uevent
->enabled
== 1) {
647 ret
= event_ust_disable_tracepoint(usess
, uchan
,
650 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
656 /* Get all UST available events */
657 size
= ust_app_list_events(&events
);
659 ret
= LTTNG_ERR_UST_LIST_FAIL
;
663 for (i
= 0; i
< size
; i
++) {
664 ret
= event_ust_disable_tracepoint(usess
, uchan
,
667 /* Continue to disable the rest... */
668 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
673 ret
= error
? error
: LTTNG_OK
;
681 * Disable all UST tracepoints for a map from a UST session.
683 int map_event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
684 struct ltt_ust_map
*umap
)
687 struct lttng_ht_iter iter
;
688 struct ltt_ust_event
*uevent
= NULL
;
689 struct lttng_event
*events
= NULL
;
696 /* Disabling existing events */
697 cds_lfht_for_each_entry(umap
->events
->ht
, &iter
.iter
, uevent
,
699 if (uevent
->enabled
== 1) {
700 ret
= map_event_ust_disable_tracepoint(usess
, umap
,
704 uevent
->attr
.instrumentation
,
705 (enum lttng_loglevel_type
) uevent
->attr
.loglevel_type
,
706 uevent
->attr
.loglevel
,
707 uevent
->filter_expression
,
712 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
719 * FIXME: FRDESO: in the equivalent function
720 * event_ust_disable_all_tracepoints() (above ^) we also iterator over
721 * all lttng_event. Do we need to do this here too?
724 ret
= error
? error
: LTTNG_OK
;
730 static void agent_enable_all(struct agent
*agt
)
732 struct agent_event
*aevent
;
733 struct lttng_ht_iter iter
;
735 /* Flag every event as enabled. */
737 cds_lfht_for_each_entry (
738 agt
->events
->ht
, &iter
.iter
, aevent
, node
.node
) {
739 aevent
->enabled_count
++;
745 * Enable all agent event for a given UST session.
747 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
749 int event_agent_enable_all(struct ltt_ust_session
*usess
,
750 struct agent
*agt
, struct lttng_event
*event
,
751 struct lttng_bytecode
*filter
,char *filter_expression
)
757 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
759 /* Enable event on agent application through TCP socket. */
760 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
761 if (ret
!= LTTNG_OK
) {
765 agent_enable_all(agt
);
774 * Check if this event's filter requires the activation of application contexts
775 * and enable them in the agent.
776 * TODO: bytecode iterator does not support non-legacy application
777 * contexts yet. Not an issue for now, since they are not generated by
778 * the lttng-ctl library.
780 static int add_filter_app_ctx(struct lttng_bytecode
*bytecode
,
781 const char *filter_expression
, struct agent
*agt
)
784 char *provider_name
= NULL
, *ctx_name
= NULL
;
785 struct bytecode_symbol_iterator
*it
=
786 bytecode_symbol_iterator_create(bytecode
);
789 ret
= LTTNG_ERR_NOMEM
;
794 struct lttng_event_context ctx
;
795 const char *symbol_name
=
796 bytecode_symbol_iterator_get_name(it
);
798 if (parse_application_context(symbol_name
, &provider_name
,
800 /* Not an application context. */
804 ctx
.ctx
= LTTNG_EVENT_CONTEXT_APP_CONTEXT
;
805 ctx
.u
.app_ctx
.provider_name
= provider_name
;
806 ctx
.u
.app_ctx
.ctx_name
= ctx_name
;
808 /* Recognized an application context. */
809 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
810 filter_expression
, provider_name
, ctx_name
);
812 ret
= agent_add_context(&ctx
, agt
);
813 if (ret
!= LTTNG_OK
) {
814 ERR("Failed to add application context %s:%s.",
815 provider_name
, ctx_name
);
819 ret
= agent_enable_context(&ctx
, agt
->domain
);
820 if (ret
!= LTTNG_OK
) {
821 ERR("Failed to enable application context %s:%s.",
822 provider_name
, ctx_name
);
828 provider_name
= ctx_name
= NULL
;
829 } while (bytecode_symbol_iterator_next(it
) == 0);
833 bytecode_symbol_iterator_destroy(it
);
837 static int agent_enable(struct agent
*agt
,
838 struct lttng_event
*event
,
839 struct lttng_bytecode
*filter
,
840 char *filter_expression
)
842 int ret
, created
= 0;
843 struct agent_event
*aevent
;
848 aevent
= agent_find_event(event
->name
, event
->loglevel_type
,
849 event
->loglevel
, filter_expression
, agt
);
851 aevent
= agent_create_event(event
->name
, event
->loglevel_type
,
852 event
->loglevel
, filter
,
855 ret
= LTTNG_ERR_NOMEM
;
859 filter_expression
= NULL
;
861 assert(!AGENT_EVENT_IS_ENABLED(aevent
));
864 if (created
&& aevent
->filter
) {
865 ret
= add_filter_app_ctx(
866 aevent
->filter
, aevent
->filter_expression
, agt
);
867 if (ret
!= LTTNG_OK
) {
872 /* Already enabled? */
873 if (AGENT_EVENT_IS_ENABLED(aevent
)) {
878 ret
= agent_enable_event(aevent
, agt
->domain
);
879 if (ret
!= LTTNG_OK
) {
883 /* If the event was created prior to the enable, add it to the domain. */
885 agent_add_event(aevent
, agt
);
893 agent_destroy_event(aevent
);
897 free(filter_expression
);
902 * Enable a single agent event for a given UST session.
904 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
906 int event_agent_enable(struct ltt_ust_session
*usess
,
908 struct lttng_event
*event
,
909 struct lttng_bytecode
*filter
,
910 char *filter_expression
)
916 DBG("Enabling agent event: event pattern = '%s', session id = %" PRIu64
", loglevel type = %d, loglevel = %d, filter expression = '%s'",
917 event
->name
, usess
->id
, event
->loglevel_type
,
919 filter_expression
? filter_expression
: "(none)");
921 return agent_enable(agt
, event
, filter
, filter_expression
);
925 * Enable a single agent event for a trigger.
927 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
929 int trigger_agent_enable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
932 enum lttng_condition_status c_status
;
933 enum lttng_trigger_status t_status
;
934 enum lttng_domain_type d_type
;
935 const struct lttng_condition
*condition
;
936 const struct lttng_event_rule
*rule
;
937 const char *filter_expression
;
938 char *filter_expression_copy
= NULL
;
939 const struct lttng_bytecode
*filter_bytecode
;
940 struct lttng_bytecode
*filter_bytecode_copy
= NULL
;
941 struct lttng_event
*event
= NULL
;
942 uid_t trigger_owner_uid
= 0;
943 const char *trigger_name
;
948 t_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
949 if (t_status
!= LTTNG_TRIGGER_STATUS_OK
) {
950 trigger_name
= "(unnamed)";
953 t_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_owner_uid
);
954 assert(t_status
== LTTNG_TRIGGER_STATUS_OK
);
956 condition
= lttng_trigger_get_const_condition(trigger
);
958 assert(lttng_condition_get_type(condition
) ==
959 LTTNG_CONDITION_TYPE_ON_EVENT
);
961 c_status
= lttng_condition_on_event_get_rule(condition
, &rule
);
962 assert(c_status
== LTTNG_CONDITION_STATUS_OK
);
964 assert(lttng_event_rule_get_type(rule
) ==
965 LTTNG_EVENT_RULE_TYPE_TRACEPOINT
);
967 d_type
= lttng_event_rule_get_domain_type(rule
);
968 assert(d_type
== agt
->domain
);
970 event
= lttng_event_rule_generate_lttng_event(rule
);
972 ret
= LTTNG_ERR_NOMEM
;
976 /* Get the internal filter expression and bytecode. */
977 filter_expression
= lttng_event_rule_get_filter(rule
);
978 if (filter_expression
) {
979 filter_expression_copy
= strdup(filter_expression
);
980 if (!filter_expression_copy
) {
981 ret
= LTTNG_ERR_NOMEM
;
985 /* Get the filter bytecode */
986 filter_bytecode
= lttng_event_rule_get_filter_bytecode(rule
);
987 if (filter_bytecode
) {
988 filter_bytecode_copy
=
989 lttng_bytecode_copy(filter_bytecode
);
990 if (!filter_bytecode_copy
) {
991 ret
= LTTNG_ERR_NOMEM
;
997 DBG("Enabling agent event from trigger: trigger name = '%s', trigger owner uid = %d, token = %" PRIu64
,
998 trigger_name
, trigger_owner_uid
,
999 lttng_trigger_get_tracer_token(trigger
));
1001 ret
= agent_enable(agt
, event
, filter_bytecode_copy
,
1002 filter_expression_copy
);
1003 /* Ownership was passed even in case of error. */
1004 filter_expression_copy
= NULL
;
1005 filter_bytecode_copy
= NULL
;
1008 free(filter_expression_copy
);
1009 free(filter_bytecode_copy
);
1015 * Return the default event name associated with the provided UST domain. Return
1018 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
1020 const char *default_event_name
= NULL
;
1023 case LTTNG_DOMAIN_LOG4J
:
1024 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
1026 case LTTNG_DOMAIN_JUL
:
1027 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
1029 case LTTNG_DOMAIN_PYTHON
:
1030 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
1036 return default_event_name
;
1039 static int trigger_agent_disable_one(const struct lttng_trigger
*trigger
,
1041 struct agent_event
*aevent
)
1051 * Actual ust event un-registration happens on the trigger
1052 * un-registration at that point.
1055 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for trigger %" PRIu64
,
1056 aevent
->name
, aevent
->loglevel_type
,
1057 aevent
->loglevel_value
, lttng_trigger_get_tracer_token(trigger
));
1059 /* Already disabled? */
1060 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
1064 ret
= agent_disable_event(aevent
, agt
->domain
);
1065 if (ret
!= LTTNG_OK
) {
1077 * Disable a given agent event for a given UST session.
1079 * Must be called with the RCU read lock held.
1080 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
1082 static int event_agent_disable_one(struct ltt_ust_session
*usess
,
1083 struct agent
*agt
, struct agent_event
*aevent
)
1086 struct ltt_ust_event
*uevent
= NULL
;
1087 struct ltt_ust_channel
*uchan
= NULL
;
1088 const char *ust_event_name
, *ust_channel_name
;
1094 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64
,
1095 aevent
->name
, aevent
->loglevel_type
, aevent
->loglevel_value
,
1098 /* Already disabled? */
1099 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
1103 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
1104 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
1105 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
1106 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
1107 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
1108 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
1110 ret
= LTTNG_ERR_INVALID
;
1115 * Disable it on the UST side. First get the channel reference then find
1116 * the event and finally disable it.
1118 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
1119 (char *) ust_channel_name
);
1121 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
1125 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
1126 if (!ust_event_name
) {
1127 ret
= LTTNG_ERR_FATAL
;
1132 * Agent UST event has its loglevel type forced to
1133 * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
1134 * happens thanks to an UST filter. The following -1 is actually
1135 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
1137 /* TODO: JORAJ FRDESO: hmmm what to do with tracer token here?
1139 uevent
= trace_ust_find_event(uchan
->events
, 0, (char *) ust_event_name
,
1140 aevent
->filter
, LTTNG_UST_LOGLEVEL_ALL
, -1, NULL
, NULL
);
1141 /* If the agent event exists, it must be available on the UST side. */
1144 if (usess
->active
) {
1145 ret
= ust_app_disable_channel_event_glb(usess
, uchan
, uevent
);
1146 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
1147 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
1153 * Flag event that it's disabled so the shadow copy on the ust app side
1154 * will disable it if an application shows up.
1156 uevent
->enabled
= 0;
1158 ret
= agent_disable_event(aevent
, agt
->domain
);
1159 if (ret
!= LTTNG_OK
) {
1171 * Disable agent event matching a given trigger.
1173 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
1175 int trigger_agent_disable(
1176 const struct lttng_trigger
*trigger
, struct agent
*agt
)
1179 struct agent_event
*aevent
;
1184 DBG("Event agent disabling for trigger %" PRIu64
,
1185 lttng_trigger_get_tracer_token(trigger
));
1188 aevent
= agent_find_event_by_trigger(trigger
, agt
);
1190 if (aevent
== NULL
) {
1191 DBG2("Event agent NOT found by trigger %" PRIu64
,
1192 lttng_trigger_get_tracer_token(trigger
));
1193 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
1197 ret
= trigger_agent_disable_one(trigger
, agt
, aevent
);
1199 if (ret
!= LTTNG_OK
) {
1209 * Disable all agent events matching a given name for a given UST session.
1211 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
1213 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
1214 const char *event_name
)
1217 struct agent_event
*aevent
;
1218 struct lttng_ht_iter iter
;
1219 struct lttng_ht_node_str
*node
;
1225 DBG("Event agent disabling %s (all loglevels) for session %" PRIu64
, event_name
, usess
->id
);
1228 agent_find_events_by_name(event_name
, agt
, &iter
);
1229 node
= lttng_ht_iter_get_node_str(&iter
);
1232 DBG2("Event agent NOT found by name %s", event_name
);
1233 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
1238 aevent
= caa_container_of(node
, struct agent_event
, node
);
1239 ret
= event_agent_disable_one(usess
, agt
, aevent
);
1241 if (ret
!= LTTNG_OK
) {
1245 /* Get next duplicate agent event by name. */
1246 agent_event_next_duplicate(event_name
, agt
, &iter
);
1247 node
= lttng_ht_iter_get_node_str(&iter
);
1254 * Disable all agent event for a given UST session.
1256 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
1258 int event_agent_disable_all(struct ltt_ust_session
*usess
,
1262 struct agent_event
*aevent
;
1263 struct lttng_ht_iter iter
;
1269 * Disable event on agent application. Continue to disable all other events
1270 * if the * event is not found.
1272 ret
= event_agent_disable(usess
, agt
, "*");
1273 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
1277 /* Disable every event. */
1279 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
1281 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
1285 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
1286 if (ret
!= LTTNG_OK
) {