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>
26 #ifdef CONFIG_LTTNG_TOOLS_HAVE_UST
27 #include <ust/lttng-ust-ctl.h>
29 #include "lttng-ust-ctl.h"
34 #include "kernel-ctl.h"
37 * Setup a lttng_event used to enable *all* syscall tracing.
39 static void init_syscalls_kernel_event(struct lttng_event
*event
)
41 event
->name
[0] = '\0';
43 * We use LTTNG_EVENT* here since the trace kernel creation will make the
44 * right changes for the kernel.
46 event
->type
= LTTNG_EVENT_SYSCALL
;
50 * Disable kernel tracepoint event for a channel from the kernel session.
52 int event_kernel_disable_tracepoint(struct ltt_kernel_session
*ksession
,
53 struct ltt_kernel_channel
*kchan
, char *event_name
)
56 struct ltt_kernel_event
*kevent
;
58 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
);
60 ret
= LTTCOMM_NO_EVENT
;
64 ret
= kernel_disable_event(kevent
);
66 ret
= LTTCOMM_KERN_DISABLE_FAIL
;
70 DBG("Kernel event %s disable for channel %s.",
71 kevent
->event
->name
, kchan
->channel
->name
);
80 * Disable kernel tracepoint events for a channel from the kernel session.
82 int event_kernel_disable_all_tracepoints(struct ltt_kernel_session
*ksession
,
83 struct ltt_kernel_channel
*kchan
)
86 struct ltt_kernel_event
*kevent
;
88 /* For each event in the kernel session */
89 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
90 ret
= kernel_disable_event(kevent
);
92 /* We continue disabling the rest */
101 * Disable kernel syscall events for a channel from the kernel session.
103 int event_kernel_disable_all_syscalls(struct ltt_kernel_session
*ksession
,
104 struct ltt_kernel_channel
*kchan
)
106 ERR("Cannot disable syscall tracing for existing session. Please destroy session instead.");
107 return LTTCOMM_OK
; /* Return OK so disable all succeeds */
111 * Disable all kernel event for a channel from the kernel session.
113 int event_kernel_disable_all(struct ltt_kernel_session
*ksession
,
114 struct ltt_kernel_channel
*kchan
)
118 ret
= event_kernel_disable_all_tracepoints(ksession
, kchan
);
119 if (ret
!= LTTCOMM_OK
)
121 ret
= event_kernel_disable_all_syscalls(ksession
, kchan
);
126 * Enable kernel tracepoint event for a channel from the kernel session.
128 int event_kernel_enable_tracepoint(struct ltt_kernel_session
*ksession
,
129 struct ltt_kernel_channel
*kchan
, struct lttng_event
*event
)
132 struct ltt_kernel_event
*kevent
;
134 kevent
= trace_kernel_get_event_by_name(event
->name
, kchan
);
135 if (kevent
== NULL
) {
136 ret
= kernel_create_event(event
, kchan
);
138 if (ret
== -EEXIST
) {
139 ret
= LTTCOMM_KERN_EVENT_EXIST
;
141 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
145 } else if (kevent
->enabled
== 0) {
146 ret
= kernel_enable_event(kevent
);
148 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
158 * Enable all kernel tracepoint events of a channel of the kernel session.
160 int event_kernel_enable_all_tracepoints(struct ltt_kernel_session
*ksession
,
161 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
164 struct ltt_kernel_event
*kevent
;
165 struct lttng_event
*event_list
;
167 /* For each event in the kernel session */
168 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
169 ret
= kernel_enable_event(kevent
);
171 /* Enable failed but still continue */
176 size
= kernel_list_events(kernel_tracer_fd
, &event_list
);
178 ret
= LTTCOMM_KERN_LIST_FAIL
;
182 for (i
= 0; i
< size
; i
++) {
183 kevent
= trace_kernel_get_event_by_name(event_list
[i
].name
, kchan
);
184 if (kevent
== NULL
) {
185 /* Default event type for enable all */
186 event_list
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
187 /* Enable each single tracepoint event */
188 ret
= kernel_create_event(&event_list
[i
], kchan
);
190 /* Ignore error here and continue */
202 * Enable all kernel tracepoint events of a channel of the kernel session.
204 int event_kernel_enable_all_syscalls(struct ltt_kernel_session
*ksession
,
205 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
208 struct lttng_event event
;
210 init_syscalls_kernel_event(&event
);
212 DBG("Enabling all syscall tracing");
214 ret
= kernel_create_event(&event
, kchan
);
224 * Enable all kernel events of a channel of the kernel session.
226 int event_kernel_enable_all(struct ltt_kernel_session
*ksession
,
227 struct ltt_kernel_channel
*kchan
, int kernel_tracer_fd
)
231 ret
= event_kernel_enable_all_tracepoints(ksession
, kchan
, kernel_tracer_fd
);
232 if (ret
!= LTTCOMM_OK
) {
235 ret
= event_kernel_enable_all_syscalls(ksession
, kchan
, kernel_tracer_fd
);
241 * Enable UST tracepoint event for a channel from a UST session.
243 int event_ust_enable_tracepoint(struct ltt_ust_session
*ustsession
,
244 struct ltt_ust_channel
*ustchan
, struct lttng_event
*event
)
247 struct ltt_ust_event
*ustevent
;
248 struct lttng_ust_event lttngustevent
;
249 struct object_data
*object_event
;
251 ustevent
= trace_ust_get_event_by_name(event
->name
, ustchan
);
252 if (ustevent
== NULL
) {
253 ustevent
= trace_ust_create_event(event
);
254 if (ustevent
== NULL
) {
258 strncpy(lttngustevent
.name
, event
->name
,
259 LTTNG_UST_SYM_NAME_LEN
);
260 lttngustevent
.name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
261 /* TODO: adjust to other instrumentation types */
262 lttngustevent
.instrumentation
= LTTNG_UST_TRACEPOINT
;
263 ret
= ustctl_create_event(ustsession
->sock
, <tngustevent
,
264 ustchan
->obj
, &object_event
);
266 if (ret
== -EEXIST
) {
267 ret
= LTTCOMM_KERN_EVENT_EXIST
;
269 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
273 ustevent
->obj
= object_event
;
274 ustevent
->handle
= object_event
->handle
;
275 ustevent
->enabled
= 1;
276 /* Add event to event list */
277 cds_list_add(&ustevent
->list
, &ustchan
->events
.head
);
278 ustchan
->events
.count
++;
279 } else if (ustevent
->enabled
== 0) {
280 ret
= ustctl_enable(ustsession
->sock
, ustevent
->obj
);
282 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
285 ustevent
->enabled
= 1;
292 int event_ust_disable_tracepoint(struct ltt_ust_session
*ustsession
,
293 struct ltt_ust_channel
*ustchan
, char *event_name
)
296 struct ltt_ust_event
*ustevent
;
298 ustevent
= trace_ust_get_event_by_name(event_name
, ustchan
);
299 if (ustevent
== NULL
) {
300 ret
= LTTCOMM_NO_EVENT
;
303 ret
= ustctl_disable(ustsession
->sock
, ustevent
->obj
);
305 ret
= LTTCOMM_UST_ENABLE_FAIL
;
308 ustevent
->enabled
= 0;