2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <urcu/list.h>
24 #include <lttng/lttng.h>
25 #include <common/error.h>
26 #include <common/sessiond-comm/sessiond-comm.h>
31 #include "lttng-sessiond.h"
34 #include "trace-kernel.h"
35 #include "trace-ust.h"
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_filter_bytecode
*) event
->filter
;
52 key
.loglevel
= event
->attr
.loglevel
;
53 key
.exclusion
= event
->exclusion
;
55 node_ptr
= cds_lfht_add_unique(ht
->ht
,
56 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
57 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
58 assert(node_ptr
== &event
->node
.node
);
62 * Disable kernel tracepoint event for a channel from the kernel session.
64 int event_kernel_disable_tracepoint(struct ltt_kernel_channel
*kchan
,
68 struct ltt_kernel_event
*kevent
;
72 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
);
74 ret
= LTTNG_ERR_NO_EVENT
;
78 ret
= kernel_disable_event(kevent
);
80 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
84 DBG("Kernel event %s disable for channel %s.",
85 kevent
->event
->name
, kchan
->channel
->name
);
94 * Enable kernel system call for a channel from the kernel session.
96 int event_kernel_enable_syscall(struct ltt_kernel_channel
*kchan
,
103 ret
= kernel_enable_syscall(syscall_name
, kchan
);
105 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
109 DBG("Kernel syscall %s enable for channel %s.",
110 syscall_name
, kchan
->channel
->name
);
119 * Disable kernel system call for a channel from the kernel session.
121 int event_kernel_disable_syscall(struct ltt_kernel_channel
*kchan
,
128 ret
= kernel_disable_syscall(syscall_name
, kchan
);
130 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
134 DBG("Kernel syscall %s disable for channel %s.",
135 !strcmp(syscall_name
, "*") ? "<all>" : syscall_name
,
136 kchan
->channel
->name
);
145 * Disable kernel tracepoint events for a channel from the kernel session.
147 int event_kernel_disable_all_tracepoints(struct ltt_kernel_channel
*kchan
)
150 struct ltt_kernel_event
*kevent
;
154 /* For each event in the kernel session */
155 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
156 ret
= kernel_disable_event(kevent
);
158 /* We continue disabling the rest */
167 * Disable all kernel event for a channel from the kernel session.
169 int event_kernel_disable_all(struct ltt_kernel_channel
*kchan
)
175 ret
= event_kernel_disable_all_tracepoints(kchan
);
178 ret
= event_kernel_disable_syscall(kchan
, "*");
183 * Enable kernel tracepoint event for a channel from the kernel session.
184 * We own filter_expression and filter.
186 int event_kernel_enable_tracepoint(struct ltt_kernel_channel
*kchan
,
187 struct lttng_event
*event
)
190 struct ltt_kernel_event
*kevent
;
195 kevent
= trace_kernel_get_event_by_name(event
->name
, kchan
);
196 if (kevent
== NULL
) {
197 ret
= kernel_create_event(event
, kchan
);
201 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
204 ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
207 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
212 } else if (kevent
->enabled
== 0) {
213 ret
= kernel_enable_event(kevent
);
215 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
219 /* At this point, the event is considered enabled */
220 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
230 * ============================
231 * UST : The Ultimate Frontier!
232 * ============================
236 * Enable all UST tracepoints for a channel from a UST session.
238 int event_ust_enable_all_tracepoints(struct ltt_ust_session
*usess
,
239 struct ltt_ust_channel
*uchan
,
240 char *filter_expression
,
241 struct lttng_filter_bytecode
*filter
)
244 struct lttng_ht_iter iter
;
245 struct ltt_ust_event
*uevent
= NULL
;
246 struct lttng_event
*events
= NULL
;
253 /* Enable existing events */
254 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
256 if (uevent
->enabled
== 0) {
257 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
265 /* Get all UST available events */
266 size
= ust_app_list_events(&events
);
268 ret
= LTTNG_ERR_UST_LIST_FAIL
;
272 for (i
= 0; i
< size
; i
++) {
274 * Check if event exist and if so, continue since it was enable
277 uevent
= trace_ust_find_event(uchan
->events
, events
[i
].name
, filter
,
278 events
[i
].loglevel
, NULL
);
279 if (uevent
!= NULL
) {
280 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
283 if (ret
!= -LTTNG_UST_ERR_EXIST
) {
284 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
291 /* Create ust event */
292 uevent
= trace_ust_create_event(&events
[i
], filter_expression
,
294 if (uevent
== NULL
) {
295 ret
= LTTNG_ERR_FATAL
;
299 /* Create event for the specific PID */
300 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
303 if (ret
== -LTTNG_UST_ERR_EXIST
) {
304 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
307 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
313 /* Add ltt ust event to channel */
315 add_unique_ust_event(uchan
->events
, uevent
);
324 trace_ust_destroy_event(uevent
);
333 * Enable UST tracepoint event for a channel from a UST session.
334 * We own filter_expression, filter, and exclusion.
336 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
337 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
338 char *filter_expression
,
339 struct lttng_filter_bytecode
*filter
,
340 struct lttng_event_exclusion
*exclusion
)
342 int ret
= LTTNG_OK
, to_create
= 0;
343 struct ltt_ust_event
*uevent
;
351 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
352 event
->loglevel
, exclusion
);
353 if (uevent
== NULL
) {
354 uevent
= trace_ust_create_event(event
, filter_expression
,
356 /* We have passed ownership */
357 filter_expression
= NULL
;
360 if (uevent
== NULL
) {
361 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
365 /* Valid to set it after the goto error since uevent is still NULL */
369 if (uevent
->enabled
) {
370 /* It's already enabled so everything is OK */
371 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
378 /* Create event on all UST registered apps for session */
379 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
381 /* Enable event on all UST registered apps for session */
382 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
386 if (ret
== -LTTNG_UST_ERR_EXIST
) {
387 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
390 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
396 /* Add ltt ust event to channel */
397 add_unique_ust_event(uchan
->events
, uevent
);
400 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
401 to_create
? "created" : "enabled", uchan
->name
);
407 free(filter_expression
);
414 * Only destroy event on creation time (not enabling time) because if the
415 * event is found in the channel (to_create == 0), it means that at some
416 * point the enable_event worked and it's thus valid to keep it alive.
417 * Destroying it also implies that we also destroy it's shadow copy to sync
421 /* In this code path, the uevent was not added to the hash table */
422 trace_ust_destroy_event(uevent
);
425 free(filter_expression
);
432 * Disable UST tracepoint of a channel from a UST session.
434 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
435 struct ltt_ust_channel
*uchan
, char *event_name
)
438 struct ltt_ust_event
*uevent
;
439 struct lttng_ht_node_str
*node
;
440 struct lttng_ht_iter iter
;
452 * We use a custom lookup since we need the iterator for the next_duplicate
453 * call in the do while loop below.
455 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
456 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
457 node
= lttng_ht_iter_get_node_str(&iter
);
459 DBG2("Trace UST event NOT found by name %s", event_name
);
460 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
465 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
468 if (uevent
->enabled
== 0) {
469 /* It's already disabled so everything is OK */
473 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
474 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
475 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
480 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
484 /* Get next duplicate event by name. */
485 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
486 event_name
, &iter
.iter
);
487 node
= lttng_ht_iter_get_node_str(&iter
);
498 * Disable all UST tracepoints for a channel from a UST session.
500 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
501 struct ltt_ust_channel
*uchan
)
504 struct lttng_ht_iter iter
;
505 struct ltt_ust_event
*uevent
= NULL
;
506 struct lttng_event
*events
= NULL
;
513 /* Disabling existing events */
514 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
516 if (uevent
->enabled
== 1) {
517 ret
= event_ust_disable_tracepoint(usess
, uchan
,
525 /* Get all UST available events */
526 size
= ust_app_list_events(&events
);
528 ret
= LTTNG_ERR_UST_LIST_FAIL
;
532 for (i
= 0; i
< size
; i
++) {
533 ret
= event_ust_disable_tracepoint(usess
, uchan
,
535 if (ret
!= LTTNG_OK
) {
536 /* Continue to disable the rest... */
552 * Enable all agent event for a given UST session.
554 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
556 int event_agent_enable_all(struct ltt_ust_session
*usess
,
557 struct agent
*agt
, struct lttng_event
*event
,
558 struct lttng_filter_bytecode
*filter
)
561 struct agent_event
*aevent
;
562 struct lttng_ht_iter iter
;
566 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
568 /* Enable event on agent application through TCP socket. */
569 ret
= event_agent_enable(usess
, agt
, event
, filter
);
570 if (ret
!= LTTNG_OK
) {
574 /* Flag every event that they are now enabled. */
576 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
589 * Enable a single agent event for a given UST session.
591 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
593 int event_agent_enable(struct ltt_ust_session
*usess
,
594 struct agent
*agt
, struct lttng_event
*event
,
595 struct lttng_filter_bytecode
*filter
)
597 int ret
, created
= 0;
598 struct agent_event
*aevent
;
604 DBG("Event agent enabling %s for session %" PRIu64
" with loglevel type %d "
605 "and loglevel %d", event
->name
, usess
->id
, event
->loglevel_type
,
608 aevent
= agent_find_event(event
->name
, event
->loglevel
, agt
);
610 aevent
= agent_create_event(event
->name
, filter
);
612 ret
= LTTNG_ERR_NOMEM
;
615 aevent
->loglevel
= event
->loglevel
;
616 aevent
->loglevel_type
= event
->loglevel_type
;
620 /* Already enabled? */
621 if (aevent
->enabled
) {
625 ret
= agent_enable_event(aevent
, agt
->domain
);
626 if (ret
!= LTTNG_OK
) {
630 /* If the event was created prior to the enable, add it to the domain. */
632 agent_add_event(aevent
, agt
);
640 agent_destroy_event(aevent
);
646 * Return the agent default event name to use by testing if the process is root
647 * or not. Return NULL on error.
649 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
651 const char *default_event_name
= NULL
;
654 case LTTNG_DOMAIN_LOG4J
:
656 default_event_name
= DEFAULT_SYS_LOG4J_EVENT_NAME
;
658 default_event_name
= DEFAULT_USER_LOG4J_EVENT_NAME
;
661 case LTTNG_DOMAIN_JUL
:
663 default_event_name
= DEFAULT_SYS_JUL_EVENT_NAME
;
665 default_event_name
= DEFAULT_USER_JUL_EVENT_NAME
;
668 case LTTNG_DOMAIN_PYTHON
:
669 default_event_name
= DEFAULT_USER_PYTHON_EVENT_NAME
;
675 return default_event_name
;
679 * Disable a single agent event for a given UST session.
681 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
683 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
687 struct agent_event
*aevent
;
688 struct ltt_ust_event
*uevent
= NULL
;
689 struct ltt_ust_channel
*uchan
= NULL
;
690 const char *ust_event_name
, *ust_channel_name
;
696 DBG("Event agent disabling %s for session %" PRIu64
, event_name
, usess
->id
);
698 aevent
= agent_find_event_by_name(event_name
, agt
);
700 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
704 /* Already disabled? */
705 if (!aevent
->enabled
) {
709 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
710 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
711 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
712 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
713 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
714 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
716 ret
= LTTNG_ERR_INVALID
;
721 * Disable it on the UST side. First get the channel reference then find
722 * the event and finally disable it.
724 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
725 (char *) ust_channel_name
);
727 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
731 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
732 if (!ust_event_name
) {
733 ret
= LTTNG_ERR_FATAL
;
738 * The loglevel is hardcoded with 0 here since the agent ust event is set
739 * with the loglevel type to ALL thus the loglevel stays 0. The event's
740 * filter is the one handling the loglevel for agent.
742 uevent
= trace_ust_find_event(uchan
->events
, (char *) ust_event_name
,
743 aevent
->filter
, 0, NULL
);
744 /* If the agent event exists, it must be available on the UST side. */
747 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
748 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
749 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
754 * Flag event that it's disabled so the shadow copy on the ust app side
755 * will disable it if an application shows up.
759 ret
= agent_disable_event(aevent
, agt
->domain
);
760 if (ret
!= LTTNG_OK
) {
771 * Disable all agent event for a given UST session.
773 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
775 int event_agent_disable_all(struct ltt_ust_session
*usess
,
779 struct agent_event
*aevent
;
780 struct lttng_ht_iter iter
;
786 * Disable event on agent application. Continue to disable all other events
787 * if the * event is not found.
789 ret
= event_agent_disable(usess
, agt
, "*");
790 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
794 /* Flag every event that they are now enabled. */
796 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
798 if (!aevent
->enabled
) {
802 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
803 if (ret
!= LTTNG_OK
) {