2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the Free
6 * Software Foundation; only version 2 of the License.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307, USA.
19 #include <urcu/list.h>
22 #include <lttng/lttng.h>
23 #include <lttng-sessiond-comm.h>
28 #include "hashtable.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
);
137 if (ret
== -EEXIST
) {
138 ret
= LTTCOMM_KERN_EVENT_EXIST
;
140 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
144 } else if (kevent
->enabled
== 0) {
145 ret
= kernel_enable_event(kevent
);
147 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
157 * Enable all kernel tracepoint events of a channel of the kernel session.
159 int event_kernel_enable_all_tracepoints(struct ltt_kernel_session
*ksession
,
160 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
163 struct ltt_kernel_event
*kevent
;
164 struct lttng_event
*event_list
= NULL
;
166 /* For each event in the kernel session */
167 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
168 if (kevent
->enabled
== 0) {
169 ret
= kernel_enable_event(kevent
);
171 /* Enable failed but still continue */
177 size
= kernel_list_events(kernel_tracer_fd
, &event_list
);
179 ret
= LTTCOMM_KERN_LIST_FAIL
;
183 for (i
= 0; i
< size
; i
++) {
184 kevent
= trace_kernel_get_event_by_name(event_list
[i
].name
, kchan
);
185 if (kevent
== NULL
) {
186 /* Default event type for enable all */
187 event_list
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
188 /* Enable each single tracepoint event */
189 ret
= kernel_create_event(&event_list
[i
], kchan
);
191 /* Ignore error here and continue */
204 * Enable all kernel tracepoint events of a channel of the kernel session.
206 int event_kernel_enable_all_syscalls(struct ltt_kernel_session
*ksession
,
207 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
210 struct lttng_event event
;
212 init_syscalls_kernel_event(&event
);
214 DBG("Enabling all syscall tracing");
216 ret
= kernel_create_event(&event
, kchan
);
218 if (ret
== -EEXIST
) {
219 ret
= LTTCOMM_KERN_EVENT_EXIST
;
221 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
232 * Enable all kernel events of a channel of the kernel session.
234 int event_kernel_enable_all(struct ltt_kernel_session
*ksession
,
235 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
239 ret
= event_kernel_enable_all_tracepoints(ksession
, kchan
, kernel_tracer_fd
);
240 if (ret
!= LTTCOMM_OK
) {
243 ret
= event_kernel_enable_all_syscalls(ksession
, kchan
, kernel_tracer_fd
);
249 * ============================
250 * UST : The Ultimate Frontier!
251 * ============================
255 * Enable all UST tracepoints for a channel from a UST session.
257 int event_ust_enable_all_tracepoints(struct ltt_ust_session
*usess
, int domain
,
258 struct ltt_ust_channel
*uchan
)
262 struct cds_lfht_iter iter
;
263 struct ltt_ust_event
*uevent
= NULL
;
264 struct lttng_event
*events
= NULL
;
267 case LTTNG_DOMAIN_UST
:
269 /* Enable existing events */
270 cds_lfht_for_each_entry(uchan
->events
, &iter
, uevent
, node
) {
271 if (uevent
->enabled
== 0) {
272 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
280 /* Get all UST available events */
281 size
= ust_app_list_events(&events
);
283 ret
= LTTCOMM_UST_LIST_FAIL
;
287 for (i
= 0; i
< size
; i
++) {
289 * Check if event exist and if so, continue since it was enable
292 uevent
= trace_ust_find_event_by_name(uchan
->events
,
294 if (uevent
!= NULL
) {
295 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
298 if (ret
!= -EEXIST
) {
299 ret
= LTTCOMM_UST_ENABLE_FAIL
;
306 /* Create ust event */
307 uevent
= trace_ust_create_event(&events
[i
]);
308 if (uevent
== NULL
) {
313 /* Create event for the specific PID */
314 ret
= ust_app_enable_event_pid(usess
, uchan
, uevent
,
317 if (ret
== -EEXIST
) {
318 ret
= LTTCOMM_UST_EVENT_EXIST
;
321 ret
= LTTCOMM_UST_ENABLE_FAIL
;
327 /* Add ltt ust event to channel */
329 hashtable_add_unique(uchan
->events
, &uevent
->node
);
336 case LTTNG_DOMAIN_UST_EXEC_NAME
:
337 case LTTNG_DOMAIN_UST_PID
:
338 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
340 ret
= LTTCOMM_NOT_IMPLEMENTED
;
347 trace_ust_destroy_event(uevent
);
355 * Enable UST tracepoint event for a channel from a UST session.
357 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
, int domain
,
358 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
)
360 int ret
, to_create
= 0;
361 struct ltt_ust_event
*uevent
;
363 uevent
= trace_ust_find_event_by_name(uchan
->events
, event
->name
);
364 if (uevent
== NULL
) {
365 uevent
= trace_ust_create_event(event
);
366 if (uevent
== NULL
) {
373 if (uevent
->enabled
) {
374 /* It's already enabled so everything is OK */
379 case LTTNG_DOMAIN_UST
:
382 /* Create event on all UST registered apps for session */
383 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
385 /* Enable event on all UST registered apps for session */
386 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
390 if (ret
== -EEXIST
) {
391 ret
= LTTCOMM_UST_EVENT_EXIST
;
394 ret
= LTTCOMM_UST_ENABLE_FAIL
;
400 case LTTNG_DOMAIN_UST_EXEC_NAME
:
401 case LTTNG_DOMAIN_UST_PID
:
402 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
404 ret
= LTTCOMM_NOT_IMPLEMENTED
;
409 /* Add ltt ust event to channel */
412 hashtable_add_unique(uchan
->events
, &uevent
->node
);
416 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
417 to_create
? "created" : "enabled", uchan
->name
);
423 trace_ust_destroy_event(uevent
);
428 * Disable UST tracepoint of a channel from a UST session.
430 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
, int domain
,
431 struct ltt_ust_channel
*uchan
, char *event_name
)
434 struct ltt_ust_event
*uevent
;
436 uevent
= trace_ust_find_event_by_name(uchan
->events
, event_name
);
437 if (uevent
== NULL
) {
438 ret
= LTTCOMM_UST_EVENT_NOT_FOUND
;
442 if (uevent
->enabled
== 0) {
443 /* It's already enabled so everything is OK */
449 case LTTNG_DOMAIN_UST
:
450 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
451 if (ret
< 0 && ret
!= -EEXIST
) {
452 ret
= LTTCOMM_UST_DISABLE_FAIL
;
456 case LTTNG_DOMAIN_UST_EXEC_NAME
:
457 case LTTNG_DOMAIN_UST_PID
:
458 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
460 ret
= LTTCOMM_NOT_IMPLEMENTED
;
468 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
476 * Disable all UST tracepoints for a channel from a UST session.
478 int event_ust_disable_all_tracepoints(struct ltt_ust_session
*usess
, int domain
,
479 struct ltt_ust_channel
*uchan
)
483 struct cds_lfht_iter iter
;
484 struct ltt_ust_event
*uevent
= NULL
;
485 struct lttng_event
*events
= NULL
;
488 case LTTNG_DOMAIN_UST
:
490 /* Disabling existing events */
491 cds_lfht_for_each_entry(uchan
->events
, &iter
, uevent
, node
) {
492 if (uevent
->enabled
== 1) {
493 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
501 /* Get all UST available events */
502 size
= ust_app_list_events(&events
);
504 ret
= LTTCOMM_UST_LIST_FAIL
;
508 for (i
= 0; i
< size
; i
++) {
509 uevent
= trace_ust_find_event_by_name(uchan
->events
,
511 if (uevent
!= NULL
&& uevent
->enabled
== 1) {
512 ret
= ust_app_disable_event_pid(usess
, uchan
, uevent
,
514 if (ret
< 0 && ret
!= -EEXIST
) {
515 ret
= LTTCOMM_UST_DISABLE_FAIL
;
526 case LTTNG_DOMAIN_UST_EXEC_NAME
:
527 case LTTNG_DOMAIN_UST_PID
:
528 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
530 ret
= LTTCOMM_NOT_IMPLEMENTED
;