2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
11 #include "channel.hpp"
14 #include "lttng-sessiond.hpp"
15 #include "lttng-ust-ctl.hpp"
16 #include "lttng-ust-error.hpp"
17 #include "trace-kernel.hpp"
18 #include "trace-ust.hpp"
19 #include "ust-app.hpp"
22 #include <common/bytecode/bytecode.hpp>
23 #include <common/compat/errno.hpp>
24 #include <common/context.hpp>
25 #include <common/error.hpp>
26 #include <common/filter.hpp>
27 #include <common/sessiond-comm/sessiond-comm.hpp>
28 #include <common/urcu.hpp>
30 #include <lttng/condition/condition.h>
31 #include <lttng/condition/event-rule-matches.h>
32 #include <lttng/event-rule/event-rule-internal.hpp>
33 #include <lttng/event-rule/event-rule.h>
34 #include <lttng/lttng.h>
37 #include <urcu/list.h>
40 * Add unique UST event based on the event name, filter bytecode and loglevel.
42 static void add_unique_ust_event(struct lttng_ht
*ht
, struct ltt_ust_event
*event
)
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
= (lttng_ust_abi_loglevel_type
) event
->attr
.loglevel_type
;
54 key
.loglevel_value
= event
->attr
.loglevel
;
55 key
.exclusion
= event
->exclusion
;
57 node_ptr
= cds_lfht_add_unique(ht
->ht
,
58 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
59 trace_ust_ht_match_event
,
62 LTTNG_ASSERT(node_ptr
== &event
->node
.node
);
66 * Disable kernel tracepoint events for a channel from the kernel session of
67 * a specified event_name and event type.
68 * On type LTTNG_EVENT_ALL all events with event_name are disabled.
69 * If event_name is NULL all events of the specified type are disabled.
71 int event_kernel_disable_event(struct ltt_kernel_channel
*kchan
,
72 const char *event_name
,
73 enum lttng_event_type type
)
75 int ret
, error
= 0, found
= 0;
76 struct ltt_kernel_event
*kevent
;
80 /* For each event in the kernel session */
81 cds_list_for_each_entry (kevent
, &kchan
->events_list
.head
, list
) {
82 if (type
!= LTTNG_EVENT_ALL
&& kevent
->type
!= type
)
84 if (event_name
!= nullptr && strcmp(event_name
, kevent
->event
->name
) != 0) {
88 ret
= kernel_disable_event(kevent
);
94 DBG("Disable kernel event: found %d events with name: %s and type: %d",
96 event_name
? event_name
: "NULL",
99 if (event_name
!= nullptr && !found
) {
100 ret
= LTTNG_ERR_NO_EVENT
;
102 ret
= error
? LTTNG_ERR_KERN_DISABLE_FAIL
: LTTNG_OK
;
109 * Enable kernel tracepoint event for a channel from the kernel session.
110 * We own filter_expression and filter.
112 int event_kernel_enable_event(struct ltt_kernel_channel
*kchan
,
113 struct lttng_event
*event
,
114 char *filter_expression
,
115 struct lttng_bytecode
*filter
)
118 struct ltt_kernel_event
*kevent
;
123 kevent
= trace_kernel_find_event(event
->name
, kchan
, event
->type
, filter
);
124 if (kevent
== nullptr) {
125 ret
= kernel_create_event(event
, kchan
, filter_expression
, filter
);
126 /* We have passed ownership */
127 filter_expression
= nullptr;
132 } else if (!kevent
->enabled
) {
133 ret
= kernel_enable_event(kevent
);
135 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
139 /* At this point, the event is considered enabled */
140 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
146 free(filter_expression
);
152 * ============================
153 * UST : The Ultimate Frontier!
154 * ============================
158 * Enable UST tracepoint event for a channel from a UST session.
159 * We own filter_expression, filter, and exclusion.
161 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
162 struct ltt_ust_channel
*uchan
,
163 struct lttng_event
*event
,
164 char *filter_expression
,
165 struct lttng_bytecode
*filter
,
166 struct lttng_event_exclusion
*exclusion
,
169 int ret
= LTTNG_OK
, to_create
= 0;
170 struct ltt_ust_event
*uevent
;
176 lttng::urcu::read_lock_guard read_lock
;
178 uevent
= trace_ust_find_event(uchan
->events
,
181 (enum lttng_ust_abi_loglevel_type
) event
->loglevel_type
,
185 ret
= trace_ust_create_event(
186 event
, filter_expression
, filter
, exclusion
, internal_event
, &uevent
);
187 /* We have passed ownership */
188 filter_expression
= nullptr;
191 if (ret
!= LTTNG_OK
) {
195 /* Valid to set it after the goto error since uevent is still NULL */
199 if (uevent
->enabled
) {
200 /* It's already enabled so everything is OK */
201 LTTNG_ASSERT(!to_create
);
202 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
206 uevent
->enabled
= true;
208 /* Add ltt ust event to channel */
209 add_unique_ust_event(uchan
->events
, uevent
);
212 if (!usess
->active
) {
217 /* Create event on all UST registered apps for session */
218 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
220 /* Enable event on all UST registered apps for session */
221 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
225 if (ret
== -LTTNG_UST_ERR_EXIST
) {
226 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
228 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
233 DBG("Event UST %s %s in channel %s",
235 to_create
? "created" : "enabled",
241 free(filter_expression
);
248 * Disable UST tracepoint of a channel from a UST session.
250 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
251 struct ltt_ust_channel
*uchan
,
252 const char *event_name
)
255 struct ltt_ust_event
*uevent
;
256 struct lttng_ht_node_str
*node
;
257 struct lttng_ht_iter iter
;
262 LTTNG_ASSERT(event_name
);
266 lttng::urcu::read_lock_guard read_lock
;
269 * We use a custom lookup since we need the iterator for the next_duplicate
270 * call in the do while loop below.
272 cds_lfht_lookup(ht
->ht
,
273 ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
274 trace_ust_ht_match_event_by_name
,
277 node
= lttng_ht_iter_get_node_str(&iter
);
278 if (node
== nullptr) {
279 DBG2("Trace UST event NOT found by name %s", event_name
);
280 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
285 uevent
= lttng::utils::container_of(node
, <t_ust_event::node
);
286 LTTNG_ASSERT(uevent
);
288 if (!uevent
->enabled
) {
289 /* It's already disabled so everything is OK */
292 uevent
->enabled
= false;
293 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
, uchan
->name
);
295 if (!usess
->active
) {
298 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
299 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
300 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
304 /* Get next duplicate event by name. */
305 cds_lfht_next_duplicate(
306 ht
->ht
, trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
307 node
= lttng_ht_iter_get_node_str(&iter
);
317 * Disable all UST tracepoints for a channel from a UST session.
319 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
, struct ltt_ust_channel
*uchan
)
321 int ret
, i
, size
, error
= 0;
322 struct lttng_ht_iter iter
;
323 struct ltt_ust_event
*uevent
= nullptr;
324 struct lttng_event
*events
= nullptr;
330 /* Disabling existing events */
332 lttng::urcu::read_lock_guard read_lock
;
334 cds_lfht_for_each_entry (uchan
->events
->ht
, &iter
.iter
, uevent
, node
.node
) {
335 if (uevent
->enabled
) {
336 ret
= event_ust_disable_tracepoint(usess
, uchan
, uevent
->attr
.name
);
338 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
345 /* Get all UST available events */
346 size
= ust_app_list_events(&events
);
348 ret
= LTTNG_ERR_UST_LIST_FAIL
;
352 for (i
= 0; i
< size
; i
++) {
353 ret
= event_ust_disable_tracepoint(usess
, uchan
, events
[i
].name
);
355 /* Continue to disable the rest... */
356 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
361 ret
= error
? error
: LTTNG_OK
;
367 static void agent_enable_all(struct agent
*agt
)
369 struct agent_event
*aevent
;
370 struct lttng_ht_iter iter
;
373 /* Flag every event as enabled. */
374 lttng::urcu::read_lock_guard read_lock
;
376 cds_lfht_for_each_entry (agt
->events
->ht
, &iter
.iter
, aevent
, node
.node
) {
377 aevent
->enabled_count
++;
383 * Enable all agent event for a given UST session.
385 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
387 int event_agent_enable_all(struct ltt_ust_session
*usess
,
389 struct lttng_event
*event
,
390 struct lttng_bytecode
*filter
,
391 char *filter_expression
)
397 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
399 /* Enable event on agent application through TCP socket. */
400 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
401 if (ret
!= LTTNG_OK
) {
405 agent_enable_all(agt
);
414 * Check if this event's filter requires the activation of application contexts
415 * and enable them in the agent.
416 * TODO: bytecode iterator does not support non-legacy application
417 * contexts yet. Not an issue for now, since they are not generated by
418 * the lttng-ctl library.
420 static int add_filter_app_ctx(struct lttng_bytecode
*bytecode
,
421 const char *filter_expression
,
425 char *provider_name
= nullptr, *ctx_name
= nullptr;
426 struct bytecode_symbol_iterator
*it
= bytecode_symbol_iterator_create(bytecode
);
429 ret
= LTTNG_ERR_NOMEM
;
434 struct lttng_event_context ctx
;
435 const char *symbol_name
= bytecode_symbol_iterator_get_name(it
);
437 if (parse_application_context(symbol_name
, &provider_name
, &ctx_name
)) {
438 /* Not an application context. */
442 ctx
.ctx
= LTTNG_EVENT_CONTEXT_APP_CONTEXT
;
443 ctx
.u
.app_ctx
.provider_name
= provider_name
;
444 ctx
.u
.app_ctx
.ctx_name
= ctx_name
;
446 /* Recognized an application context. */
447 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
452 ret
= agent_add_context(&ctx
, agt
);
453 if (ret
!= LTTNG_OK
) {
454 ERR("Failed to add application context %s:%s.", provider_name
, ctx_name
);
458 ret
= agent_enable_context(&ctx
, agt
->domain
);
459 if (ret
!= LTTNG_OK
) {
460 ERR("Failed to enable application context %s:%s.", provider_name
, ctx_name
);
466 provider_name
= ctx_name
= nullptr;
467 } while (bytecode_symbol_iterator_next(it
) == 0);
471 bytecode_symbol_iterator_destroy(it
);
475 static int agent_enable(struct agent
*agt
,
476 struct lttng_event
*event
,
477 struct lttng_bytecode
*filter
,
478 char *filter_expression
)
480 int ret
, created
= 0;
481 struct agent_event
*aevent
;
486 lttng::urcu::read_lock_guard read_lock
;
487 aevent
= agent_find_event(
488 event
->name
, event
->loglevel_type
, event
->loglevel
, filter_expression
, agt
);
490 aevent
= agent_create_event(event
->name
,
491 event
->loglevel_type
,
496 ret
= LTTNG_ERR_NOMEM
;
500 filter_expression
= nullptr;
502 LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(aevent
));
505 if (created
&& aevent
->filter
) {
506 ret
= add_filter_app_ctx(aevent
->filter
, aevent
->filter_expression
, agt
);
507 if (ret
!= LTTNG_OK
) {
512 /* Already enabled? */
513 if (AGENT_EVENT_IS_ENABLED(aevent
)) {
518 ret
= agent_enable_event(aevent
, agt
->domain
);
519 if (ret
!= LTTNG_OK
) {
523 /* If the event was created prior to the enable, add it to the domain. */
525 agent_add_event(aevent
, agt
);
533 agent_destroy_event(aevent
);
537 free(filter_expression
);
542 * Enable a single agent event for a given UST session.
544 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
546 int event_agent_enable(struct ltt_ust_session
*usess
,
548 struct lttng_event
*event
,
549 struct lttng_bytecode
*filter
,
550 char *filter_expression
)
556 DBG("Enabling agent event: event pattern = '%s', session id = %" PRIu64
557 ", loglevel type = %d, loglevel = %d, filter expression = '%s'",
560 event
->loglevel_type
,
562 filter_expression
? filter_expression
: "(none)");
564 return agent_enable(agt
, event
, filter
, filter_expression
);
568 * Enable a single agent event for a trigger.
570 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
572 int trigger_agent_enable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
575 enum lttng_condition_status c_status
;
576 enum lttng_trigger_status t_status
;
577 enum lttng_domain_type d_type
;
578 const struct lttng_condition
*condition
;
579 const struct lttng_event_rule
*rule
;
580 const char *filter_expression
;
581 char *filter_expression_copy
= nullptr;
582 const struct lttng_bytecode
*filter_bytecode
;
583 struct lttng_bytecode
*filter_bytecode_copy
= nullptr;
584 struct lttng_event
*event
= nullptr;
585 uid_t trigger_owner_uid
= 0;
586 const char *trigger_name
;
588 LTTNG_ASSERT(trigger
);
591 t_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
592 if (t_status
!= LTTNG_TRIGGER_STATUS_OK
) {
593 trigger_name
= "(anonymous)";
596 t_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_owner_uid
);
597 LTTNG_ASSERT(t_status
== LTTNG_TRIGGER_STATUS_OK
);
599 condition
= lttng_trigger_get_const_condition(trigger
);
601 LTTNG_ASSERT(lttng_condition_get_type(condition
) ==
602 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
);
604 c_status
= lttng_condition_event_rule_matches_get_rule(condition
, &rule
);
605 LTTNG_ASSERT(c_status
== LTTNG_CONDITION_STATUS_OK
);
607 switch (lttng_event_rule_get_type(rule
)) {
608 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
609 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
610 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
617 d_type
= lttng_event_rule_get_domain_type(rule
);
618 LTTNG_ASSERT(d_type
== agt
->domain
);
620 event
= lttng_event_rule_generate_lttng_event(rule
);
622 ret
= LTTNG_ERR_NOMEM
;
626 /* Get the internal filter expression and bytecode. */
627 filter_expression
= lttng_event_rule_get_filter(rule
);
628 if (filter_expression
) {
629 filter_expression_copy
= strdup(filter_expression
);
630 if (!filter_expression_copy
) {
631 ret
= LTTNG_ERR_NOMEM
;
635 /* Get the filter bytecode */
636 filter_bytecode
= lttng_event_rule_get_filter_bytecode(rule
);
637 if (filter_bytecode
) {
638 filter_bytecode_copy
= lttng_bytecode_copy(filter_bytecode
);
639 if (!filter_bytecode_copy
) {
640 ret
= LTTNG_ERR_NOMEM
;
646 DBG("Enabling agent event from trigger: trigger name = '%s', trigger owner uid = %d, token = %" PRIu64
,
649 lttng_trigger_get_tracer_token(trigger
));
651 ret
= agent_enable(agt
, event
, filter_bytecode_copy
, filter_expression_copy
);
652 /* Ownership was passed even in case of error. */
653 filter_expression_copy
= nullptr;
654 filter_bytecode_copy
= nullptr;
657 free(filter_expression_copy
);
658 free(filter_bytecode_copy
);
664 * Return the default event name associated with the provided UST domain. Return
667 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
669 const char *default_event_name
= nullptr;
672 case LTTNG_DOMAIN_LOG4J
:
673 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
675 case LTTNG_DOMAIN_JUL
:
676 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
678 case LTTNG_DOMAIN_PYTHON
:
679 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
685 return default_event_name
;
688 static int trigger_agent_disable_one(const struct lttng_trigger
*trigger
,
690 struct agent_event
*aevent
)
696 LTTNG_ASSERT(trigger
);
697 LTTNG_ASSERT(aevent
);
700 * Actual ust event un-registration happens on the trigger
701 * un-registration at that point.
704 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for trigger %" PRIu64
,
706 aevent
->loglevel_type
,
707 aevent
->loglevel_value
,
708 lttng_trigger_get_tracer_token(trigger
));
710 /* Already disabled? */
711 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
715 ret
= agent_disable_event(aevent
, agt
->domain
);
716 if (ret
!= LTTNG_OK
) {
728 * Disable a given agent event for a given UST session.
730 * Must be called with the RCU read lock held.
731 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
733 static int event_agent_disable_one(struct ltt_ust_session
*usess
,
735 struct agent_event
*aevent
)
738 struct ltt_ust_event
*uevent
= nullptr;
739 struct ltt_ust_channel
*uchan
= nullptr;
740 const char *ust_event_name
, *ust_channel_name
;
744 LTTNG_ASSERT(aevent
);
746 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64
,
748 aevent
->loglevel_type
,
749 aevent
->loglevel_value
,
752 /* Already disabled? */
753 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
757 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
758 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
759 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
760 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
761 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
762 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
764 ret
= LTTNG_ERR_INVALID
;
769 * Disable it on the UST side. First get the channel reference then find
770 * the event and finally disable it.
772 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
773 (char *) ust_channel_name
);
775 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
779 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
780 if (!ust_event_name
) {
781 ret
= LTTNG_ERR_FATAL
;
786 * Agent UST event has its loglevel type forced to
787 * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
788 * happens thanks to an UST filter. The following -1 is actually
789 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
791 uevent
= trace_ust_find_event(uchan
->events
,
792 (char *) ust_event_name
,
794 LTTNG_UST_ABI_LOGLEVEL_ALL
,
797 /* If the agent event exists, it must be available on the UST side. */
798 LTTNG_ASSERT(uevent
);
801 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
802 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
803 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
809 * Flag event that it's disabled so the shadow copy on the ust app side
810 * will disable it if an application shows up.
812 uevent
->enabled
= false;
814 ret
= agent_disable_event(aevent
, agt
->domain
);
815 if (ret
!= LTTNG_OK
) {
827 * Disable agent event matching a given trigger.
829 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
831 int trigger_agent_disable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
834 struct agent_event
*aevent
;
836 LTTNG_ASSERT(trigger
);
839 DBG("Event agent disabling for trigger %" PRIu64
, lttng_trigger_get_tracer_token(trigger
));
841 lttng::urcu::read_lock_guard read_lock
;
842 aevent
= agent_find_event_by_trigger(trigger
, agt
);
844 if (aevent
== nullptr) {
845 DBG2("Event agent NOT found by trigger %" PRIu64
,
846 lttng_trigger_get_tracer_token(trigger
));
847 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
851 ret
= trigger_agent_disable_one(trigger
, agt
, aevent
);
853 if (ret
!= LTTNG_OK
) {
862 * Disable all agent events matching a given name for a given UST session.
864 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
866 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
, const char *event_name
)
869 struct agent_event
*aevent
;
870 struct lttng_ht_iter iter
;
871 struct lttng_ht_node_str
*node
;
875 LTTNG_ASSERT(event_name
);
877 DBG("Event agent disabling %s (all loglevels) for session %" PRIu64
, event_name
, usess
->id
);
879 lttng::urcu::read_lock_guard read_lock
;
880 agent_find_events_by_name(event_name
, agt
, &iter
);
881 node
= lttng_ht_iter_get_node_str(&iter
);
883 if (node
== nullptr) {
884 DBG2("Event agent NOT found by name %s", event_name
);
885 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
890 aevent
= lttng::utils::container_of(node
, &agent_event::node
);
891 ret
= event_agent_disable_one(usess
, agt
, aevent
);
893 if (ret
!= LTTNG_OK
) {
897 /* Get next duplicate agent event by name. */
898 agent_event_next_duplicate(event_name
, agt
, &iter
);
899 node
= lttng_ht_iter_get_node_str(&iter
);
905 * Disable all agent event for a given UST session.
907 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
909 int event_agent_disable_all(struct ltt_ust_session
*usess
, struct agent
*agt
)
912 struct agent_event
*aevent
;
913 struct lttng_ht_iter iter
;
919 * Disable event on agent application. Continue to disable all other events
920 * if the * event is not found.
922 ret
= event_agent_disable(usess
, agt
, "*");
923 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
927 /* Disable every event. */
929 lttng::urcu::read_lock_guard read_lock
;
931 cds_lfht_for_each_entry (agt
->events
->ht
, &iter
.iter
, aevent
, node
.node
) {
932 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
936 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
937 if (ret
!= LTTNG_OK
) {