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 const 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 const 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
<lttng_ht_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
<lttng_ht_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_event
*events
= nullptr;
327 /* Disabling existing events */
329 lttng::urcu::lfht_iteration_adapter
<ltt_ust_event
,
330 decltype(ltt_ust_event::node
),
331 <t_ust_event::node
>(*uchan
->events
->ht
)) {
332 if (uevent
->enabled
) {
333 ret
= event_ust_disable_tracepoint(usess
, uchan
, uevent
->attr
.name
);
335 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
341 /* Get all UST available events */
342 size
= ust_app_list_events(&events
);
344 ret
= LTTNG_ERR_UST_LIST_FAIL
;
348 for (i
= 0; i
< size
; i
++) {
349 ret
= event_ust_disable_tracepoint(usess
, uchan
, events
[i
].name
);
351 /* Continue to disable the rest... */
352 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
357 ret
= error
? error
: LTTNG_OK
;
363 static void agent_enable_all(struct agent
*agt
)
366 lttng::urcu::lfht_iteration_adapter
<agent_event
,
367 decltype(agent_event::node
),
368 &agent_event::node
>(*agt
->events
->ht
)) {
369 aevent
->enabled_count
++;
374 * Enable all agent event for a given UST session.
376 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
378 int event_agent_enable_all(struct ltt_ust_session
*usess
,
380 struct lttng_event
*event
,
381 struct lttng_bytecode
*filter
,
382 char *filter_expression
)
388 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
390 /* Enable event on agent application through TCP socket. */
391 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
392 if (ret
!= LTTNG_OK
) {
396 agent_enable_all(agt
);
405 * Check if this event's filter requires the activation of application contexts
406 * and enable them in the agent.
407 * TODO: bytecode iterator does not support non-legacy application
408 * contexts yet. Not an issue for now, since they are not generated by
409 * the lttng-ctl library.
411 static int add_filter_app_ctx(struct lttng_bytecode
*bytecode
,
412 const char *filter_expression
,
416 char *provider_name
= nullptr, *ctx_name
= nullptr;
417 struct bytecode_symbol_iterator
*it
= bytecode_symbol_iterator_create(bytecode
);
420 ret
= LTTNG_ERR_NOMEM
;
425 struct lttng_event_context ctx
;
426 const char *symbol_name
= bytecode_symbol_iterator_get_name(it
);
428 if (parse_application_context(symbol_name
, &provider_name
, &ctx_name
)) {
429 /* Not an application context. */
433 ctx
.ctx
= LTTNG_EVENT_CONTEXT_APP_CONTEXT
;
434 ctx
.u
.app_ctx
.provider_name
= provider_name
;
435 ctx
.u
.app_ctx
.ctx_name
= ctx_name
;
437 /* Recognized an application context. */
438 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
443 ret
= agent_add_context(&ctx
, agt
);
444 if (ret
!= LTTNG_OK
) {
445 ERR("Failed to add application context %s:%s.", provider_name
, ctx_name
);
449 ret
= agent_enable_context(&ctx
, agt
->domain
);
450 if (ret
!= LTTNG_OK
) {
451 ERR("Failed to enable application context %s:%s.", provider_name
, ctx_name
);
457 provider_name
= ctx_name
= nullptr;
458 } while (bytecode_symbol_iterator_next(it
) == 0);
462 bytecode_symbol_iterator_destroy(it
);
466 static int agent_enable(struct agent
*agt
,
467 struct lttng_event
*event
,
468 struct lttng_bytecode
*filter
,
469 char *filter_expression
)
471 int ret
, created
= 0;
472 struct agent_event
*aevent
;
477 const lttng::urcu::read_lock_guard read_lock
;
478 aevent
= agent_find_event(
479 event
->name
, event
->loglevel_type
, event
->loglevel
, filter_expression
, agt
);
481 aevent
= agent_create_event(event
->name
,
482 event
->loglevel_type
,
487 ret
= LTTNG_ERR_NOMEM
;
491 filter_expression
= nullptr;
493 LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(aevent
));
496 if (created
&& aevent
->filter
) {
497 ret
= add_filter_app_ctx(aevent
->filter
, aevent
->filter_expression
, agt
);
498 if (ret
!= LTTNG_OK
) {
503 /* Already enabled? */
504 if (AGENT_EVENT_IS_ENABLED(aevent
)) {
509 ret
= agent_enable_event(aevent
, agt
->domain
);
510 if (ret
!= LTTNG_OK
) {
514 /* If the event was created prior to the enable, add it to the domain. */
516 agent_add_event(aevent
, agt
);
524 agent_destroy_event(aevent
);
528 free(filter_expression
);
533 * Enable a single agent event for a given UST session.
535 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
537 int event_agent_enable(struct ltt_ust_session
*usess
,
539 struct lttng_event
*event
,
540 struct lttng_bytecode
*filter
,
541 char *filter_expression
)
547 DBG("Enabling agent event: event pattern = '%s', session id = %" PRIu64
548 ", loglevel type = %d, loglevel = %d, filter expression = '%s'",
551 event
->loglevel_type
,
553 filter_expression
? filter_expression
: "(none)");
555 return agent_enable(agt
, event
, filter
, filter_expression
);
559 * Enable a single agent event for a trigger.
561 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
563 int trigger_agent_enable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
566 enum lttng_condition_status c_status
;
567 enum lttng_trigger_status t_status
;
568 enum lttng_domain_type d_type
;
569 const struct lttng_condition
*condition
;
570 const struct lttng_event_rule
*rule
;
571 const char *filter_expression
;
572 char *filter_expression_copy
= nullptr;
573 const struct lttng_bytecode
*filter_bytecode
;
574 struct lttng_bytecode
*filter_bytecode_copy
= nullptr;
575 struct lttng_event
*event
= nullptr;
576 uid_t trigger_owner_uid
= 0;
577 const char *trigger_name
;
579 LTTNG_ASSERT(trigger
);
582 t_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
583 if (t_status
!= LTTNG_TRIGGER_STATUS_OK
) {
584 trigger_name
= "(anonymous)";
587 t_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_owner_uid
);
588 LTTNG_ASSERT(t_status
== LTTNG_TRIGGER_STATUS_OK
);
590 condition
= lttng_trigger_get_const_condition(trigger
);
592 LTTNG_ASSERT(lttng_condition_get_type(condition
) ==
593 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
);
595 c_status
= lttng_condition_event_rule_matches_get_rule(condition
, &rule
);
596 LTTNG_ASSERT(c_status
== LTTNG_CONDITION_STATUS_OK
);
598 switch (lttng_event_rule_get_type(rule
)) {
599 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
600 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
601 case LTTNG_EVENT_RULE_TYPE_LOG4J2_LOGGING
:
602 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
609 d_type
= lttng_event_rule_get_domain_type(rule
);
610 LTTNG_ASSERT(d_type
== agt
->domain
);
612 event
= lttng_event_rule_generate_lttng_event(rule
);
614 ret
= LTTNG_ERR_NOMEM
;
618 /* Get the internal filter expression and bytecode. */
619 filter_expression
= lttng_event_rule_get_filter(rule
);
620 if (filter_expression
) {
621 filter_expression_copy
= strdup(filter_expression
);
622 if (!filter_expression_copy
) {
623 ret
= LTTNG_ERR_NOMEM
;
627 /* Get the filter bytecode */
628 filter_bytecode
= lttng_event_rule_get_filter_bytecode(rule
);
629 if (filter_bytecode
) {
630 filter_bytecode_copy
= lttng_bytecode_copy(filter_bytecode
);
631 if (!filter_bytecode_copy
) {
632 ret
= LTTNG_ERR_NOMEM
;
638 DBG("Enabling agent event from trigger: trigger name = '%s', trigger owner uid = %d, token = %" PRIu64
,
641 lttng_trigger_get_tracer_token(trigger
));
643 ret
= agent_enable(agt
, event
, filter_bytecode_copy
, filter_expression_copy
);
644 /* Ownership was passed even in case of error. */
645 filter_expression_copy
= nullptr;
646 filter_bytecode_copy
= nullptr;
649 free(filter_expression_copy
);
650 free(filter_bytecode_copy
);
656 * Return the default event name associated with the provided UST domain. Return
659 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
661 const char *default_event_name
= nullptr;
664 case LTTNG_DOMAIN_LOG4J
:
665 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
667 case LTTNG_DOMAIN_LOG4J2
:
668 default_event_name
= DEFAULT_LOG4J2_EVENT_NAME
;
670 case LTTNG_DOMAIN_JUL
:
671 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
673 case LTTNG_DOMAIN_PYTHON
:
674 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
680 return default_event_name
;
683 static int trigger_agent_disable_one(const struct lttng_trigger
*trigger
,
685 struct agent_event
*aevent
)
691 LTTNG_ASSERT(trigger
);
692 LTTNG_ASSERT(aevent
);
695 * Actual ust event un-registration happens on the trigger
696 * un-registration at that point.
699 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for trigger %" PRIu64
,
701 aevent
->loglevel_type
,
702 aevent
->loglevel_value
,
703 lttng_trigger_get_tracer_token(trigger
));
705 /* Already disabled? */
706 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
710 ret
= agent_disable_event(aevent
, agt
->domain
);
711 if (ret
!= LTTNG_OK
) {
723 * Disable a given agent event for a given UST session.
725 * Must be called with the RCU read lock held.
726 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
728 static int event_agent_disable_one(struct ltt_ust_session
*usess
,
730 struct agent_event
*aevent
)
733 struct ltt_ust_event
*uevent
= nullptr;
734 struct ltt_ust_channel
*uchan
= nullptr;
735 const char *ust_event_name
, *ust_channel_name
;
739 LTTNG_ASSERT(aevent
);
741 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64
,
743 aevent
->loglevel_type
,
744 aevent
->loglevel_value
,
747 /* Already disabled? */
748 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
752 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
753 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
754 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
755 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
756 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J2
) {
757 ust_channel_name
= DEFAULT_LOG4J2_CHANNEL_NAME
;
758 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
759 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
761 ret
= LTTNG_ERR_INVALID
;
766 * Disable it on the UST side. First get the channel reference then find
767 * the event and finally disable it.
769 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
770 (char *) ust_channel_name
);
772 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
776 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
777 if (!ust_event_name
) {
778 ret
= LTTNG_ERR_FATAL
;
783 * Agent UST event has its loglevel type forced to
784 * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
785 * happens thanks to an UST filter. The following -1 is actually
786 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
788 uevent
= trace_ust_find_event(uchan
->events
,
789 (char *) ust_event_name
,
791 LTTNG_UST_ABI_LOGLEVEL_ALL
,
794 /* If the agent event exists, it must be available on the UST side. */
795 LTTNG_ASSERT(uevent
);
798 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
799 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
800 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
806 * Flag event that it's disabled so the shadow copy on the ust app side
807 * will disable it if an application shows up.
809 uevent
->enabled
= false;
811 ret
= agent_disable_event(aevent
, agt
->domain
);
812 if (ret
!= LTTNG_OK
) {
824 * Disable agent event matching a given trigger.
826 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
828 int trigger_agent_disable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
831 struct agent_event
*aevent
;
833 LTTNG_ASSERT(trigger
);
836 DBG("Event agent disabling for trigger %" PRIu64
, lttng_trigger_get_tracer_token(trigger
));
838 const lttng::urcu::read_lock_guard read_lock
;
839 aevent
= agent_find_event_by_trigger(trigger
, agt
);
841 if (aevent
== nullptr) {
842 DBG2("Event agent NOT found by trigger %" PRIu64
,
843 lttng_trigger_get_tracer_token(trigger
));
844 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
848 ret
= trigger_agent_disable_one(trigger
, agt
, aevent
);
850 if (ret
!= LTTNG_OK
) {
859 * Disable all agent events matching a given name for a given UST session.
861 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
863 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
, const char *event_name
)
866 struct agent_event
*aevent
;
867 struct lttng_ht_iter iter
;
868 struct lttng_ht_node_str
*node
;
872 LTTNG_ASSERT(event_name
);
874 DBG("Event agent disabling %s (all loglevels) for session %" PRIu64
, event_name
, usess
->id
);
876 const lttng::urcu::read_lock_guard read_lock
;
877 agent_find_events_by_name(event_name
, agt
, &iter
);
878 node
= lttng_ht_iter_get_node
<lttng_ht_node_str
>(&iter
);
880 if (node
== nullptr) {
881 DBG2("Event agent NOT found by name %s", event_name
);
882 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
887 aevent
= lttng::utils::container_of(node
, &agent_event::node
);
888 ret
= event_agent_disable_one(usess
, agt
, aevent
);
890 if (ret
!= LTTNG_OK
) {
894 /* Get next duplicate agent event by name. */
895 agent_event_next_duplicate(event_name
, agt
, &iter
);
896 node
= lttng_ht_iter_get_node
<lttng_ht_node_str
>(&iter
);
902 * Disable all agent event for a given UST session.
904 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
906 int event_agent_disable_all(struct ltt_ust_session
*usess
, struct agent
*agt
)
914 * Disable event on agent application. Continue to disable all other events
915 * if the * event is not found.
917 ret
= event_agent_disable(usess
, agt
, "*");
918 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
922 /* Disable every event. */
924 lttng::urcu::lfht_iteration_adapter
<agent_event
,
925 decltype(agent_event::node
),
926 &agent_event::node
>(*agt
->events
->ht
)) {
927 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
931 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
932 if (ret
!= LTTNG_OK
) {