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
11 #include <urcu/list.h>
14 #include <lttng/lttng.h>
15 #include <common/error.h>
16 #include <common/sessiond-comm/sessiond-comm.h>
17 #include <common/filter.h>
18 #include <common/context.h>
23 #include "lttng-sessiond.h"
24 #include "lttng-ust-ctl.h"
25 #include "lttng-ust-error.h"
27 #include "trace-kernel.h"
28 #include "trace-ust.h"
32 * Add unique UST event based on the event name, filter bytecode and loglevel.
34 static void add_unique_ust_event(struct lttng_ht
*ht
,
35 struct ltt_ust_event
*event
)
37 struct cds_lfht_node
*node_ptr
;
38 struct ltt_ust_ht_key key
;
44 key
.name
= event
->attr
.name
;
45 key
.filter
= (struct lttng_filter_bytecode
*) event
->filter
;
46 key
.loglevel_type
= event
->attr
.loglevel_type
;
47 key
.loglevel_value
= event
->attr
.loglevel
;
48 key
.exclusion
= event
->exclusion
;
50 node_ptr
= cds_lfht_add_unique(ht
->ht
,
51 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
52 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
53 assert(node_ptr
== &event
->node
.node
);
57 * Disable kernel tracepoint events for a channel from the kernel session of
58 * a specified event_name and event type.
59 * On type LTTNG_EVENT_ALL all events with event_name are disabled.
60 * If event_name is NULL all events of the specified type are disabled.
62 int event_kernel_disable_event(struct ltt_kernel_channel
*kchan
,
63 const char *event_name
, enum lttng_event_type type
)
65 int ret
, error
= 0, found
= 0;
66 struct ltt_kernel_event
*kevent
;
70 /* For each event in the kernel session */
71 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
72 if (type
!= LTTNG_EVENT_ALL
&& kevent
->type
!= type
)
74 if (event_name
!= NULL
&& strcmp(event_name
, kevent
->event
->name
)) {
78 ret
= kernel_disable_event(kevent
);
84 DBG("Disable kernel event: found %d events with name: %s and type: %d",
85 found
, event_name
? event_name
: "NULL", type
);
87 if (event_name
!= NULL
&& !found
) {
88 ret
= LTTNG_ERR_NO_EVENT
;
90 ret
= error
? LTTNG_ERR_KERN_DISABLE_FAIL
: LTTNG_OK
;
97 * Enable kernel tracepoint event for a channel from the kernel session.
98 * We own filter_expression and filter.
100 int event_kernel_enable_event(struct ltt_kernel_channel
*kchan
,
101 struct lttng_event
*event
, char *filter_expression
,
102 struct lttng_filter_bytecode
*filter
)
105 struct ltt_kernel_event
*kevent
;
110 kevent
= trace_kernel_find_event(event
->name
, kchan
,
111 event
->type
, filter
);
112 if (kevent
== NULL
) {
113 ret
= kernel_create_event(event
, kchan
, filter_expression
, filter
);
114 /* We have passed ownership */
115 filter_expression
= NULL
;
120 } else if (kevent
->enabled
== 0) {
121 ret
= kernel_enable_event(kevent
);
123 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
127 /* At this point, the event is considered enabled */
128 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
134 free(filter_expression
);
140 * ============================
141 * UST : The Ultimate Frontier!
142 * ============================
146 * Enable UST tracepoint event for a channel from a UST session.
147 * We own filter_expression, filter, and exclusion.
149 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
150 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
151 char *filter_expression
,
152 struct lttng_filter_bytecode
*filter
,
153 struct lttng_event_exclusion
*exclusion
,
156 int ret
= LTTNG_OK
, to_create
= 0;
157 struct ltt_ust_event
*uevent
;
165 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
166 (enum lttng_ust_loglevel_type
) event
->loglevel_type
,
167 event
->loglevel
, exclusion
);
169 ret
= trace_ust_create_event(event
, filter_expression
,
170 filter
, exclusion
, internal_event
, &uevent
);
171 /* We have passed ownership */
172 filter_expression
= NULL
;
175 if (ret
!= LTTNG_OK
) {
179 /* Valid to set it after the goto error since uevent is still NULL */
183 if (uevent
->enabled
) {
184 /* It's already enabled so everything is OK */
186 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
192 /* Add ltt ust event to channel */
193 add_unique_ust_event(uchan
->events
, uevent
);
196 if (!usess
->active
) {
201 /* Create event on all UST registered apps for session */
202 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
204 /* Enable event on all UST registered apps for session */
205 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
209 if (ret
== -LTTNG_UST_ERR_EXIST
) {
210 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
212 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
217 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
218 to_create
? "created" : "enabled", uchan
->name
);
224 free(filter_expression
);
231 * Disable UST tracepoint of a channel from a UST session.
233 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
234 struct ltt_ust_channel
*uchan
, const char *event_name
)
237 struct ltt_ust_event
*uevent
;
238 struct lttng_ht_node_str
*node
;
239 struct lttng_ht_iter iter
;
251 * We use a custom lookup since we need the iterator for the next_duplicate
252 * call in the do while loop below.
254 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
255 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
256 node
= lttng_ht_iter_get_node_str(&iter
);
258 DBG2("Trace UST event NOT found by name %s", event_name
);
259 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
264 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
267 if (uevent
->enabled
== 0) {
268 /* It's already disabled so everything is OK */
272 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
275 if (!usess
->active
) {
278 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
279 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
280 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
284 /* Get next duplicate event by name. */
285 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
286 event_name
, &iter
.iter
);
287 node
= lttng_ht_iter_get_node_str(&iter
);
298 * Disable all UST tracepoints for a channel from a UST session.
300 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
301 struct ltt_ust_channel
*uchan
)
303 int ret
, i
, size
, error
= 0;
304 struct lttng_ht_iter iter
;
305 struct ltt_ust_event
*uevent
= NULL
;
306 struct lttng_event
*events
= NULL
;
313 /* Disabling existing events */
314 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
316 if (uevent
->enabled
== 1) {
317 ret
= event_ust_disable_tracepoint(usess
, uchan
,
320 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
326 /* Get all UST available events */
327 size
= ust_app_list_events(&events
);
329 ret
= LTTNG_ERR_UST_LIST_FAIL
;
333 for (i
= 0; i
< size
; i
++) {
334 ret
= event_ust_disable_tracepoint(usess
, uchan
,
337 /* Continue to disable the rest... */
338 error
= LTTNG_ERR_UST_DISABLE_FAIL
;
343 ret
= error
? error
: LTTNG_OK
;
351 * Enable all agent event for a given UST session.
353 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
355 int event_agent_enable_all(struct ltt_ust_session
*usess
,
356 struct agent
*agt
, struct lttng_event
*event
,
357 struct lttng_filter_bytecode
*filter
,char *filter_expression
)
360 struct agent_event
*aevent
;
361 struct lttng_ht_iter iter
;
365 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
367 /* Enable event on agent application through TCP socket. */
368 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
369 if (ret
!= LTTNG_OK
) {
373 /* Flag every event that they are now enabled. */
375 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
388 * Check if this event's filter requires the activation of application contexts
389 * and enable them in the agent.
390 * TODO: bytecode iterator does not support non-legacy application
391 * contexts yet. Not an issue for now, since they are not generated by
392 * the lttng-ctl library.
394 static int add_filter_app_ctx(struct lttng_filter_bytecode
*bytecode
,
395 const char *filter_expression
, struct agent
*agt
)
398 char *provider_name
= NULL
, *ctx_name
= NULL
;
399 struct bytecode_symbol_iterator
*it
=
400 bytecode_symbol_iterator_create(bytecode
);
403 ret
= LTTNG_ERR_NOMEM
;
408 struct lttng_event_context ctx
;
409 const char *symbol_name
=
410 bytecode_symbol_iterator_get_name(it
);
412 if (parse_application_context(symbol_name
, &provider_name
,
414 /* Not an application context. */
418 ctx
.ctx
= LTTNG_EVENT_CONTEXT_APP_CONTEXT
;
419 ctx
.u
.app_ctx
.provider_name
= provider_name
;
420 ctx
.u
.app_ctx
.ctx_name
= ctx_name
;
422 /* Recognized an application context. */
423 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
424 filter_expression
, provider_name
, ctx_name
);
426 ret
= agent_add_context(&ctx
, agt
);
427 if (ret
!= LTTNG_OK
) {
428 ERR("Failed to add application context %s:%s.",
429 provider_name
, ctx_name
);
433 ret
= agent_enable_context(&ctx
, agt
->domain
);
434 if (ret
!= LTTNG_OK
) {
435 ERR("Failed to enable application context %s:%s.",
436 provider_name
, ctx_name
);
442 provider_name
= ctx_name
= NULL
;
443 } while (bytecode_symbol_iterator_next(it
) == 0);
447 bytecode_symbol_iterator_destroy(it
);
452 * Enable a single agent event for a given UST session.
454 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
456 int event_agent_enable(struct ltt_ust_session
*usess
,
457 struct agent
*agt
, struct lttng_event
*event
,
458 struct lttng_filter_bytecode
*filter
,
459 char *filter_expression
)
461 int ret
, created
= 0;
462 struct agent_event
*aevent
;
468 DBG("Event agent enabling %s for session %" PRIu64
" with loglevel type %d "
469 ", loglevel %d and filter \"%s\"", event
->name
,
470 usess
->id
, event
->loglevel_type
, event
->loglevel
,
471 filter_expression
? filter_expression
: "NULL");
473 aevent
= agent_find_event(event
->name
, event
->loglevel_type
,
474 event
->loglevel
, filter_expression
, agt
);
476 aevent
= agent_create_event(event
->name
, event
->loglevel_type
,
477 event
->loglevel
, filter
,
480 ret
= LTTNG_ERR_NOMEM
;
484 filter_expression
= NULL
;
486 assert(!aevent
->enabled
);
489 if (created
&& aevent
->filter
) {
490 ret
= add_filter_app_ctx(
491 aevent
->filter
, aevent
->filter_expression
, agt
);
492 if (ret
!= LTTNG_OK
) {
497 /* Already enabled? */
498 if (aevent
->enabled
) {
503 ret
= agent_enable_event(aevent
, agt
->domain
);
504 if (ret
!= LTTNG_OK
) {
508 /* If the event was created prior to the enable, add it to the domain. */
510 agent_add_event(aevent
, agt
);
518 agent_destroy_event(aevent
);
522 free(filter_expression
);
527 * Return the default event name associated with the provided UST domain. Return
530 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
532 const char *default_event_name
= NULL
;
535 case LTTNG_DOMAIN_LOG4J
:
536 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
538 case LTTNG_DOMAIN_JUL
:
539 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
541 case LTTNG_DOMAIN_PYTHON
:
542 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
548 return default_event_name
;
552 * Disable a given agent event for a given UST session.
554 * Must be called with the RCU read lock held.
555 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
557 static int event_agent_disable_one(struct ltt_ust_session
*usess
,
558 struct agent
*agt
, struct agent_event
*aevent
)
561 struct ltt_ust_event
*uevent
= NULL
;
562 struct ltt_ust_channel
*uchan
= NULL
;
563 const char *ust_event_name
, *ust_channel_name
;
569 DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64
,
570 aevent
->name
, aevent
->loglevel_type
, aevent
->loglevel_value
,
573 /* Already disabled? */
574 if (!aevent
->enabled
) {
578 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
579 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
580 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
581 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
582 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
583 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
585 ret
= LTTNG_ERR_INVALID
;
590 * Disable it on the UST side. First get the channel reference then find
591 * the event and finally disable it.
593 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
594 (char *) ust_channel_name
);
596 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
600 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
601 if (!ust_event_name
) {
602 ret
= LTTNG_ERR_FATAL
;
607 * Agent UST event has its loglevel type forced to
608 * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
609 * happens thanks to an UST filter. The following -1 is actually
610 * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
612 uevent
= trace_ust_find_event(uchan
->events
, (char *) ust_event_name
,
613 aevent
->filter
, LTTNG_UST_LOGLEVEL_ALL
, -1, NULL
);
614 /* If the agent event exists, it must be available on the UST side. */
618 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
619 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
620 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
626 * Flag event that it's disabled so the shadow copy on the ust app side
627 * will disable it if an application shows up.
631 ret
= agent_disable_event(aevent
, agt
->domain
);
632 if (ret
!= LTTNG_OK
) {
644 * Disable all agent events matching a given name for a given UST session.
646 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
648 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
649 const char *event_name
)
652 struct agent_event
*aevent
;
653 struct lttng_ht_iter iter
;
654 struct lttng_ht_node_str
*node
;
660 DBG("Event agent disabling %s (all loglevels) for session %" PRIu64
, event_name
, usess
->id
);
663 agent_find_events_by_name(event_name
, agt
, &iter
);
664 node
= lttng_ht_iter_get_node_str(&iter
);
667 DBG2("Event agent NOT found by name %s", event_name
);
668 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
673 aevent
= caa_container_of(node
, struct agent_event
, node
);
674 ret
= event_agent_disable_one(usess
, agt
, aevent
);
676 if (ret
!= LTTNG_OK
) {
680 /* Get next duplicate agent event by name. */
681 agent_event_next_duplicate(event_name
, agt
, &iter
);
682 node
= lttng_ht_iter_get_node_str(&iter
);
689 * Disable all agent event for a given UST session.
691 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
693 int event_agent_disable_all(struct ltt_ust_session
*usess
,
697 struct agent_event
*aevent
;
698 struct lttng_ht_iter iter
;
704 * Disable event on agent application. Continue to disable all other events
705 * if the * event is not found.
707 ret
= event_agent_disable(usess
, agt
, "*");
708 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
712 /* Disable every event. */
714 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
716 if (!aevent
->enabled
) {
720 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
721 if (ret
!= LTTNG_OK
) {