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
10 #include <urcu/list.h>
13 #include <common/compat/errno.hpp>
14 #include <lttng/lttng.h>
15 #include <lttng/condition/condition.h>
16 #include <lttng/condition/event-rule-matches.h>
17 #include <lttng/event-rule/event-rule.h>
18 #include <lttng/event-rule/event-rule-internal.hpp>
19 #include <common/bytecode/bytecode.hpp>
20 #include <common/error.hpp>
21 #include <common/sessiond-comm/sessiond-comm.hpp>
22 #include <common/filter.hpp>
23 #include <common/context.hpp>
25 #include "channel.hpp"
28 #include "lttng-sessiond.hpp"
29 #include "lttng-ust-ctl.hpp"
30 #include "lttng-ust-error.hpp"
31 #include "ust-app.hpp"
32 #include "trace-kernel.hpp"
33 #include "trace-ust.hpp"
38 * Add unique UST event based on the event name, filter bytecode and loglevel.
40 static void add_unique_ust_event(struct lttng_ht
*ht
,
41 struct ltt_ust_event
*event
)
43 struct cds_lfht_node
*node_ptr
;
44 struct ltt_ust_ht_key key
;
50 key
.name
= event
->attr
.name
;
51 key
.filter
= (struct lttng_bytecode
*) event
->filter
;
52 key
.loglevel_type
= (lttng_ust_abi_loglevel_type
) event
->attr
.loglevel_type
;
53 key
.loglevel_value
= event
->attr
.loglevel
;
54 key
.exclusion
= event
->exclusion
;
56 node_ptr
= cds_lfht_add_unique(ht
->ht
,
57 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
58 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
59 LTTNG_ASSERT(node_ptr
== &event
->node
.node
);
63 * Disable kernel tracepoint events for a channel from the kernel session of
64 * a specified event_name and event type.
65 * On type LTTNG_EVENT_ALL all events with event_name are disabled.
66 * If event_name is NULL all events of the specified type are disabled.
68 int event_kernel_disable_event(struct ltt_kernel_channel
*kchan
,
69 const char *event_name
, enum lttng_event_type type
)
71 int ret
, error
= 0, found
= 0;
72 struct ltt_kernel_event
*kevent
;
76 /* For each event in the kernel session */
77 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
78 if (type
!= LTTNG_EVENT_ALL
&& kevent
->type
!= type
)
80 if (event_name
!= NULL
&& strcmp(event_name
, kevent
->event
->name
)) {
84 ret
= kernel_disable_event(kevent
);
90 DBG("Disable kernel event: found %d events with name: %s and type: %d",
91 found
, event_name
? event_name
: "NULL", type
);
93 if (event_name
!= NULL
&& !found
) {
94 ret
= LTTNG_ERR_NO_EVENT
;
96 ret
= error
? LTTNG_ERR_KERN_DISABLE_FAIL
: LTTNG_OK
;
103 * Enable kernel tracepoint event for a channel from the kernel session.
104 * We own filter_expression and filter.
106 int event_kernel_enable_event(struct ltt_kernel_channel
*kchan
,
107 struct lttng_event
*event
, char *filter_expression
,
108 struct lttng_bytecode
*filter
)
111 struct ltt_kernel_event
*kevent
;
116 kevent
= trace_kernel_find_event(event
->name
, kchan
,
117 event
->type
, filter
);
118 if (kevent
== NULL
) {
119 ret
= kernel_create_event(event
, kchan
, filter_expression
, filter
);
120 /* We have passed ownership */
121 filter_expression
= NULL
;
126 } else if (kevent
->enabled
== 0) {
127 ret
= kernel_enable_event(kevent
);
129 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
133 /* At this point, the event is considered enabled */
134 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
140 free(filter_expression
);
146 * ============================
147 * UST : The Ultimate Frontier!
148 * ============================
152 * Enable UST tracepoint event for a channel from a UST session.
153 * We own filter_expression, filter, and exclusion.
155 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
156 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
157 char *filter_expression
,
158 struct lttng_bytecode
*filter
,
159 struct lttng_event_exclusion
*exclusion
,
162 int ret
= LTTNG_OK
, to_create
= 0;
163 struct ltt_ust_event
*uevent
;
171 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
172 (enum lttng_ust_abi_loglevel_type
) event
->loglevel_type
,
173 event
->loglevel
, exclusion
);
175 ret
= trace_ust_create_event(event
, filter_expression
,
176 filter
, exclusion
, internal_event
, &uevent
);
177 /* We have passed ownership */
178 filter_expression
= NULL
;
181 if (ret
!= LTTNG_OK
) {
185 /* Valid to set it after the goto error since uevent is still NULL */
189 if (uevent
->enabled
) {
190 /* It's already enabled so everything is OK */
191 LTTNG_ASSERT(!to_create
);
192 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
198 /* Add ltt ust event to channel */
199 add_unique_ust_event(uchan
->events
, uevent
);
202 if (!usess
->active
) {
207 /* Create event on all UST registered apps for session */
208 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
210 /* Enable event on all UST registered apps for session */
211 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
215 if (ret
== -LTTNG_UST_ERR_EXIST
) {
216 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
218 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
223 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
224 to_create
? "created" : "enabled", uchan
->name
);
230 free(filter_expression
);
237 * Disable UST tracepoint of a channel from a UST session.
239 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
240 struct ltt_ust_channel
*uchan
, const char *event_name
)
243 struct ltt_ust_event
*uevent
;
244 struct lttng_ht_node_str
*node
;
245 struct lttng_ht_iter iter
;
250 LTTNG_ASSERT(event_name
);
257 * We use a custom lookup since we need the iterator for the next_duplicate
258 * call in the do while loop below.
260 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
261 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
262 node
= lttng_ht_iter_get_node_str(&iter
);
264 DBG2("Trace UST event NOT found by name %s", event_name
);
265 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
270 uevent
= lttng::utils::container_of(node
, <t_ust_event::node
);
271 LTTNG_ASSERT(uevent
);
273 if (uevent
->enabled
== 0) {
274 /* It's already disabled so everything is OK */
278 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
281 if (!usess
->active
) {
284 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
285 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
286 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
290 /* Get next duplicate event by name. */
291 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
292 event_name
, &iter
.iter
);
293 node
= lttng_ht_iter_get_node_str(&iter
);
304 * Disable all UST tracepoints for a channel from a UST session.
306 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
307 struct ltt_ust_channel
*uchan
)
309 int ret
, i
, size
, error
= 0;
310 struct lttng_ht_iter iter
;
311 struct ltt_ust_event
*uevent
= NULL
;
312 struct lttng_event
*events
= NULL
;
319 /* Disabling existing events */
320 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
322 if (uevent
->enabled
== 1) {
323 ret
= event_ust_disable_tracepoint(usess
, uchan
,
326 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
332 /* Get all UST available events */
333 size
= ust_app_list_events(&events
);
335 ret
= LTTNG_ERR_UST_LIST_FAIL
;
339 for (i
= 0; i
< size
; i
++) {
340 ret
= event_ust_disable_tracepoint(usess
, uchan
,
343 /* Continue to disable the rest... */
344 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
349 ret
= error
? error
: LTTNG_OK
;
356 static void agent_enable_all(struct agent
*agt
)
358 struct agent_event
*aevent
;
359 struct lttng_ht_iter iter
;
361 /* Flag every event as enabled. */
363 cds_lfht_for_each_entry (
364 agt
->events
->ht
, &iter
.iter
, aevent
, node
.node
) {
365 aevent
->enabled_count
++;
371 * Enable all agent event for a given UST session.
373 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
375 int event_agent_enable_all(struct ltt_ust_session
*usess
,
376 struct agent
*agt
, struct lttng_event
*event
,
377 struct lttng_bytecode
*filter
,char *filter_expression
)
383 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
385 /* Enable event on agent application through TCP socket. */
386 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
387 if (ret
!= LTTNG_OK
) {
391 agent_enable_all(agt
);
400 * Check if this event's filter requires the activation of application contexts
401 * and enable them in the agent.
402 * TODO: bytecode iterator does not support non-legacy application
403 * contexts yet. Not an issue for now, since they are not generated by
404 * the lttng-ctl library.
406 static int add_filter_app_ctx(struct lttng_bytecode
*bytecode
,
407 const char *filter_expression
, struct agent
*agt
)
410 char *provider_name
= NULL
, *ctx_name
= NULL
;
411 struct bytecode_symbol_iterator
*it
=
412 bytecode_symbol_iterator_create(bytecode
);
415 ret
= LTTNG_ERR_NOMEM
;
420 struct lttng_event_context ctx
;
421 const char *symbol_name
=
422 bytecode_symbol_iterator_get_name(it
);
424 if (parse_application_context(symbol_name
, &provider_name
,
426 /* Not an application context. */
430 ctx
.ctx
= LTTNG_EVENT_CONTEXT_APP_CONTEXT
;
431 ctx
.u
.app_ctx
.provider_name
= provider_name
;
432 ctx
.u
.app_ctx
.ctx_name
= ctx_name
;
434 /* Recognized an application context. */
435 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
436 filter_expression
, provider_name
, ctx_name
);
438 ret
= agent_add_context(&ctx
, agt
);
439 if (ret
!= LTTNG_OK
) {
440 ERR("Failed to add application context %s:%s.",
441 provider_name
, ctx_name
);
445 ret
= agent_enable_context(&ctx
, agt
->domain
);
446 if (ret
!= LTTNG_OK
) {
447 ERR("Failed to enable application context %s:%s.",
448 provider_name
, ctx_name
);
454 provider_name
= ctx_name
= NULL
;
455 } while (bytecode_symbol_iterator_next(it
) == 0);
459 bytecode_symbol_iterator_destroy(it
);
463 static int agent_enable(struct agent
*agt
,
464 struct lttng_event
*event
,
465 struct lttng_bytecode
*filter
,
466 char *filter_expression
)
468 int ret
, created
= 0;
469 struct agent_event
*aevent
;
475 aevent
= agent_find_event(event
->name
, event
->loglevel_type
,
476 event
->loglevel
, filter_expression
, agt
);
478 aevent
= agent_create_event(event
->name
, event
->loglevel_type
,
479 event
->loglevel
, filter
,
482 ret
= LTTNG_ERR_NOMEM
;
486 filter_expression
= NULL
;
488 LTTNG_ASSERT(!AGENT_EVENT_IS_ENABLED(aevent
));
491 if (created
&& aevent
->filter
) {
492 ret
= add_filter_app_ctx(
493 aevent
->filter
, aevent
->filter_expression
, agt
);
494 if (ret
!= LTTNG_OK
) {
499 /* Already enabled? */
500 if (AGENT_EVENT_IS_ENABLED(aevent
)) {
505 ret
= agent_enable_event(aevent
, agt
->domain
);
506 if (ret
!= LTTNG_OK
) {
510 /* If the event was created prior to the enable, add it to the domain. */
512 agent_add_event(aevent
, agt
);
520 agent_destroy_event(aevent
);
525 free(filter_expression
);
530 * Enable a single agent event for a given UST session.
532 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
534 int event_agent_enable(struct ltt_ust_session
*usess
,
536 struct lttng_event
*event
,
537 struct lttng_bytecode
*filter
,
538 char *filter_expression
)
544 DBG("Enabling agent event: event pattern = '%s', session id = %" PRIu64
", loglevel type = %d, loglevel = %d, filter expression = '%s'",
545 event
->name
, usess
->id
, event
->loglevel_type
,
547 filter_expression
? filter_expression
: "(none)");
549 return agent_enable(agt
, event
, filter
, filter_expression
);
553 * Enable a single agent event for a trigger.
555 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
557 int trigger_agent_enable(const struct lttng_trigger
*trigger
, struct agent
*agt
)
560 enum lttng_condition_status c_status
;
561 enum lttng_trigger_status t_status
;
562 enum lttng_domain_type d_type
;
563 const struct lttng_condition
*condition
;
564 const struct lttng_event_rule
*rule
;
565 const char *filter_expression
;
566 char *filter_expression_copy
= NULL
;
567 const struct lttng_bytecode
*filter_bytecode
;
568 struct lttng_bytecode
*filter_bytecode_copy
= NULL
;
569 struct lttng_event
*event
= NULL
;
570 uid_t trigger_owner_uid
= 0;
571 const char *trigger_name
;
573 LTTNG_ASSERT(trigger
);
576 t_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
577 if (t_status
!= LTTNG_TRIGGER_STATUS_OK
) {
578 trigger_name
= "(anonymous)";
581 t_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_owner_uid
);
582 LTTNG_ASSERT(t_status
== LTTNG_TRIGGER_STATUS_OK
);
584 condition
= lttng_trigger_get_const_condition(trigger
);
586 LTTNG_ASSERT(lttng_condition_get_type(condition
) ==
587 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
);
589 c_status
= lttng_condition_event_rule_matches_get_rule(
591 LTTNG_ASSERT(c_status
== LTTNG_CONDITION_STATUS_OK
);
593 switch (lttng_event_rule_get_type(rule
)) {
594 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
595 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
596 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
603 d_type
= lttng_event_rule_get_domain_type(rule
);
604 LTTNG_ASSERT(d_type
== agt
->domain
);
606 event
= lttng_event_rule_generate_lttng_event(rule
);
608 ret
= LTTNG_ERR_NOMEM
;
612 /* Get the internal filter expression and bytecode. */
613 filter_expression
= lttng_event_rule_get_filter(rule
);
614 if (filter_expression
) {
615 filter_expression_copy
= strdup(filter_expression
);
616 if (!filter_expression_copy
) {
617 ret
= LTTNG_ERR_NOMEM
;
621 /* Get the filter bytecode */
622 filter_bytecode
= lttng_event_rule_get_filter_bytecode(rule
);
623 if (filter_bytecode
) {
624 filter_bytecode_copy
=
625 lttng_bytecode_copy(filter_bytecode
);
626 if (!filter_bytecode_copy
) {
627 ret
= LTTNG_ERR_NOMEM
;
633 DBG("Enabling agent event from trigger: trigger name = '%s', trigger owner uid = %d, token = %" PRIu64
,
634 trigger_name
, trigger_owner_uid
,
635 lttng_trigger_get_tracer_token(trigger
));
637 ret
= agent_enable(agt
, event
, filter_bytecode_copy
,
638 filter_expression_copy
);
639 /* Ownership was passed even in case of error. */
640 filter_expression_copy
= NULL
;
641 filter_bytecode_copy
= NULL
;
644 free(filter_expression_copy
);
645 free(filter_bytecode_copy
);
651 * Return the default event name associated with the provided UST domain. Return
654 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
656 const char *default_event_name
= NULL
;
659 case LTTNG_DOMAIN_LOG4J
:
660 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
662 case LTTNG_DOMAIN_JUL
:
663 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
665 case LTTNG_DOMAIN_PYTHON
:
666 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
672 return default_event_name
;
675 static int trigger_agent_disable_one(const struct lttng_trigger
*trigger
,
677 struct agent_event
*aevent
)
683 LTTNG_ASSERT(trigger
);
684 LTTNG_ASSERT(aevent
);
687 * Actual ust event un-registration happens on the trigger
688 * un-registration at that point.
691 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for trigger %" PRIu64
,
692 aevent
->name
, aevent
->loglevel_type
,
693 aevent
->loglevel_value
, lttng_trigger_get_tracer_token(trigger
));
695 /* Already disabled? */
696 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
700 ret
= agent_disable_event(aevent
, agt
->domain
);
701 if (ret
!= LTTNG_OK
) {
713 * Disable a given agent event for a given UST session.
715 * Must be called with the RCU read lock held.
716 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
718 static int event_agent_disable_one(struct ltt_ust_session
*usess
,
719 struct agent
*agt
, struct agent_event
*aevent
)
722 struct ltt_ust_event
*uevent
= NULL
;
723 struct ltt_ust_channel
*uchan
= NULL
;
724 const char *ust_event_name
, *ust_channel_name
;
728 LTTNG_ASSERT(aevent
);
730 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64
,
731 aevent
->name
, aevent
->loglevel_type
, aevent
->loglevel_value
,
734 /* Already disabled? */
735 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
739 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
740 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
741 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
742 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
743 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
744 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
746 ret
= LTTNG_ERR_INVALID
;
751 * Disable it on the UST side. First get the channel reference then find
752 * the event and finally disable it.
754 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
755 (char *) ust_channel_name
);
757 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
761 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
762 if (!ust_event_name
) {
763 ret
= LTTNG_ERR_FATAL
;
768 * Agent UST event has its loglevel type forced to
769 * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
770 * happens thanks to an UST filter. The following -1 is actually
771 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
773 uevent
= trace_ust_find_event(uchan
->events
, (char *) ust_event_name
,
774 aevent
->filter
, LTTNG_UST_ABI_LOGLEVEL_ALL
, -1, NULL
);
775 /* If the agent event exists, it must be available on the UST side. */
776 LTTNG_ASSERT(uevent
);
779 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
780 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
781 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
787 * Flag event that it's disabled so the shadow copy on the ust app side
788 * will disable it if an application shows up.
792 ret
= agent_disable_event(aevent
, agt
->domain
);
793 if (ret
!= LTTNG_OK
) {
805 * Disable agent event matching a given trigger.
807 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
809 int trigger_agent_disable(
810 const struct lttng_trigger
*trigger
, struct agent
*agt
)
813 struct agent_event
*aevent
;
815 LTTNG_ASSERT(trigger
);
818 DBG("Event agent disabling for trigger %" PRIu64
,
819 lttng_trigger_get_tracer_token(trigger
));
822 aevent
= agent_find_event_by_trigger(trigger
, agt
);
824 if (aevent
== NULL
) {
825 DBG2("Event agent NOT found by trigger %" PRIu64
,
826 lttng_trigger_get_tracer_token(trigger
));
827 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
831 ret
= trigger_agent_disable_one(trigger
, agt
, aevent
);
833 if (ret
!= LTTNG_OK
) {
843 * Disable all agent events matching a given name for a given UST session.
845 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
847 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
848 const char *event_name
)
851 struct agent_event
*aevent
;
852 struct lttng_ht_iter iter
;
853 struct lttng_ht_node_str
*node
;
857 LTTNG_ASSERT(event_name
);
859 DBG("Event agent disabling %s (all loglevels) for session %" PRIu64
, event_name
, usess
->id
);
862 agent_find_events_by_name(event_name
, agt
, &iter
);
863 node
= lttng_ht_iter_get_node_str(&iter
);
866 DBG2("Event agent NOT found by name %s", event_name
);
867 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
872 aevent
= lttng::utils::container_of(node
, &agent_event::node
);
873 ret
= event_agent_disable_one(usess
, agt
, aevent
);
875 if (ret
!= LTTNG_OK
) {
879 /* Get next duplicate agent event by name. */
880 agent_event_next_duplicate(event_name
, agt
, &iter
);
881 node
= lttng_ht_iter_get_node_str(&iter
);
888 * Disable all agent event for a given UST session.
890 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
892 int event_agent_disable_all(struct ltt_ust_session
*usess
,
896 struct agent_event
*aevent
;
897 struct lttng_ht_iter iter
;
903 * Disable event on agent application. Continue to disable all other events
904 * if the * event is not found.
906 ret
= event_agent_disable(usess
, agt
, "*");
907 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
911 /* Disable every event. */
913 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
915 if (!AGENT_EVENT_IS_ENABLED(aevent
)) {
919 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
920 if (ret
!= LTTNG_OK
) {