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>
32 #include "trace-kernel.h"
33 #include "trace-ust.h"
36 * Setup a lttng_event used to enable *all* syscall tracing.
38 static void init_syscalls_kernel_event(struct lttng_event
*event
)
40 event
->name
[0] = '\0';
42 * We use LTTNG_EVENT* here since the trace kernel creation will make the
43 * right changes for the kernel.
45 event
->type
= LTTNG_EVENT_SYSCALL
;
49 * Disable kernel tracepoint event for a channel from the kernel session.
51 int event_kernel_disable_tracepoint(struct ltt_kernel_session
*ksession
,
52 struct ltt_kernel_channel
*kchan
, char *event_name
)
55 struct ltt_kernel_event
*kevent
;
57 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
);
59 ret
= LTTCOMM_NO_EVENT
;
63 ret
= kernel_disable_event(kevent
);
65 ret
= LTTCOMM_KERN_DISABLE_FAIL
;
69 DBG("Kernel event %s disable for channel %s.",
70 kevent
->event
->name
, kchan
->channel
->name
);
79 * Disable kernel tracepoint events for a channel from the kernel session.
81 int event_kernel_disable_all_tracepoints(struct ltt_kernel_session
*ksession
,
82 struct ltt_kernel_channel
*kchan
)
85 struct ltt_kernel_event
*kevent
;
87 /* For each event in the kernel session */
88 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
89 ret
= kernel_disable_event(kevent
);
91 /* We continue disabling the rest */
100 * Disable kernel syscall events for a channel from the kernel session.
102 int event_kernel_disable_all_syscalls(struct ltt_kernel_session
*ksession
,
103 struct ltt_kernel_channel
*kchan
)
105 ERR("Cannot disable syscall tracing for existing session. Please destroy session instead.");
106 return LTTCOMM_OK
; /* Return OK so disable all succeeds */
110 * Disable all kernel event for a channel from the kernel session.
112 int event_kernel_disable_all(struct ltt_kernel_session
*ksession
,
113 struct ltt_kernel_channel
*kchan
)
117 ret
= event_kernel_disable_all_tracepoints(ksession
, kchan
);
118 if (ret
!= LTTCOMM_OK
)
120 ret
= event_kernel_disable_all_syscalls(ksession
, kchan
);
125 * Enable kernel tracepoint event for a channel from the kernel session.
127 int event_kernel_enable_tracepoint(struct ltt_kernel_session
*ksession
,
128 struct ltt_kernel_channel
*kchan
, struct lttng_event
*event
)
131 struct ltt_kernel_event
*kevent
;
133 kevent
= trace_kernel_get_event_by_name(event
->name
, kchan
);
134 if (kevent
== NULL
) {
135 ret
= kernel_create_event(event
, kchan
);
139 ret
= LTTCOMM_KERN_EVENT_EXIST
;
142 ret
= LTTCOMM_KERN_EVENT_ENOSYS
;
145 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
150 } else if (kevent
->enabled
== 0) {
151 ret
= kernel_enable_event(kevent
);
153 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
157 /* At this point, the event is considered enabled */
158 ret
= LTTCOMM_KERN_EVENT_EXIST
;
168 * Enable all kernel tracepoint events of a channel of the kernel session.
170 int event_kernel_enable_all_tracepoints(struct ltt_kernel_session
*ksession
,
171 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
174 struct ltt_kernel_event
*kevent
;
175 struct lttng_event
*event_list
= NULL
;
177 /* For each event in the kernel session */
178 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
179 if (kevent
->enabled
== 0) {
180 ret
= kernel_enable_event(kevent
);
182 /* Enable failed but still continue */
188 size
= kernel_list_events(kernel_tracer_fd
, &event_list
);
190 ret
= LTTCOMM_KERN_LIST_FAIL
;
194 for (i
= 0; i
< size
; i
++) {
195 kevent
= trace_kernel_get_event_by_name(event_list
[i
].name
, kchan
);
196 if (kevent
== NULL
) {
197 /* Default event type for enable all */
198 event_list
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
199 /* Enable each single tracepoint event */
200 ret
= kernel_create_event(&event_list
[i
], kchan
);
202 /* Ignore error here and continue */
215 * Enable all kernel tracepoint events of a channel of the kernel session.
217 int event_kernel_enable_all_syscalls(struct ltt_kernel_session
*ksession
,
218 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
221 struct lttng_event event
;
223 init_syscalls_kernel_event(&event
);
225 DBG("Enabling all syscall tracing");
227 ret
= kernel_create_event(&event
, kchan
);
229 if (ret
== -EEXIST
) {
230 ret
= LTTCOMM_KERN_EVENT_EXIST
;
232 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
243 * Enable all kernel events of a channel of the kernel session.
245 int event_kernel_enable_all(struct ltt_kernel_session
*ksession
,
246 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
248 int tp_ret
, syscall_ret
;
250 tp_ret
= event_kernel_enable_all_tracepoints(ksession
, kchan
, kernel_tracer_fd
);
251 if (tp_ret
!= LTTCOMM_OK
) {
256 * Reaching this code path means that all tracepoints were enabled without
257 * errors so we ignore the error value of syscalls.
259 * At the moment, failing to enable syscalls on "lttng enable-event -a -k"
260 * is not considered an error that need to be returned to the client since
261 * tracepoints did not fail. Future work will allow us to send back
262 * multiple errors to the client in one API call.
264 syscall_ret
= event_kernel_enable_all_syscalls(ksession
, kchan
,
272 * ============================
273 * UST : The Ultimate Frontier!
274 * ============================
278 * Enable all UST tracepoints for a channel from a UST session.
280 int event_ust_enable_all_tracepoints(struct ltt_ust_session
*usess
, int domain
,
281 struct ltt_ust_channel
*uchan
)
285 struct lttng_ht_iter iter
;
286 struct ltt_ust_event
*uevent
= NULL
;
287 struct lttng_event
*events
= NULL
;
290 case LTTNG_DOMAIN_UST
:
292 /* Enable existing events */
293 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
295 if (uevent
->enabled
== 0) {
296 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
304 /* Get all UST available events */
305 size
= ust_app_list_events(&events
);
307 ret
= LTTCOMM_UST_LIST_FAIL
;
311 for (i
= 0; i
< size
; i
++) {
313 * Check if event exist and if so, continue since it was enable
316 uevent
= trace_ust_find_event_by_name(uchan
->events
,
318 if (uevent
!= NULL
) {
319 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
322 if (ret
!= -EEXIST
) {
323 ret
= LTTCOMM_UST_ENABLE_FAIL
;
330 /* Create ust event */
331 uevent
= trace_ust_create_event(&events
[i
]);
332 if (uevent
== NULL
) {
337 /* Create event for the specific PID */
338 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
341 if (ret
== -EEXIST
) {
342 ret
= LTTCOMM_UST_EVENT_EXIST
;
345 ret
= LTTCOMM_UST_ENABLE_FAIL
;
351 /* Add ltt ust event to channel */
353 lttng_ht_add_unique_str(uchan
->events
, &uevent
->node
);
361 case LTTNG_DOMAIN_UST_EXEC_NAME
:
362 case LTTNG_DOMAIN_UST_PID
:
363 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
373 trace_ust_destroy_event(uevent
);
381 * Enable UST tracepoint event for a channel from a UST session.
383 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
, int domain
,
384 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
)
386 int ret
= LTTCOMM_OK
, to_create
= 0;
387 struct ltt_ust_event
*uevent
;
389 uevent
= trace_ust_find_event_by_name(uchan
->events
, event
->name
);
390 if (uevent
== NULL
) {
391 uevent
= trace_ust_create_event(event
);
392 if (uevent
== NULL
) {
396 /* Valid to set it after the goto error since uevent is still NULL */
400 if (uevent
->enabled
) {
401 /* It's already enabled so everything is OK */
408 case LTTNG_DOMAIN_UST
:
411 /* Create event on all UST registered apps for session */
412 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
414 /* Enable event on all UST registered apps for session */
415 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
419 if (ret
== -EEXIST
) {
420 ret
= LTTCOMM_UST_EVENT_EXIST
;
423 ret
= LTTCOMM_UST_ENABLE_FAIL
;
430 case LTTNG_DOMAIN_UST_EXEC_NAME
:
431 case LTTNG_DOMAIN_UST_PID
:
432 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
441 /* Add ltt ust event to channel */
442 lttng_ht_add_unique_str(uchan
->events
, &uevent
->node
);
446 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
447 to_create
? "created" : "enabled", uchan
->name
);
456 * Only destroy event on creation time (not enabling time) because if the
457 * event is found in the channel (to_create == 0), it means that at some
458 * point the enable_event worked and it's thus valid to keep it alive.
459 * Destroying it also implies that we also destroy it's shadow copy to sync
463 /* In this code path, the uevent was not added to the hash table */
464 trace_ust_destroy_event(uevent
);
470 * Disable UST tracepoint of a channel from a UST session.
472 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
, int domain
,
473 struct ltt_ust_channel
*uchan
, char *event_name
)
476 struct ltt_ust_event
*uevent
;
478 uevent
= trace_ust_find_event_by_name(uchan
->events
, event_name
);
479 if (uevent
== NULL
) {
480 ret
= LTTCOMM_UST_EVENT_NOT_FOUND
;
484 if (uevent
->enabled
== 0) {
485 /* It's already enabled so everything is OK */
491 case LTTNG_DOMAIN_UST
:
492 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
493 if (ret
< 0 && ret
!= -EEXIST
) {
494 ret
= LTTCOMM_UST_DISABLE_FAIL
;
499 case LTTNG_DOMAIN_UST_EXEC_NAME
:
500 case LTTNG_DOMAIN_UST_PID
:
501 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
512 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
520 * Disable all UST tracepoints for a channel from a UST session.
522 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
, int domain
,
523 struct ltt_ust_channel
*uchan
)
527 struct lttng_ht_iter iter
;
528 struct ltt_ust_event
*uevent
= NULL
;
529 struct lttng_event
*events
= NULL
;
532 case LTTNG_DOMAIN_UST
:
534 /* Disabling existing events */
535 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
,
537 if (uevent
->enabled
== 1) {
538 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
546 /* Get all UST available events */
547 size
= ust_app_list_events(&events
);
549 ret
= LTTCOMM_UST_LIST_FAIL
;
553 for (i
= 0; i
< size
; i
++) {
554 uevent
= trace_ust_find_event_by_name(uchan
->events
,
556 if (uevent
!= NULL
&& uevent
->enabled
== 1) {
557 ret
= ust_app_disable_event_pid(usess
, uchan
, uevent
,
559 if (ret
< 0 && ret
!= -EEXIST
) {
560 ret
= LTTCOMM_UST_DISABLE_FAIL
;
572 case LTTNG_DOMAIN_UST_EXEC_NAME
:
573 case LTTNG_DOMAIN_UST_PID
:
574 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
: