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 * Setup a lttng_event used to enable *all* syscall tracing.
63 static void init_syscalls_kernel_event(struct lttng_event
*event
)
67 event
->name
[0] = '\0';
69 * We use LTTNG_EVENT* here since the trace kernel creation will make the
70 * right changes for the kernel.
72 event
->type
= LTTNG_EVENT_SYSCALL
;
76 * Disable kernel tracepoint event for a channel from the kernel session.
78 int event_kernel_disable_tracepoint(struct ltt_kernel_channel
*kchan
,
82 struct ltt_kernel_event
*kevent
;
86 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
);
88 ret
= LTTNG_ERR_NO_EVENT
;
92 ret
= kernel_disable_event(kevent
);
94 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
98 DBG("Kernel event %s disable for channel %s.",
99 kevent
->event
->name
, kchan
->channel
->name
);
108 * Disable kernel tracepoint events for a channel from the kernel session.
110 int event_kernel_disable_all_tracepoints(struct ltt_kernel_channel
*kchan
)
113 struct ltt_kernel_event
*kevent
;
117 /* For each event in the kernel session */
118 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
119 ret
= kernel_disable_event(kevent
);
121 /* We continue disabling the rest */
130 * Disable kernel syscall events for a channel from the kernel session.
132 int event_kernel_disable_all_syscalls(struct ltt_kernel_channel
*kchan
)
134 ERR("Cannot disable syscall tracing for existing session. Please destroy session instead.");
135 return LTTNG_OK
; /* Return OK so disable all succeeds */
139 * Disable all kernel event for a channel from the kernel session.
141 int event_kernel_disable_all(struct ltt_kernel_channel
*kchan
)
147 ret
= event_kernel_disable_all_tracepoints(kchan
);
150 ret
= event_kernel_disable_all_syscalls(kchan
);
155 * Enable kernel tracepoint event for a channel from the kernel session.
156 * We own filter_expression and filter.
158 int event_kernel_enable_tracepoint(struct ltt_kernel_channel
*kchan
,
159 struct lttng_event
*event
)
162 struct ltt_kernel_event
*kevent
;
167 kevent
= trace_kernel_get_event_by_name(event
->name
, kchan
);
168 if (kevent
== NULL
) {
169 ret
= kernel_create_event(event
, kchan
);
173 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
176 ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
179 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
184 } else if (kevent
->enabled
== 0) {
185 ret
= kernel_enable_event(kevent
);
187 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
191 /* At this point, the event is considered enabled */
192 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
202 * Enable all kernel tracepoint events of a channel of the kernel session.
204 int event_kernel_enable_all_tracepoints(struct ltt_kernel_channel
*kchan
,
205 int kernel_tracer_fd
)
208 struct ltt_kernel_event
*kevent
;
209 struct lttng_event
*event_list
= NULL
;
213 /* For each event in the kernel session */
214 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
215 if (kevent
->enabled
== 0) {
216 ret
= kernel_enable_event(kevent
);
218 /* Enable failed but still continue */
224 size
= kernel_list_events(kernel_tracer_fd
, &event_list
);
226 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
230 for (i
= 0; i
< size
; i
++) {
231 kevent
= trace_kernel_get_event_by_name(event_list
[i
].name
, kchan
);
232 if (kevent
== NULL
) {
233 /* Default event type for enable all */
234 event_list
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
235 /* Enable each single tracepoint event */
236 ret
= kernel_create_event(&event_list
[i
], kchan
);
238 /* Ignore error here and continue */
250 * Enable all kernel sycalls events of a channel of the kernel session.
252 int event_kernel_enable_all_syscalls(struct ltt_kernel_channel
*kchan
,
253 int kernel_tracer_fd
)
256 struct lttng_event event
;
260 init_syscalls_kernel_event(&event
);
262 DBG("Enabling all syscall tracing");
264 ret
= kernel_create_event(&event
, kchan
);
266 if (ret
== -EEXIST
) {
267 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
269 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
280 * Enable all kernel events of a channel of the kernel session.
282 int event_kernel_enable_all(struct ltt_kernel_channel
*kchan
,
283 int kernel_tracer_fd
)
289 tp_ret
= event_kernel_enable_all_tracepoints(kchan
, kernel_tracer_fd
);
290 if (tp_ret
!= LTTNG_OK
) {
295 * Reaching this code path means that all tracepoints were enabled without
296 * errors so we ignore the error value of syscalls.
298 * At the moment, failing to enable syscalls on "lttng enable-event -a -k"
299 * is not considered an error that need to be returned to the client since
300 * tracepoints did not fail. Future work will allow us to send back
301 * multiple errors to the client in one API call.
303 (void) event_kernel_enable_all_syscalls(kchan
, kernel_tracer_fd
);
310 * ============================
311 * UST : The Ultimate Frontier!
312 * ============================
316 * Enable all UST tracepoints for a channel from a UST session.
318 int event_ust_enable_all_tracepoints(struct ltt_ust_session
*usess
,
319 struct ltt_ust_channel
*uchan
,
320 char *filter_expression
,
321 struct lttng_filter_bytecode
*filter
)
324 struct lttng_ht_iter iter
;
325 struct ltt_ust_event
*uevent
= NULL
;
326 struct lttng_event
*events
= NULL
;
333 /* Enable existing events */
334 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
336 if (uevent
->enabled
== 0) {
337 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
345 /* Get all UST available events */
346 size
= ust_app_list_events(&events
);
348 ret
= LTTNG_ERR_UST_LIST_FAIL
;
352 for (i
= 0; i
< size
; i
++) {
354 * Check if event exist and if so, continue since it was enable
357 uevent
= trace_ust_find_event(uchan
->events
, events
[i
].name
, filter
,
358 events
[i
].loglevel
, NULL
);
359 if (uevent
!= NULL
) {
360 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
363 if (ret
!= -LTTNG_UST_ERR_EXIST
) {
364 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
371 /* Create ust event */
372 uevent
= trace_ust_create_event(&events
[i
], filter_expression
,
374 if (uevent
== NULL
) {
375 ret
= LTTNG_ERR_FATAL
;
379 /* Create event for the specific PID */
380 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
383 if (ret
== -LTTNG_UST_ERR_EXIST
) {
384 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
387 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
393 /* Add ltt ust event to channel */
395 add_unique_ust_event(uchan
->events
, uevent
);
404 trace_ust_destroy_event(uevent
);
413 * Enable UST tracepoint event for a channel from a UST session.
414 * We own filter_expression, filter, and exclusion.
416 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
417 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
418 char *filter_expression
,
419 struct lttng_filter_bytecode
*filter
,
420 struct lttng_event_exclusion
*exclusion
)
422 int ret
= LTTNG_OK
, to_create
= 0;
423 struct ltt_ust_event
*uevent
;
431 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
432 event
->loglevel
, exclusion
);
433 if (uevent
== NULL
) {
434 uevent
= trace_ust_create_event(event
, filter_expression
,
436 /* We have passed ownership */
437 filter_expression
= NULL
;
440 if (uevent
== NULL
) {
441 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
445 /* Valid to set it after the goto error since uevent is still NULL */
449 if (uevent
->enabled
) {
450 /* It's already enabled so everything is OK */
451 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
458 /* Create event on all UST registered apps for session */
459 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
461 /* Enable event on all UST registered apps for session */
462 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
466 if (ret
== -LTTNG_UST_ERR_EXIST
) {
467 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
470 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
476 /* Add ltt ust event to channel */
477 add_unique_ust_event(uchan
->events
, uevent
);
480 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
481 to_create
? "created" : "enabled", uchan
->name
);
487 free(filter_expression
);
494 * Only destroy event on creation time (not enabling time) because if the
495 * event is found in the channel (to_create == 0), it means that at some
496 * point the enable_event worked and it's thus valid to keep it alive.
497 * Destroying it also implies that we also destroy it's shadow copy to sync
501 /* In this code path, the uevent was not added to the hash table */
502 trace_ust_destroy_event(uevent
);
505 free(filter_expression
);
512 * Disable UST tracepoint of a channel from a UST session.
514 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
515 struct ltt_ust_channel
*uchan
, char *event_name
)
518 struct ltt_ust_event
*uevent
;
519 struct lttng_ht_node_str
*node
;
520 struct lttng_ht_iter iter
;
532 * We use a custom lookup since we need the iterator for the next_duplicate
533 * call in the do while loop below.
535 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
536 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
537 node
= lttng_ht_iter_get_node_str(&iter
);
539 DBG2("Trace UST event NOT found by name %s", event_name
);
540 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
545 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
548 if (uevent
->enabled
== 0) {
549 /* It's already disabled so everything is OK */
553 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
554 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
555 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
560 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
564 /* Get next duplicate event by name. */
565 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
566 event_name
, &iter
.iter
);
567 node
= lttng_ht_iter_get_node_str(&iter
);
578 * Disable all UST tracepoints for a channel from a UST session.
580 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
,
581 struct ltt_ust_channel
*uchan
)
584 struct lttng_ht_iter iter
;
585 struct ltt_ust_event
*uevent
= NULL
;
586 struct lttng_event
*events
= NULL
;
593 /* Disabling existing events */
594 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
596 if (uevent
->enabled
== 1) {
597 ret
= event_ust_disable_tracepoint(usess
, uchan
,
605 /* Get all UST available events */
606 size
= ust_app_list_events(&events
);
608 ret
= LTTNG_ERR_UST_LIST_FAIL
;
612 for (i
= 0; i
< size
; i
++) {
613 ret
= event_ust_disable_tracepoint(usess
, uchan
,
615 if (ret
!= LTTNG_OK
) {
616 /* Continue to disable the rest... */
632 * Enable all JUL event for a given UST session.
634 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
636 int event_jul_enable_all(struct ltt_ust_session
*usess
,
637 struct lttng_event
*event
, struct lttng_filter_bytecode
*filter
)
640 struct jul_event
*jevent
;
641 struct lttng_ht_iter iter
;
645 DBG("Event JUL enabling ALL events for session %" PRIu64
, usess
->id
);
647 /* Enable event on JUL application through TCP socket. */
648 ret
= event_jul_enable(usess
, event
, filter
);
649 if (ret
!= LTTNG_OK
) {
653 /* Flag every event that they are now enabled. */
655 cds_lfht_for_each_entry(usess
->domain_jul
.events
->ht
, &iter
.iter
, jevent
,
668 * Enable a single JUL event for a given UST session.
670 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
672 int event_jul_enable(struct ltt_ust_session
*usess
, struct lttng_event
*event
,
673 struct lttng_filter_bytecode
*filter
)
675 int ret
, created
= 0;
676 struct jul_event
*jevent
;
681 DBG("Event JUL enabling %s for session %" PRIu64
" with loglevel type %d "
682 "and loglevel %d", event
->name
, usess
->id
, event
->loglevel_type
,
685 jevent
= jul_find_event(event
->name
, event
->loglevel
, &usess
->domain_jul
);
687 jevent
= jul_create_event(event
->name
, filter
);
689 ret
= LTTNG_ERR_NOMEM
;
692 jevent
->loglevel
= event
->loglevel
;
693 jevent
->loglevel_type
= event
->loglevel_type
;
697 /* Already enabled? */
698 if (jevent
->enabled
) {
702 ret
= jul_enable_event(jevent
);
703 if (ret
!= LTTNG_OK
) {
707 /* If the event was created prior to the enable, add it to the domain. */
709 jul_add_event(jevent
, &usess
->domain_jul
);
717 jul_destroy_event(jevent
);
723 * Disable a single JUL event for a given UST session.
725 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
727 int event_jul_disable(struct ltt_ust_session
*usess
, char *event_name
)
730 struct jul_event
*jevent
;
731 struct ltt_ust_event
*uevent
= NULL
;
732 struct ltt_ust_channel
*uchan
= NULL
;
733 char *ust_event_name
;
738 DBG("Event JUL disabling %s for session %" PRIu64
, event_name
, usess
->id
);
740 jevent
= jul_find_event_by_name(event_name
, &usess
->domain_jul
);
742 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
746 /* Already disabled? */
747 if (!jevent
->enabled
) {
752 * Disable it on the UST side. First get the channel reference then find
753 * the event and finally disable it.
755 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
756 DEFAULT_JUL_CHANNEL_NAME
);
758 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
763 ust_event_name
= DEFAULT_SYS_JUL_EVENT_NAME
;
765 ust_event_name
= DEFAULT_USER_JUL_EVENT_NAME
;
769 * The loglevel is hardcoded with 0 here since the JUL ust event is set
770 * with the loglevel type to ALL thus the loglevel stays 0. The event's
771 * filter is the one handling the loglevel for JUL.
773 uevent
= trace_ust_find_event(uchan
->events
, ust_event_name
,
774 jevent
->filter
, 0, NULL
);
775 /* If the JUL event exists, it must be available on the UST side. */
778 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
779 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
780 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
785 ret
= jul_disable_event(jevent
);
786 if (ret
!= LTTNG_OK
) {
797 * Disable all JUL event for a given UST session.
799 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
801 int event_jul_disable_all(struct ltt_ust_session
*usess
)
803 int ret
, do_disable
= 0;
804 struct jul_event
*jevent
;
805 struct lttng_ht_iter iter
;
809 /* Enable event on JUL application through TCP socket. */
810 ret
= event_jul_disable(usess
, "*");
811 if (ret
!= LTTNG_OK
) {
812 if (ret
== LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
814 * This means that no enable all was done before but still a user
815 * could want to disable everything even though the * wild card
816 * event does not exists.
824 /* Flag every event that they are now enabled. */
826 cds_lfht_for_each_entry(usess
->domain_jul
.events
->ht
, &iter
.iter
, jevent
,
828 if (jevent
->enabled
&& do_disable
) {
829 ret
= event_jul_disable(usess
, jevent
->name
);
830 if (ret
!= LTTNG_OK
) {