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.
20 #include <urcu/list.h>
23 #include <lttng/lttng.h>
24 #include <common/error.h>
25 #include <common/sessiond-comm/sessiond-comm.h>
30 #include "lttng-sessiond.h"
33 #include "trace-kernel.h"
34 #include "trace-ust.h"
37 * Add unique UST event based on the event name, filter bytecode and loglevel.
39 static void add_unique_ust_event(struct lttng_ht
*ht
,
40 struct ltt_ust_event
*event
)
42 struct cds_lfht_node
*node_ptr
;
43 struct ltt_ust_ht_key key
;
49 key
.name
= event
->attr
.name
;
50 key
.filter
= (struct lttng_filter_bytecode
*) event
->filter
;
51 key
.loglevel
= event
->attr
.loglevel
;
52 key
.exclusion
= event
->exclusion
;
54 node_ptr
= cds_lfht_add_unique(ht
->ht
,
55 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
56 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
57 assert(node_ptr
== &event
->node
.node
);
61 * Disable kernel tracepoint event for a channel from the kernel session.
63 int event_kernel_disable_tracepoint(struct ltt_kernel_channel
*kchan
,
67 struct ltt_kernel_event
*kevent
;
71 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
);
73 ret
= LTTNG_ERR_NO_EVENT
;
77 ret
= kernel_disable_event(kevent
);
79 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
83 DBG("Kernel event %s disable for channel %s.",
84 kevent
->event
->name
, kchan
->channel
->name
);
93 * Enable kernel system call for a channel from the kernel session.
95 int event_kernel_enable_syscall(struct ltt_kernel_channel
*kchan
,
102 ret
= kernel_enable_syscall(syscall_name
, kchan
);
104 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
108 DBG("Kernel event %s enable for channel %s.",
109 syscall_name
, kchan
->channel
->name
);
118 * Disable kernel system call for a channel from the kernel session.
120 int event_kernel_disable_syscall(struct ltt_kernel_channel
*kchan
,
127 ret
= kernel_disable_syscall(syscall_name
, kchan
);
129 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
133 DBG("Kernel syscall %s disable for channel %s.",
134 syscall_name
[0] == '\0' ? "<all>" : syscall_name
,
135 kchan
->channel
->name
);
144 * Disable kernel tracepoint events for a channel from the kernel session.
146 int event_kernel_disable_all_tracepoints(struct ltt_kernel_channel
*kchan
)
149 struct ltt_kernel_event
*kevent
;
153 /* For each event in the kernel session */
154 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
155 ret
= kernel_disable_event(kevent
);
157 /* We continue disabling the rest */
166 * Disable all kernel event for a channel from the kernel session.
168 int event_kernel_disable_all(struct ltt_kernel_channel
*kchan
)
174 ret
= event_kernel_disable_all_tracepoints(kchan
);
177 ret
= event_kernel_disable_syscall(kchan
, "");
182 * Enable kernel tracepoint event for a channel from the kernel session.
183 * We own filter_expression and filter.
185 int event_kernel_enable_tracepoint(struct ltt_kernel_channel
*kchan
,
186 struct lttng_event
*event
)
189 struct ltt_kernel_event
*kevent
;
194 kevent
= trace_kernel_get_event_by_name(event
->name
, kchan
);
195 if (kevent
== NULL
) {
196 ret
= kernel_create_event(event
, kchan
);
200 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
203 ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
206 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
211 } else if (kevent
->enabled
== 0) {
212 ret
= kernel_enable_event(kevent
);
214 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
218 /* At this point, the event is considered enabled */
219 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
229 * Enable all kernel tracepoint events of a channel of the kernel session.
231 int event_kernel_enable_all_tracepoints(struct ltt_kernel_channel
*kchan
,
232 int kernel_tracer_fd
)
235 struct ltt_kernel_event
*kevent
;
236 struct lttng_event
*event_list
= NULL
;
240 /* For each event in the kernel session */
241 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
242 if (kevent
->enabled
== 0) {
243 ret
= kernel_enable_event(kevent
);
245 /* Enable failed but still continue */
251 size
= kernel_list_events(kernel_tracer_fd
, &event_list
);
253 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
257 for (i
= 0; i
< size
; i
++) {
258 kevent
= trace_kernel_get_event_by_name(event_list
[i
].name
, kchan
);
259 if (kevent
== NULL
) {
260 /* Default event type for enable all */
261 event_list
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
262 /* Enable each single tracepoint event */
263 ret
= kernel_create_event(&event_list
[i
], kchan
);
265 /* Ignore error here and continue */
277 * Enable all kernel events of a channel of the kernel session.
279 int event_kernel_enable_all(struct ltt_kernel_channel
*kchan
,
280 int kernel_tracer_fd
)
286 tp_ret
= event_kernel_enable_all_tracepoints(kchan
, kernel_tracer_fd
);
287 if (tp_ret
!= LTTNG_OK
) {
292 * Reaching this code path means that all tracepoints were enabled without
293 * errors so we ignore the error value of syscalls.
295 * At the moment, failing to enable syscalls on "lttng enable-event -a -k"
296 * is not considered an error that need to be returned to the client since
297 * tracepoints did not fail. Future work will allow us to send back
298 * multiple errors to the client in one API call.
300 (void) event_kernel_enable_syscall(kchan
, "");
307 * ============================
308 * UST : The Ultimate Frontier!
309 * ============================
313 * Enable all UST tracepoints for a channel from a UST session.
315 int event_ust_enable_all_tracepoints(struct ltt_ust_session
*usess
,
316 struct ltt_ust_channel
*uchan
,
317 char *filter_expression
,
318 struct lttng_filter_bytecode
*filter
)
321 struct lttng_ht_iter iter
;
322 struct ltt_ust_event
*uevent
= NULL
;
323 struct lttng_event
*events
= NULL
;
330 /* Enable existing events */
331 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
333 if (uevent
->enabled
== 0) {
334 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
342 /* Get all UST available events */
343 size
= ust_app_list_events(&events
);
345 ret
= LTTNG_ERR_UST_LIST_FAIL
;
349 for (i
= 0; i
< size
; i
++) {
351 * Check if event exist and if so, continue since it was enable
354 uevent
= trace_ust_find_event(uchan
->events
, events
[i
].name
, filter
,
355 events
[i
].loglevel
, NULL
);
356 if (uevent
!= NULL
) {
357 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
360 if (ret
!= -LTTNG_UST_ERR_EXIST
) {
361 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
368 /* Create ust event */
369 uevent
= trace_ust_create_event(&events
[i
], filter_expression
,
371 if (uevent
== NULL
) {
372 ret
= LTTNG_ERR_FATAL
;
376 /* Create event for the specific PID */
377 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
380 if (ret
== -LTTNG_UST_ERR_EXIST
) {
381 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
384 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
390 /* Add ltt ust event to channel */
392 add_unique_ust_event(uchan
->events
, uevent
);
401 trace_ust_destroy_event(uevent
);
410 * Enable UST tracepoint event for a channel from a UST session.
411 * We own filter_expression, filter, and exclusion.
413 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
414 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
415 char *filter_expression
,
416 struct lttng_filter_bytecode
*filter
,
417 struct lttng_event_exclusion
*exclusion
)
419 int ret
= LTTNG_OK
, to_create
= 0;
420 struct ltt_ust_event
*uevent
;
428 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
429 event
->loglevel
, exclusion
);
430 if (uevent
== NULL
) {
431 uevent
= trace_ust_create_event(event
, filter_expression
,
433 /* We have passed ownership */
434 filter_expression
= NULL
;
437 if (uevent
== NULL
) {
438 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
442 /* Valid to set it after the goto error since uevent is still NULL */
446 if (uevent
->enabled
) {
447 /* It's already enabled so everything is OK */
448 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
455 /* Create event on all UST registered apps for session */
456 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
458 /* Enable event on all UST registered apps for session */
459 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
463 if (ret
== -LTTNG_UST_ERR_EXIST
) {
464 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
467 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
473 /* Add ltt ust event to channel */
474 add_unique_ust_event(uchan
->events
, uevent
);
477 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
478 to_create
? "created" : "enabled", uchan
->name
);
484 free(filter_expression
);
491 * Only destroy event on creation time (not enabling time) because if the
492 * event is found in the channel (to_create == 0), it means that at some
493 * point the enable_event worked and it's thus valid to keep it alive.
494 * Destroying it also implies that we also destroy it's shadow copy to sync
498 /* In this code path, the uevent was not added to the hash table */
499 trace_ust_destroy_event(uevent
);
502 free(filter_expression
);
509 * Disable UST tracepoint of a channel from a UST session.
511 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
512 struct ltt_ust_channel
*uchan
, char *event_name
)
515 struct ltt_ust_event
*uevent
;
516 struct lttng_ht_node_str
*node
;
517 struct lttng_ht_iter iter
;
529 * We use a custom lookup since we need the iterator for the next_duplicate
530 * call in the do while loop below.
532 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
533 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
534 node
= lttng_ht_iter_get_node_str(&iter
);
536 DBG2("Trace UST event NOT found by name %s", event_name
);
537 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
542 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
545 if (uevent
->enabled
== 0) {
546 /* It's already disabled so everything is OK */
550 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
551 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
552 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
557 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
561 /* Get next duplicate event by name. */
562 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
563 event_name
, &iter
.iter
);
564 node
= lttng_ht_iter_get_node_str(&iter
);
575 * Disable all UST tracepoints for a channel from a UST session.
577 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
578 struct ltt_ust_channel
*uchan
)
581 struct lttng_ht_iter iter
;
582 struct ltt_ust_event
*uevent
= NULL
;
583 struct lttng_event
*events
= NULL
;
590 /* Disabling existing events */
591 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
593 if (uevent
->enabled
== 1) {
594 ret
= event_ust_disable_tracepoint(usess
, uchan
,
602 /* Get all UST available events */
603 size
= ust_app_list_events(&events
);
605 ret
= LTTNG_ERR_UST_LIST_FAIL
;
609 for (i
= 0; i
< size
; i
++) {
610 ret
= event_ust_disable_tracepoint(usess
, uchan
,
612 if (ret
!= LTTNG_OK
) {
613 /* Continue to disable the rest... */
629 * Enable all agent event for a given UST session.
631 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
633 int event_agent_enable_all(struct ltt_ust_session
*usess
,
634 struct agent
*agt
, struct lttng_event
*event
,
635 struct lttng_filter_bytecode
*filter
,
636 char *filter_expression
)
639 struct agent_event
*aevent
;
640 struct lttng_ht_iter iter
;
644 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
646 /* Enable event on agent application through TCP socket. */
647 ret
= event_agent_enable(usess
, agt
, event
, filter
, filter_expression
);
648 if (ret
!= LTTNG_OK
) {
652 /* Flag every event that they are now enabled. */
654 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
667 * Enable a single agent event for a given UST session.
669 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
671 int event_agent_enable(struct ltt_ust_session
*usess
,
672 struct agent
*agt
, struct lttng_event
*event
,
673 struct lttng_filter_bytecode
*filter
,
674 char *filter_expression
)
676 int ret
, created
= 0;
677 struct agent_event
*aevent
;
683 DBG("Event agent enabling %s for session %" PRIu64
" with loglevel type %d "
684 "and loglevel %d", event
->name
, usess
->id
, event
->loglevel_type
,
687 aevent
= agent_find_event(event
->name
, event
->loglevel
, agt
);
689 aevent
= agent_create_event(event
->name
, filter
);
691 ret
= LTTNG_ERR_NOMEM
;
694 aevent
->loglevel
= event
->loglevel
;
695 aevent
->loglevel_type
= event
->loglevel_type
;
699 /* Already enabled? */
700 if (aevent
->enabled
) {
704 ret
= agent_enable_event(aevent
, agt
->domain
);
705 if (ret
!= LTTNG_OK
) {
709 /* If the event was created prior to the enable, add it to the domain. */
711 agent_add_event(aevent
, agt
);
719 agent_destroy_event(aevent
);
725 * Return the agent default event name to use by testing if the process is root
726 * or not. Return NULL on error.
728 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
730 const char *default_event_name
= NULL
;
732 if (domain
== LTTNG_DOMAIN_JUL
) {
734 default_event_name
= DEFAULT_SYS_JUL_EVENT_NAME
;
736 default_event_name
= DEFAULT_USER_JUL_EVENT_NAME
;
738 } else if (domain
== LTTNG_DOMAIN_LOG4J
) {
740 default_event_name
= DEFAULT_SYS_LOG4J_EVENT_NAME
;
742 default_event_name
= DEFAULT_USER_LOG4J_EVENT_NAME
;
748 return default_event_name
;
753 * Disable a single agent event for a given UST session.
755 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
757 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
761 struct agent_event
*aevent
;
762 struct ltt_ust_event
*uevent
= NULL
;
763 struct ltt_ust_channel
*uchan
= NULL
;
764 const char *ust_event_name
, *ust_channel_name
;
770 DBG("Event agent disabling %s for session %" PRIu64
, event_name
, usess
->id
);
772 aevent
= agent_find_event_by_name(event_name
, agt
);
774 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
778 /* Already disabled? */
779 if (!aevent
->enabled
) {
783 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
784 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
785 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
786 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
788 ret
= LTTNG_ERR_INVALID
;
793 * Disable it on the UST side. First get the channel reference then find
794 * the event and finally disable it.
796 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
797 (char *) ust_channel_name
);
799 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
803 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
804 if (!ust_event_name
) {
805 ret
= LTTNG_ERR_FATAL
;
810 * The loglevel is hardcoded with 0 here since the agent ust event is set
811 * with the loglevel type to ALL thus the loglevel stays 0. The event's
812 * filter is the one handling the loglevel for agent.
814 uevent
= trace_ust_find_event(uchan
->events
, (char *) ust_event_name
,
815 aevent
->filter
, 0, NULL
);
816 /* If the agent event exists, it must be available on the UST side. */
819 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
820 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
821 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
826 * Flag event that it's disabled so the shadow copy on the ust app side
827 * will disable it if an application shows up.
831 ret
= agent_disable_event(aevent
, agt
->domain
);
832 if (ret
!= LTTNG_OK
) {
843 * Disable all agent event for a given UST session.
845 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
847 int event_agent_disable_all(struct ltt_ust_session
*usess
,
851 struct agent_event
*aevent
;
852 struct lttng_ht_iter iter
;
858 * Disable event on agent application. Continue to disable all other events
859 * if the * event is not found.
861 ret
= event_agent_disable(usess
, agt
, "*");
862 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
866 /* Flag every event that they are now enabled. */
868 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
870 if (!aevent
->enabled
) {
874 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
875 if (ret
!= LTTNG_OK
) {