Update lttng kernel modules names
[lttng-tools.git] / src / bin / lttng-sessiond / event.c
CommitLineData
54d01ffb
DG
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
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.
7 *
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
11 * more details.
12 *
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.
16 */
17
be040666 18#define _GNU_SOURCE
d87bfb32 19#include <errno.h>
54d01ffb 20#include <urcu/list.h>
2bdd86d4 21#include <string.h>
54d01ffb
DG
22
23#include <lttng/lttng.h>
db758600 24#include <common/error.h>
10a8a223 25#include <common/sessiond-comm/sessiond-comm.h>
54d01ffb
DG
26
27#include "channel.h"
28#include "event.h"
4771f025 29#include "kernel.h"
9df8df5e 30#include "ust-ctl.h"
edb67388
DG
31#include "ust-app.h"
32#include "trace-kernel.h"
33#include "trace-ust.h"
54d01ffb 34
8c9ae521
DG
35/*
36 * Setup a lttng_event used to enable *all* syscall tracing.
37 */
38static void init_syscalls_kernel_event(struct lttng_event *event)
39{
40 event->name[0] = '\0';
41 /*
42 * We use LTTNG_EVENT* here since the trace kernel creation will make the
43 * right changes for the kernel.
44 */
45 event->type = LTTNG_EVENT_SYSCALL;
46}
47
54d01ffb 48/*
7a3d1328 49 * Disable kernel tracepoint event for a channel from the kernel session.
54d01ffb 50 */
7a3d1328 51int event_kernel_disable_tracepoint(struct ltt_kernel_session *ksession,
54d01ffb
DG
52 struct ltt_kernel_channel *kchan, char *event_name)
53{
54 int ret;
55 struct ltt_kernel_event *kevent;
56
57 kevent = trace_kernel_get_event_by_name(event_name, kchan);
58 if (kevent == NULL) {
59 ret = LTTCOMM_NO_EVENT;
60 goto error;
61 }
62
63 ret = kernel_disable_event(kevent);
64 if (ret < 0) {
65 ret = LTTCOMM_KERN_DISABLE_FAIL;
66 goto error;
67 }
68
69 DBG("Kernel event %s disable for channel %s.",
70 kevent->event->name, kchan->channel->name);
71
72 ret = LTTCOMM_OK;
73
74error:
75 return ret;
76}
77
78/*
7a3d1328 79 * Disable kernel tracepoint events for a channel from the kernel session.
54d01ffb 80 */
7a3d1328 81int event_kernel_disable_all_tracepoints(struct ltt_kernel_session *ksession,
54d01ffb
DG
82 struct ltt_kernel_channel *kchan)
83{
84 int ret;
85 struct ltt_kernel_event *kevent;
86
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);
90 if (ret < 0) {
91 /* We continue disabling the rest */
92 continue;
93 }
94 }
54d01ffb 95 ret = LTTCOMM_OK;
7a3d1328
MD
96 return ret;
97}
98
99/*
100 * Disable kernel syscall events for a channel from the kernel session.
101 */
102int event_kernel_disable_all_syscalls(struct ltt_kernel_session *ksession,
103 struct ltt_kernel_channel *kchan)
104{
105 ERR("Cannot disable syscall tracing for existing session. Please destroy session instead.");
106 return LTTCOMM_OK; /* Return OK so disable all succeeds */
107}
54d01ffb 108
7a3d1328
MD
109/*
110 * Disable all kernel event for a channel from the kernel session.
111 */
112int event_kernel_disable_all(struct ltt_kernel_session *ksession,
113 struct ltt_kernel_channel *kchan)
114{
115 int ret;
116
117 ret = event_kernel_disable_all_tracepoints(ksession, kchan);
118 if (ret != LTTCOMM_OK)
119 return ret;
120 ret = event_kernel_disable_all_syscalls(ksession, kchan);
54d01ffb
DG
121 return ret;
122}
123
124/*
7a3d1328 125 * Enable kernel tracepoint event for a channel from the kernel session.
54d01ffb 126 */
7a3d1328 127int event_kernel_enable_tracepoint(struct ltt_kernel_session *ksession,
54d01ffb
DG
128 struct ltt_kernel_channel *kchan, struct lttng_event *event)
129{
130 int ret;
131 struct ltt_kernel_event *kevent;
132
133 kevent = trace_kernel_get_event_by_name(event->name, kchan);
134 if (kevent == NULL) {
135 ret = kernel_create_event(event, kchan);
136 if (ret < 0) {
d87bfb32
DG
137 if (ret == -EEXIST) {
138 ret = LTTCOMM_KERN_EVENT_EXIST;
139 } else {
140 ret = LTTCOMM_KERN_ENABLE_FAIL;
141 }
7a3d1328 142 goto end;
54d01ffb
DG
143 }
144 } else if (kevent->enabled == 0) {
145 ret = kernel_enable_event(kevent);
146 if (ret < 0) {
147 ret = LTTCOMM_KERN_ENABLE_FAIL;
7a3d1328 148 goto end;
54d01ffb
DG
149 }
150 }
54d01ffb 151 ret = LTTCOMM_OK;
7a3d1328 152end:
54d01ffb
DG
153 return ret;
154}
155
156/*
7a3d1328 157 * Enable all kernel tracepoint events of a channel of the kernel session.
54d01ffb 158 */
7a3d1328 159int event_kernel_enable_all_tracepoints(struct ltt_kernel_session *ksession,
54d01ffb
DG
160 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
161{
162 int size, i, ret;
163 struct ltt_kernel_event *kevent;
8f69e5eb 164 struct lttng_event *event_list = NULL;
54d01ffb
DG
165
166 /* For each event in the kernel session */
167 cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
8f69e5eb
DG
168 if (kevent->enabled == 0) {
169 ret = kernel_enable_event(kevent);
170 if (ret < 0) {
171 /* Enable failed but still continue */
172 continue;
173 }
54d01ffb
DG
174 }
175 }
176
177 size = kernel_list_events(kernel_tracer_fd, &event_list);
178 if (size < 0) {
179 ret = LTTCOMM_KERN_LIST_FAIL;
7a3d1328 180 goto end;
54d01ffb
DG
181 }
182
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);
190 if (ret < 0) {
191 /* Ignore error here and continue */
192 }
193 }
194 }
54d01ffb 195 free(event_list);
8f69e5eb 196
54d01ffb 197 ret = LTTCOMM_OK;
7a3d1328 198end:
54d01ffb 199 return ret;
7a3d1328 200
54d01ffb 201}
8c9ae521
DG
202
203/*
7a3d1328 204 * Enable all kernel tracepoint events of a channel of the kernel session.
8c9ae521 205 */
7a3d1328 206int event_kernel_enable_all_syscalls(struct ltt_kernel_session *ksession,
8c9ae521
DG
207 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
208{
209 int ret;
210 struct lttng_event event;
211
212 init_syscalls_kernel_event(&event);
213
214 DBG("Enabling all syscall tracing");
215
216 ret = kernel_create_event(&event, kchan);
217 if (ret < 0) {
8f69e5eb
DG
218 if (ret == -EEXIST) {
219 ret = LTTCOMM_KERN_EVENT_EXIST;
220 } else {
221 ret = LTTCOMM_KERN_ENABLE_FAIL;
222 }
7a3d1328 223 goto end;
8c9ae521 224 }
8f69e5eb 225
8c9ae521 226 ret = LTTCOMM_OK;
7a3d1328
MD
227end:
228 return ret;
229}
8c9ae521 230
7a3d1328
MD
231/*
232 * Enable all kernel events of a channel of the kernel session.
233 */
234int event_kernel_enable_all(struct ltt_kernel_session *ksession,
235 struct ltt_kernel_channel *kchan, int kernel_tracer_fd)
236{
237 int ret;
238
239 ret = event_kernel_enable_all_tracepoints(ksession, kchan, kernel_tracer_fd);
240 if (ret != LTTCOMM_OK) {
241 goto end;
242 }
243 ret = event_kernel_enable_all_syscalls(ksession, kchan, kernel_tracer_fd);
244end:
8c9ae521
DG
245 return ret;
246}
2bdd86d4 247
7f79d3a1
DG
248/*
249 * ============================
250 * UST : The Ultimate Frontier!
251 * ============================
252 */
253
76d45b40
DG
254/*
255 * Enable all UST tracepoints for a channel from a UST session.
256 */
257int event_ust_enable_all_tracepoints(struct ltt_ust_session *usess, int domain,
258 struct ltt_ust_channel *uchan)
259{
260 int ret, i;
261 size_t size;
bec39940 262 struct lttng_ht_iter iter;
76d45b40 263 struct ltt_ust_event *uevent = NULL;
7f79d3a1 264 struct lttng_event *events = NULL;
76d45b40
DG
265
266 switch (domain) {
267 case LTTNG_DOMAIN_UST:
268 {
269 /* Enable existing events */
bec39940
DG
270 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent,
271 node.node) {
76d45b40
DG
272 if (uevent->enabled == 0) {
273 ret = ust_app_enable_event_glb(usess, uchan, uevent);
274 if (ret < 0) {
275 continue;
276 }
277 uevent->enabled = 1;
278 }
279 }
280
281 /* Get all UST available events */
282 size = ust_app_list_events(&events);
283 if (size < 0) {
284 ret = LTTCOMM_UST_LIST_FAIL;
285 goto error;
286 }
287
288 for (i = 0; i < size; i++) {
289 /*
290 * Check if event exist and if so, continue since it was enable
291 * previously.
292 */
293 uevent = trace_ust_find_event_by_name(uchan->events,
294 events[i].name);
295 if (uevent != NULL) {
296 ret = ust_app_enable_event_pid(usess, uchan, uevent,
297 events[i].pid);
298 if (ret < 0) {
299 if (ret != -EEXIST) {
300 ret = LTTCOMM_UST_ENABLE_FAIL;
301 goto error;
302 }
303 }
304 continue;
305 }
306
307 /* Create ust event */
308 uevent = trace_ust_create_event(&events[i]);
309 if (uevent == NULL) {
310 ret = LTTCOMM_FATAL;
7f79d3a1 311 goto error_destroy;
76d45b40
DG
312 }
313
314 /* Create event for the specific PID */
315 ret = ust_app_enable_event_pid(usess, uchan, uevent,
316 events[i].pid);
317 if (ret < 0) {
318 if (ret == -EEXIST) {
319 ret = LTTCOMM_UST_EVENT_EXIST;
7f79d3a1 320 goto error;
76d45b40
DG
321 } else {
322 ret = LTTCOMM_UST_ENABLE_FAIL;
7f79d3a1 323 goto error_destroy;
76d45b40 324 }
76d45b40
DG
325 }
326
327 uevent->enabled = 1;
328 /* Add ltt ust event to channel */
329 rcu_read_lock();
bec39940 330 lttng_ht_add_unique_str(uchan->events, &uevent->node);
76d45b40
DG
331 rcu_read_unlock();
332 }
333
334 free(events);
335 break;
336 }
337 case LTTNG_DOMAIN_UST_EXEC_NAME:
338 case LTTNG_DOMAIN_UST_PID:
339 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
340 default:
341 ret = LTTCOMM_NOT_IMPLEMENTED;
342 goto error;
343 }
344
345 return LTTCOMM_OK;
346
7f79d3a1 347error_destroy:
76d45b40 348 trace_ust_destroy_event(uevent);
7f79d3a1
DG
349
350error:
351 free(events);
76d45b40
DG
352 return ret;
353}
354
2bdd86d4
MD
355/*
356 * Enable UST tracepoint event for a channel from a UST session.
357 */
edb67388
DG
358int event_ust_enable_tracepoint(struct ltt_ust_session *usess, int domain,
359 struct ltt_ust_channel *uchan, struct lttng_event *event)
2bdd86d4 360{
fc34caaa 361 int ret = LTTCOMM_OK, to_create = 0;
edb67388
DG
362 struct ltt_ust_event *uevent;
363
364 uevent = trace_ust_find_event_by_name(uchan->events, event->name);
365 if (uevent == NULL) {
366 uevent = trace_ust_create_event(event);
367 if (uevent == NULL) {
368 ret = LTTCOMM_FATAL;
369 goto error;
370 }
fc34caaa 371 /* Valid to set it after the goto error since uevent is still NULL */
edb67388
DG
372 to_create = 1;
373 }
2bdd86d4 374
7f79d3a1
DG
375 if (uevent->enabled) {
376 /* It's already enabled so everything is OK */
7f79d3a1
DG
377 goto end;
378 }
379
fc34caaa
DG
380 uevent->enabled = 1;
381
edb67388
DG
382 switch (domain) {
383 case LTTNG_DOMAIN_UST:
384 {
385 if (to_create) {
386 /* Create event on all UST registered apps for session */
35a9059d 387 ret = ust_app_create_event_glb(usess, uchan, uevent);
edb67388
DG
388 } else {
389 /* Enable event on all UST registered apps for session */
35a9059d 390 ret = ust_app_enable_event_glb(usess, uchan, uevent);
edb67388 391 }
48842b30 392
edb67388
DG
393 if (ret < 0) {
394 if (ret == -EEXIST) {
395 ret = LTTCOMM_UST_EVENT_EXIST;
7f79d3a1 396 goto end;
edb67388
DG
397 } else {
398 ret = LTTCOMM_UST_ENABLE_FAIL;
7f79d3a1 399 goto error;
edb67388 400 }
edb67388 401 }
edb67388
DG
402 break;
403 }
404 case LTTNG_DOMAIN_UST_EXEC_NAME:
405 case LTTNG_DOMAIN_UST_PID:
406 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
407 default:
408 ret = LTTCOMM_NOT_IMPLEMENTED;
7f79d3a1 409 goto end;
2bdd86d4 410 }
48842b30 411
7f79d3a1
DG
412 if (to_create) {
413 rcu_read_lock();
fc34caaa 414 /* Add ltt ust event to channel */
bec39940 415 lttng_ht_add_unique_str(uchan->events, &uevent->node);
7f79d3a1
DG
416 rcu_read_unlock();
417 }
edb67388 418
7f79d3a1
DG
419 DBG("Event UST %s %s in channel %s", uevent->attr.name,
420 to_create ? "created" : "enabled", uchan->name);
421
fc34caaa
DG
422 ret = LTTCOMM_OK;
423
fb89d070 424end:
fc34caaa 425 return ret;
edb67388
DG
426
427error:
fc34caaa
DG
428 /*
429 * Only destroy event on creation time (not enabling time) because if the
430 * event is found in the channel (to_create == 0), it means that at some
431 * point the enable_event worked and it's thus valid to keep it alive.
432 * Destroying it also implies that we also destroy it's shadow copy to sync
433 * everyone up.
434 */
435 if (to_create) {
436 /* In this code path, the uevent was not added to the hash table */
437 trace_ust_destroy_event(uevent);
438 }
2bdd86d4
MD
439 return ret;
440}
441
7f79d3a1
DG
442/*
443 * Disable UST tracepoint of a channel from a UST session.
444 */
445int event_ust_disable_tracepoint(struct ltt_ust_session *usess, int domain,
446 struct ltt_ust_channel *uchan, char *event_name)
2bdd86d4
MD
447{
448 int ret;
7f79d3a1 449 struct ltt_ust_event *uevent;
2bdd86d4 450
7f79d3a1
DG
451 uevent = trace_ust_find_event_by_name(uchan->events, event_name);
452 if (uevent == NULL) {
453 ret = LTTCOMM_UST_EVENT_NOT_FOUND;
454 goto error;
2bdd86d4 455 }
7f79d3a1
DG
456
457 if (uevent->enabled == 0) {
458 /* It's already enabled so everything is OK */
459 ret = LTTCOMM_OK;
2bdd86d4
MD
460 goto end;
461 }
7f79d3a1
DG
462
463 switch (domain) {
464 case LTTNG_DOMAIN_UST:
465 ret = ust_app_disable_event_glb(usess, uchan, uevent);
466 if (ret < 0 && ret != -EEXIST) {
467 ret = LTTCOMM_UST_DISABLE_FAIL;
468 goto error;
469 }
470 break;
471 case LTTNG_DOMAIN_UST_EXEC_NAME:
472 case LTTNG_DOMAIN_UST_PID:
473 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
474 default:
475 ret = LTTCOMM_NOT_IMPLEMENTED;
476 goto error;
477 }
478
479 uevent->enabled = 0;
2bdd86d4 480 ret = LTTCOMM_OK;
7f79d3a1 481
2bdd86d4 482end:
7f79d3a1
DG
483 DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
484 uchan->name);
485
486error:
487 return ret;
488}
489
490/*
491 * Disable all UST tracepoints for a channel from a UST session.
492 */
493int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess, int domain,
494 struct ltt_ust_channel *uchan)
495{
496 int ret, i;
497 size_t size;
bec39940 498 struct lttng_ht_iter iter;
7f79d3a1
DG
499 struct ltt_ust_event *uevent = NULL;
500 struct lttng_event *events = NULL;
501
502 switch (domain) {
503 case LTTNG_DOMAIN_UST:
504 {
505 /* Disabling existing events */
bec39940
DG
506 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent,
507 node.node) {
7f79d3a1
DG
508 if (uevent->enabled == 1) {
509 ret = ust_app_disable_event_glb(usess, uchan, uevent);
510 if (ret < 0) {
511 continue;
512 }
513 uevent->enabled = 0;
514 }
515 }
516
517 /* Get all UST available events */
518 size = ust_app_list_events(&events);
519 if (size < 0) {
520 ret = LTTCOMM_UST_LIST_FAIL;
521 goto error;
522 }
523
524 for (i = 0; i < size; i++) {
525 uevent = trace_ust_find_event_by_name(uchan->events,
526 events[i].name);
527 if (uevent != NULL && uevent->enabled == 1) {
528 ret = ust_app_disable_event_pid(usess, uchan, uevent,
529 events[i].pid);
530 if (ret < 0 && ret != -EEXIST) {
531 ret = LTTCOMM_UST_DISABLE_FAIL;
532 goto error;
533 }
534 uevent->enabled = 0;
535 continue;
536 }
537 }
538
539 free(events);
540 break;
541 }
542 case LTTNG_DOMAIN_UST_EXEC_NAME:
543 case LTTNG_DOMAIN_UST_PID:
544 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
545 default:
546 ret = LTTCOMM_NOT_IMPLEMENTED;
547 goto error;
548 }
549
550 return LTTCOMM_OK;
551
552error:
553 free(events);
2bdd86d4
MD
554 return ret;
555}
This page took 0.049625 seconds and 4 git commands to generate.