projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: lttng: poptGetArg doesn't provide string ownership
[lttng-tools.git] / src / bin / lttng / commands / enable_events.cpp
1 /*
2 * Copyright (C) 2011 EfficiOS Inc.
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8 #define _LGPL_SOURCE
9 #include <popt.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <sys/stat.h>
13 #include <sys/types.h>
14 #include <unistd.h>
15 #include <inttypes.h>
16 #include <ctype.h>
17
18 #include <common/sessiond-comm/sessiond-comm.hpp>
19 #include <common/compat/string.hpp>
20 #include <common/compat/getenv.hpp>
21 #include <common/string-utils/string-utils.hpp>
22 #include <common/utils.hpp>
23
24 /* Mi dependancy */
25 #include <common/mi-lttng.hpp>
26
27 #include <lttng/domain-internal.hpp>
28 #include <lttng/event-internal.hpp>
29
30 #include "../command.hpp"
31 #include "../loglevel.hpp"
32 #include "../uprobe.hpp"
33
34 #if (LTTNG_SYMBOL_NAME_LEN == 256)
35 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
36 #endif
37
38 static int opt_event_type;
39 static const char *opt_loglevel;
40 static int opt_loglevel_type;
41 static int opt_kernel;
42 static char *opt_session_name;
43 static int opt_userspace;
44 static int opt_jul;
45 static int opt_log4j;
46 static int opt_python;
47 static int opt_enable_all;
48 static char *opt_probe;
49 static char *opt_userspace_probe;
50 static char *opt_function;
51 static char *opt_channel_name;
52 static char *opt_filter;
53 static char *opt_exclude;
54
55 #ifdef LTTNG_EMBED_HELP
56 static const char help_msg[] =
57 #include <lttng-enable-event.1.h>
58 ;
59 #endif
60
61 enum {
62 OPT_HELP = 1,
63 OPT_TRACEPOINT,
64 OPT_PROBE,
65 OPT_USERSPACE_PROBE,
66 OPT_FUNCTION,
67 OPT_SYSCALL,
68 OPT_USERSPACE,
69 OPT_LOGLEVEL,
70 OPT_LOGLEVEL_ONLY,
71 OPT_LIST_OPTIONS,
72 OPT_FILTER,
73 OPT_EXCLUDE,
74 };
75
76 static struct lttng_handle *handle;
77 static struct mi_writer *writer;
78
79 static struct poptOption long_options[] = {
80 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
81 {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
82 {"session", 's', POPT_ARG_STRING, &opt_session_name, 0, 0, 0},
83 {"all", 'a', POPT_ARG_VAL, &opt_enable_all, 1, 0, 0},
84 {"channel", 'c', POPT_ARG_STRING, &opt_channel_name, 0, 0, 0},
85 {"kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0},
86 {"userspace", 'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0},
87 {"jul", 'j', POPT_ARG_VAL, &opt_jul, 1, 0, 0},
88 {"log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, 0, 0},
89 {"python", 'p', POPT_ARG_VAL, &opt_python, 1, 0, 0},
90 {"tracepoint", 0, POPT_ARG_NONE, 0, OPT_TRACEPOINT, 0, 0},
91 {"probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, 0, 0},
92 {"userspace-probe",0, POPT_ARG_STRING, &opt_userspace_probe, OPT_USERSPACE_PROBE, 0, 0},
93 {"function", 0, POPT_ARG_STRING, &opt_function, OPT_FUNCTION, 0, 0},
94 {"syscall", 0, POPT_ARG_NONE, 0, OPT_SYSCALL, 0, 0},
95 {"loglevel", 0, POPT_ARG_STRING, 0, OPT_LOGLEVEL, 0, 0},
96 {"loglevel-only", 0, POPT_ARG_STRING, 0, OPT_LOGLEVEL_ONLY, 0, 0},
97 {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
98 {"filter", 'f', POPT_ARG_STRING, &opt_filter, OPT_FILTER, 0, 0},
99 {"exclude", 'x', POPT_ARG_STRING, &opt_exclude, OPT_EXCLUDE, 0, 0},
100 {0, 0, 0, 0, 0, 0, 0}
101 };
102
103 /*
104 * Parse probe options.
105 */
106 static int parse_probe_opts(struct lttng_event *ev, char *opt)
107 {
108 int ret = CMD_SUCCESS;
109 int match;
110 char s_hex[19];
111 #define S_HEX_LEN_SCANF_IS_A_BROKEN_API "18" /* 18 is (19 - 1) (\0 is extra) */
112 char name[LTTNG_SYMBOL_NAME_LEN];
113
114 if (opt == NULL) {
115 ret = CMD_ERROR;
116 goto end;
117 }
118
119 /* Check for symbol+offset */
120 match = sscanf(opt, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
121 "[^'+']+%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s", name, s_hex);
122 if (match == 2) {
123 strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
124 ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
125 DBG("probe symbol %s", ev->attr.probe.symbol_name);
126 if (*s_hex == '\0') {
127 ERR("Invalid probe offset %s", s_hex);
128 ret = CMD_ERROR;
129 goto end;
130 }
131 ev->attr.probe.offset = strtoull(s_hex, NULL, 0);
132 DBG("probe offset %" PRIu64, ev->attr.probe.offset);
133 ev->attr.probe.addr = 0;
134 goto end;
135 }
136
137 /* Check for symbol */
138 if (isalpha(name[0]) || name[0] == '_') {
139 match = sscanf(opt, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "s",
140 name);
141 if (match == 1) {
142 strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
143 ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
144 DBG("probe symbol %s", ev->attr.probe.symbol_name);
145 ev->attr.probe.offset = 0;
146 DBG("probe offset %" PRIu64, ev->attr.probe.offset);
147 ev->attr.probe.addr = 0;
148 goto end;
149 }
150 }
151
152 /* Check for address */
153 match = sscanf(opt, "%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s", s_hex);
154 if (match > 0) {
155 /*
156 * Return an error if the first character of the tentative
157 * address is NULL or not a digit. It can be "0" if the address
158 * is in hexadecimal and can be 1 to 9 if it's in decimal.
159 */
160 if (*s_hex == '\0' || !isdigit(*s_hex)) {
161 ERR("Invalid probe description %s", s_hex);
162 ret = CMD_ERROR;
163 goto end;
164 }
165 ev->attr.probe.addr = strtoull(s_hex, NULL, 0);
166 DBG("probe addr %" PRIu64, ev->attr.probe.addr);
167 ev->attr.probe.offset = 0;
168 memset(ev->attr.probe.symbol_name, 0, LTTNG_SYMBOL_NAME_LEN);
169 goto end;
170 }
171
172 /* No match */
173 ret = CMD_ERROR;
174
175 end:
176 return ret;
177 }
178
179 static
180 const char *print_channel_name(const char *name)
181 {
182 return name ? : DEFAULT_CHANNEL_NAME;
183 }
184
185 static
186 const char *print_raw_channel_name(const char *name)
187 {
188 return name ? : "<default>";
189 }
190
191 /*
192 * Mi print exlcusion list
193 */
194 static
195 int mi_print_exclusion(const struct lttng_dynamic_pointer_array *exclusions)
196 {
197 int ret;
198 size_t i;
199 const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
200
201 LTTNG_ASSERT(writer);
202
203 if (count == 0) {
204 ret = 0;
205 goto end;
206 }
207
208 ret = mi_lttng_writer_open_element(writer, config_element_exclusions);
209 if (ret) {
210 goto end;
211 }
212
213 for (i = 0; i < count; i++) {
214 const char *exclusion = (const char *) lttng_dynamic_pointer_array_get_pointer(
215 exclusions, i);
216
217 ret = mi_lttng_writer_write_element_string(writer,
218 config_element_exclusion, exclusion);
219 if (ret) {
220 goto end;
221 }
222 }
223
224 /* Close exclusions element */
225 ret = mi_lttng_writer_close_element(writer);
226
227 end:
228 return ret;
229 }
230
231 /*
232 * Return allocated string for pretty-printing exclusion names.
233 */
234 static
235 char *print_exclusions(const struct lttng_dynamic_pointer_array *exclusions)
236 {
237 int length = 0;
238 size_t i;
239 const char preamble[] = " excluding ";
240 char *ret;
241 const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
242
243 if (count == 0) {
244 return strdup("");
245 }
246
247 /* Calculate total required length. */
248 for (i = 0; i < count; i++) {
249 const char *exclusion = (const char *) lttng_dynamic_pointer_array_get_pointer(
250 exclusions, i);
251
252 length += strlen(exclusion) + 4;
253 }
254
255 length += sizeof(preamble);
256 ret = calloc<char>(length);
257 if (!ret) {
258 return NULL;
259 }
260
261 strncpy(ret, preamble, length);
262 for (i = 0; i < count; i++) {
263 const char *exclusion = (const char *) lttng_dynamic_pointer_array_get_pointer(
264 exclusions, i);
265
266 strcat(ret, "\"");
267 strcat(ret, exclusion);
268 strcat(ret, "\"");
269 if (i != count - 1) {
270 strcat(ret, ", ");
271 }
272 }
273
274 return ret;
275 }
276
277 static
278 int check_exclusion_subsets(const char *event_name, const char *exclusion)
279 {
280 bool warn = false;
281 int ret = 0;
282 const char *e = event_name;
283 const char *x = exclusion;
284
285 /* Scan both the excluder and the event letter by letter */
286 while (true) {
287 if (*e == '\\') {
288 if (*x != *e) {
289 warn = true;
290 goto end;
291 }
292
293 e++;
294 x++;
295 goto cmp_chars;
296 }
297
298 if (*x == '*') {
299 /* Event is a subset of the excluder */
300 ERR("Event %s: %s excludes all events from %s",
301 event_name, exclusion, event_name);
302 goto error;
303 }
304
305 if (*e == '*') {
306 /*
307 * Reached the end of the event name before the
308 * end of the exclusion: this is valid.
309 */
310 goto end;
311 }
312
313 cmp_chars:
314 if (*x != *e) {
315 warn = true;
316 break;
317 }
318
319 x++;
320 e++;
321 }
322
323 goto end;
324
325 error:
326 ret = -1;
327
328 end:
329 if (warn) {
330 WARN("Event %s: %s does not exclude any events from %s",
331 event_name, exclusion, event_name);
332 }
333
334 return ret;
335 }
336
337 int validate_exclusion_list(const char *event_name,
338 const struct lttng_dynamic_pointer_array *exclusions)
339 {
340 int ret;
341
342 /* Event name must be a valid globbing pattern to allow exclusions. */
343 if (!strutils_is_star_glob_pattern(event_name)) {
344 ERR("Event %s: Exclusions can only be used with a globbing pattern",
345 event_name);
346 goto error;
347 }
348
349 /*
350 * If the event name is a star-at-end only globbing pattern,
351 * then we can validate the individual exclusions. Otherwise
352 * all exclusions are passed to the session daemon.
353 */
354 if (strutils_is_star_at_the_end_only_glob_pattern(event_name)) {
355 size_t i, num_exclusions;
356
357 num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
358
359 for (i = 0; i < num_exclusions; i++) {
360 const char *exclusion =
361 (const char *) lttng_dynamic_pointer_array_get_pointer(
362 exclusions, i);
363
364 if (!strutils_is_star_glob_pattern(exclusion) ||
365 strutils_is_star_at_the_end_only_glob_pattern(exclusion)) {
366 ret = check_exclusion_subsets(event_name, exclusion);
367 if (ret) {
368 goto error;
369 }
370 }
371 }
372 }
373
374 ret = 0;
375 goto end;
376
377 error:
378 ret = -1;
379
380 end:
381 return ret;
382 }
383
384 static int create_exclusion_list_and_validate(const char *event_name,
385 const char *exclusions_arg,
386 struct lttng_dynamic_pointer_array *exclusions)
387 {
388 int ret = 0;
389
390 /* Split exclusions. */
391 ret = strutils_split(exclusions_arg, ',', true, exclusions);
392 if (ret < 0) {
393 goto error;
394 }
395
396 if (validate_exclusion_list(event_name, exclusions) !=
397 0) {
398 goto error;
399 }
400
401 goto end;
402
403 error:
404 ret = -1;
405 lttng_dynamic_pointer_array_reset(exclusions);
406
407 end:
408 return ret;
409 }
410
411 static void warn_on_truncated_exclusion_names(const struct lttng_dynamic_pointer_array *exclusions,
412 int *warn)
413 {
414 size_t i;
415 const size_t num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
416
417 for (i = 0; i < num_exclusions; i++) {
418 const char * const exclusion = (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
419
420 if (strlen(exclusion) >= LTTNG_SYMBOL_NAME_LEN) {
421 WARN("Event exclusion \"%s\" will be truncated",
422 exclusion);
423 *warn = 1;
424 }
425 }
426 }
427
428 /*
429 * Enabling event using the lttng API.
430 * Note: in case of error only the last error code will be return.
431 */
432 static int enable_events(char *session_name, char *event_list)
433 {
434 int ret = CMD_SUCCESS, command_ret = CMD_SUCCESS;
435 int error_holder = CMD_SUCCESS, warn = 0, error = 0, success = 1;
436 char *event_name, *channel_name = NULL;
437 struct lttng_event *ev;
438 struct lttng_domain dom = {};
439 struct lttng_dynamic_pointer_array exclusions;
440 struct lttng_userspace_probe_location *uprobe_loc = NULL;
441
442 lttng_dynamic_pointer_array_init(&exclusions, NULL);
443
444 ev = lttng_event_create();
445 if (!ev) {
446 ret = CMD_ERROR;
447 goto error;
448 }
449
450 if (opt_kernel) {
451 if (opt_loglevel) {
452 WARN("Kernel loglevels are not supported.");
453 }
454 }
455
456 /* Create lttng domain */
457 if (opt_kernel) {
458 dom.type = LTTNG_DOMAIN_KERNEL;
459 dom.buf_type = LTTNG_BUFFER_GLOBAL;
460 } else if (opt_userspace) {
461 dom.type = LTTNG_DOMAIN_UST;
462 /* Default. */
463 dom.buf_type = LTTNG_BUFFER_PER_UID;
464 } else if (opt_jul) {
465 dom.type = LTTNG_DOMAIN_JUL;
466 /* Default. */
467 dom.buf_type = LTTNG_BUFFER_PER_UID;
468 } else if (opt_log4j) {
469 dom.type = LTTNG_DOMAIN_LOG4J;
470 /* Default. */
471 dom.buf_type = LTTNG_BUFFER_PER_UID;
472 } else if (opt_python) {
473 dom.type = LTTNG_DOMAIN_PYTHON;
474 /* Default. */
475 dom.buf_type = LTTNG_BUFFER_PER_UID;
476 } else {
477 /* Checked by the caller. */
478 abort();
479 }
480
481 if (opt_exclude) {
482 switch (dom.type) {
483 case LTTNG_DOMAIN_KERNEL:
484 case LTTNG_DOMAIN_JUL:
485 case LTTNG_DOMAIN_LOG4J:
486 case LTTNG_DOMAIN_PYTHON:
487 ERR("Event name exclusions are not yet implemented for %s events",
488 lttng_domain_type_str(dom.type));
489 ret = CMD_ERROR;
490 goto error;
491 case LTTNG_DOMAIN_UST:
492 /* Exclusions supported */
493 break;
494 default:
495 abort();
496 }
497 }
498
499 /*
500 * Adding a filter to a probe, function or userspace-probe would be
501 * denied by the kernel tracer as it's not supported at the moment. We
502 * do an early check here to warn the user.
503 */
504 if (opt_filter && opt_kernel) {
505 switch (opt_event_type) {
506 case LTTNG_EVENT_ALL:
507 case LTTNG_EVENT_TRACEPOINT:
508 case LTTNG_EVENT_SYSCALL:
509 break;
510 case LTTNG_EVENT_PROBE:
511 case LTTNG_EVENT_USERSPACE_PROBE:
512 case LTTNG_EVENT_FUNCTION:
513 ERR("Filter expressions are not supported for %s events",
514 get_event_type_str((lttng_event_type) opt_event_type));
515 ret = CMD_ERROR;
516 goto error;
517 default:
518 ret = CMD_UNDEFINED;
519 goto error;
520 }
521 }
522
523 channel_name = opt_channel_name;
524
525 handle = lttng_create_handle(session_name, &dom);
526 if (handle == NULL) {
527 ret = -1;
528 goto error;
529 }
530
531 /* Prepare Mi */
532 if (lttng_opt_mi) {
533 /* Open a events element */
534 ret = mi_lttng_writer_open_element(writer, config_element_events);
535 if (ret) {
536 ret = CMD_ERROR;
537 goto error;
538 }
539 }
540
541 if (opt_enable_all) {
542 /* Default setup for enable all */
543 if (opt_kernel) {
544 ev->type = (lttng_event_type) opt_event_type;
545 strcpy(ev->name, "*");
546 /* kernel loglevels not implemented */
547 ev->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
548 } else {
549 ev->type = LTTNG_EVENT_TRACEPOINT;
550 strcpy(ev->name, "*");
551 ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
552 if (opt_loglevel) {
553 int name_search_ret;
554
555 LTTNG_ASSERT(opt_userspace || opt_jul || opt_log4j || opt_python);
556
557 if (opt_userspace) {
558 enum lttng_loglevel loglevel;
559
560 name_search_ret = loglevel_name_to_value(opt_loglevel, &loglevel);
561 ev->loglevel = (int) loglevel;
562 } else if (opt_jul) {
563 enum lttng_loglevel_jul loglevel;
564
565 name_search_ret = loglevel_jul_name_to_value(opt_loglevel, &loglevel);
566 ev->loglevel = (int) loglevel;
567 } else if (opt_log4j) {
568 enum lttng_loglevel_log4j loglevel;
569
570 name_search_ret = loglevel_log4j_name_to_value(opt_loglevel, &loglevel);
571 ev->loglevel = (int) loglevel;
572 } else {
573 /* python domain. */
574 enum lttng_loglevel_python loglevel;
575
576 name_search_ret = loglevel_python_name_to_value(opt_loglevel, &loglevel);
577 ev->loglevel = (int) loglevel;
578 }
579
580 if (name_search_ret == -1) {
581 ERR("Unknown loglevel %s", opt_loglevel);
582 ret = -LTTNG_ERR_INVALID;
583 goto error;
584 }
585 } else {
586 LTTNG_ASSERT(opt_userspace || opt_jul || opt_log4j || opt_python);
587 if (opt_userspace) {
588 ev->loglevel = -1;
589 } else if (opt_jul) {
590 ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
591 } else if (opt_log4j) {
592 ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
593 } else if (opt_python) {
594 ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
595 }
596 }
597 }
598
599 if (opt_exclude) {
600 ret = create_exclusion_list_and_validate("*",
601 opt_exclude, &exclusions);
602 if (ret) {
603 ret = CMD_ERROR;
604 goto error;
605 }
606
607 ev->exclusion = 1;
608 warn_on_truncated_exclusion_names(&exclusions,
609 &warn);
610 }
611 if (!opt_filter) {
612 ret = lttng_enable_event_with_exclusions(handle,
613 ev, channel_name,
614 NULL,
615 lttng_dynamic_pointer_array_get_count(&exclusions),
616 (char **) exclusions.array.buffer.data);
617 if (ret < 0) {
618 switch (-ret) {
619 case LTTNG_ERR_KERN_EVENT_EXIST:
620 WARN("Kernel events already enabled (channel %s, session %s)",
621 print_channel_name(channel_name), session_name);
622 warn = 1;
623 break;
624 case LTTNG_ERR_TRACE_ALREADY_STARTED:
625 {
626 const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
627 ERR("Events: %s (channel %s, session %s)",
628 msg,
629 print_channel_name(channel_name),
630 session_name);
631 error = 1;
632 break;
633 }
634 default:
635 ERR("Events: %s (channel %s, session %s)",
636 lttng_strerror(ret),
637 ret == -LTTNG_ERR_NEED_CHANNEL_NAME
638 ? print_raw_channel_name(channel_name)
639 : print_channel_name(channel_name),
640 session_name);
641 error = 1;
642 break;
643 }
644 goto end;
645 }
646
647 switch (opt_event_type) {
648 case LTTNG_EVENT_TRACEPOINT:
649 if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
650 char *exclusion_string = print_exclusions(&exclusions);
651
652 if (!exclusion_string) {
653 PERROR("Cannot allocate exclusion_string");
654 error = 1;
655 goto end;
656 }
657 MSG("All %s tracepoints%s are enabled in channel %s for loglevel %s",
658 lttng_domain_type_str(dom.type),
659 exclusion_string,
660 print_channel_name(channel_name),
661 opt_loglevel);
662 free(exclusion_string);
663 } else {
664 char *exclusion_string = print_exclusions(&exclusions);
665
666 if (!exclusion_string) {
667 PERROR("Cannot allocate exclusion_string");
668 error = 1;
669 goto end;
670 }
671 MSG("All %s tracepoints%s are enabled in channel %s",
672 lttng_domain_type_str(dom.type),
673 exclusion_string,
674 print_channel_name(channel_name));
675 free(exclusion_string);
676 }
677 break;
678 case LTTNG_EVENT_SYSCALL:
679 if (opt_kernel) {
680 MSG("All %s system calls are enabled in channel %s",
681 lttng_domain_type_str(dom.type),
682 print_channel_name(channel_name));
683 }
684 break;
685 case LTTNG_EVENT_ALL:
686 if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
687 char *exclusion_string = print_exclusions(&exclusions);
688
689 if (!exclusion_string) {
690 PERROR("Cannot allocate exclusion_string");
691 error = 1;
692 goto end;
693 }
694 MSG("All %s events%s are enabled in channel %s for loglevel %s",
695 lttng_domain_type_str(dom.type),
696 exclusion_string,
697 print_channel_name(channel_name),
698 opt_loglevel);
699 free(exclusion_string);
700 } else {
701 char *exclusion_string = print_exclusions(&exclusions);
702
703 if (!exclusion_string) {
704 PERROR("Cannot allocate exclusion_string");
705 error = 1;
706 goto end;
707 }
708 MSG("All %s events%s are enabled in channel %s",
709 lttng_domain_type_str(dom.type),
710 exclusion_string,
711 print_channel_name(channel_name));
712 free(exclusion_string);
713 }
714 break;
715 default:
716 /*
717 * We should not be here since lttng_enable_event should have
718 * failed on the event type.
719 */
720 goto error;
721 }
722 }
723
724 if (opt_filter) {
725 command_ret = lttng_enable_event_with_exclusions(handle, ev, channel_name,
726 opt_filter,
727 lttng_dynamic_pointer_array_get_count(&exclusions),
728 (char **) exclusions.array.buffer.data);
729 if (command_ret < 0) {
730 switch (-command_ret) {
731 case LTTNG_ERR_FILTER_EXIST:
732 WARN("Filter on all events is already enabled"
733 " (channel %s, session %s)",
734 print_channel_name(channel_name), session_name);
735 warn = 1;
736 break;
737 case LTTNG_ERR_TRACE_ALREADY_STARTED:
738 {
739 const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
740 ERR("All events: %s (channel %s, session %s, filter \'%s\')",
741 msg,
742 print_channel_name(channel_name),
743 session_name, opt_filter);
744 error = 1;
745 break;
746 }
747 default:
748 ERR("All events: %s (channel %s, session %s, filter \'%s\')",
749 lttng_strerror(command_ret),
750 command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME
751 ? print_raw_channel_name(channel_name)
752 : print_channel_name(channel_name),
753 session_name, opt_filter);
754 error = 1;
755 break;
756 }
757 error_holder = command_ret;
758 } else {
759 ev->filter = 1;
760 MSG("Filter '%s' successfully set", opt_filter);
761 }
762 }
763
764 if (lttng_opt_mi) {
765 /* The wildcard * is used for kernel and ust domain to
766 * represent ALL. We copy * in event name to force the wildcard use
767 * for kernel domain
768 *
769 * Note: this is strictly for semantic and printing while in
770 * machine interface mode.
771 */
772 strcpy(ev->name, "*");
773
774 /* If we reach here the events are enabled */
775 if (!error && !warn) {
776 ev->enabled = 1;
777 } else {
778 ev->enabled = 0;
779 success = 0;
780 }
781 ret = mi_lttng_event(writer, ev, 1, handle->domain.type);
782 if (ret) {
783 ret = CMD_ERROR;
784 goto error;
785 }
786
787 /* print exclusion */
788 ret = mi_print_exclusion(&exclusions);
789 if (ret) {
790 ret = CMD_ERROR;
791 goto error;
792 }
793
794 /* Success ? */
795 ret = mi_lttng_writer_write_element_bool(writer,
796 mi_lttng_element_command_success, success);
797 if (ret) {
798 ret = CMD_ERROR;
799 goto error;
800 }
801
802 /* Close event element */
803 ret = mi_lttng_writer_close_element(writer);
804 if (ret) {
805 ret = CMD_ERROR;
806 goto error;
807 }
808 }
809
810 goto end;
811 }
812
813 /* Strip event list */
814 event_name = strtok(event_list, ",");
815 while (event_name != NULL) {
816 /* Copy name and type of the event */
817 strncpy(ev->name, event_name, LTTNG_SYMBOL_NAME_LEN);
818 ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
819 ev->type = (lttng_event_type) opt_event_type;
820
821 /* Kernel tracer action */
822 if (opt_kernel) {
823 DBG("Enabling kernel event %s for channel %s",
824 event_name,
825 print_channel_name(channel_name));
826
827 switch (opt_event_type) {
828 case LTTNG_EVENT_ALL: /* Enable tracepoints and syscalls */
829 /* If event name differs from *, select tracepoint. */
830 if (strcmp(ev->name, "*")) {
831 ev->type = LTTNG_EVENT_TRACEPOINT;
832 }
833 break;
834 case LTTNG_EVENT_TRACEPOINT:
835 break;
836 case LTTNG_EVENT_PROBE:
837 ret = parse_probe_opts(ev, opt_probe);
838 if (ret) {
839 ERR("Unable to parse probe options");
840 ret = CMD_ERROR;
841 goto error;
842 }
843 break;
844 case LTTNG_EVENT_USERSPACE_PROBE:
845 LTTNG_ASSERT(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
846
847 ret = parse_userspace_probe_opts(opt_userspace_probe, &uprobe_loc);
848 if (ret) {
849 switch (ret) {
850 case CMD_UNSUPPORTED:
851 /*
852 * Error message describing
853 * what is not supported was
854 * printed in the function.
855 */
856 break;
857 case CMD_ERROR:
858 default:
859 ERR("Unable to parse userspace probe options");
860 break;
861 }
862 goto error;
863 }
864
865 ret = lttng_event_set_userspace_probe_location(ev, uprobe_loc);
866 if (ret) {
867 WARN("Failed to set probe location on event");
868 ret = CMD_ERROR;
869 goto error;
870 }
871
872 /* Ownership of the uprobe location was transferred to the event. */
873 uprobe_loc = NULL;
874 break;
875 case LTTNG_EVENT_FUNCTION:
876 ret = parse_probe_opts(ev, opt_function);
877 if (ret) {
878 ERR("Unable to parse function probe options");
879 ret = CMD_ERROR;
880 goto error;
881 }
882 break;
883 case LTTNG_EVENT_SYSCALL:
884 ev->type = LTTNG_EVENT_SYSCALL;
885 break;
886 default:
887 ret = CMD_UNDEFINED;
888 goto error;
889 }
890
891 /* kernel loglevels not implemented */
892 ev->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
893 } else if (opt_userspace) { /* User-space tracer action */
894 DBG("Enabling UST event %s for channel %s, loglevel %s", event_name,
895 print_channel_name(channel_name), opt_loglevel ? : "<all>");
896
897 switch (opt_event_type) {
898 case LTTNG_EVENT_ALL: /* Default behavior is tracepoint */
899 /* Fall-through */
900 case LTTNG_EVENT_TRACEPOINT:
901 /* Copy name and type of the event */
902 ev->type = LTTNG_EVENT_TRACEPOINT;
903 strncpy(ev->name, event_name, LTTNG_SYMBOL_NAME_LEN);
904 ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
905 break;
906 case LTTNG_EVENT_PROBE:
907 case LTTNG_EVENT_FUNCTION:
908 case LTTNG_EVENT_SYSCALL:
909 case LTTNG_EVENT_USERSPACE_PROBE:
910 default:
911 ERR("Event type not available for user-space tracing");
912 ret = CMD_UNSUPPORTED;
913 goto error;
914 }
915
916 if (opt_exclude) {
917 ev->exclusion = 1;
918 if (opt_event_type != LTTNG_EVENT_ALL && opt_event_type != LTTNG_EVENT_TRACEPOINT) {
919 ERR("Exclusion option can only be used with tracepoint events");
920 ret = CMD_ERROR;
921 goto error;
922 }
923 /* Free previously allocated items. */
924 lttng_dynamic_pointer_array_reset(&exclusions);
925 ret = create_exclusion_list_and_validate(
926 event_name, opt_exclude,
927 &exclusions);
928 if (ret) {
929 ret = CMD_ERROR;
930 goto error;
931 }
932
933 warn_on_truncated_exclusion_names(
934 &exclusions, &warn);
935 }
936
937 ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
938 if (opt_loglevel) {
939 enum lttng_loglevel loglevel;
940 const int name_search_ret = loglevel_name_to_value(opt_loglevel, &loglevel);
941
942 if (name_search_ret == -1) {
943 ERR("Unknown loglevel %s", opt_loglevel);
944 ret = -LTTNG_ERR_INVALID;
945 goto error;
946 }
947
948 ev->loglevel = (int) loglevel;
949 } else {
950 ev->loglevel = -1;
951 }
952 } else if (opt_jul || opt_log4j || opt_python) {
953 if (opt_event_type != LTTNG_EVENT_ALL &&
954 opt_event_type != LTTNG_EVENT_TRACEPOINT) {
955 ERR("Event type not supported for domain.");
956 ret = CMD_UNSUPPORTED;
957 goto error;
958 }
959
960 ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
961 if (opt_loglevel) {
962 int name_search_ret;
963
964 if (opt_jul) {
965 enum lttng_loglevel_jul loglevel;
966
967 name_search_ret = loglevel_jul_name_to_value(opt_loglevel, &loglevel);
968 ev->loglevel = (int) loglevel;
969 } else if (opt_log4j) {
970 enum lttng_loglevel_log4j loglevel;
971
972 name_search_ret = loglevel_log4j_name_to_value(opt_loglevel, &loglevel);
973 ev->loglevel = (int) loglevel;
974 } else {
975 /* python domain. */
976 enum lttng_loglevel_python loglevel;
977
978 name_search_ret = loglevel_python_name_to_value(opt_loglevel, &loglevel);
979 ev->loglevel = (int) loglevel;
980 }
981
982 if (name_search_ret) {
983 ERR("Unknown loglevel %s", opt_loglevel);
984 ret = -LTTNG_ERR_INVALID;
985 goto error;
986 }
987 } else {
988 if (opt_jul) {
989 ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
990 } else if (opt_log4j) {
991 ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
992 } else if (opt_python) {
993 ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
994 }
995 }
996 ev->type = LTTNG_EVENT_TRACEPOINT;
997 strncpy(ev->name, event_name, LTTNG_SYMBOL_NAME_LEN);
998 ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
999 } else {
1000 abort();
1001 }
1002
1003 if (!opt_filter) {
1004 char *exclusion_string;
1005
1006 command_ret = lttng_enable_event_with_exclusions(handle,
1007 ev, channel_name,
1008 NULL,
1009 lttng_dynamic_pointer_array_get_count(&exclusions),
1010 (char **) exclusions.array.buffer.data);
1011 exclusion_string = print_exclusions(&exclusions);
1012 if (!exclusion_string) {
1013 PERROR("Cannot allocate exclusion_string");
1014 error = 1;
1015 goto end;
1016 }
1017 if (command_ret < 0) {
1018 /* Turn ret to positive value to handle the positive error code */
1019 switch (-command_ret) {
1020 case LTTNG_ERR_KERN_EVENT_EXIST:
1021 WARN("Kernel event %s%s already enabled (channel %s, session %s)",
1022 event_name,
1023 exclusion_string,
1024 print_channel_name(channel_name), session_name);
1025 warn = 1;
1026 break;
1027 case LTTNG_ERR_TRACE_ALREADY_STARTED:
1028 {
1029 const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
1030 ERR("Event %s%s: %s (channel %s, session %s)", event_name,
1031 exclusion_string,
1032 msg,
1033 print_channel_name(channel_name),
1034 session_name);
1035 error = 1;
1036 break;
1037 }
1038 case LTTNG_ERR_SDT_PROBE_SEMAPHORE:
1039 ERR("SDT probes %s guarded by semaphores are not supported (channel %s, session %s)",
1040 event_name, print_channel_name(channel_name),
1041 session_name);
1042 error = 1;
1043 break;
1044 default:
1045 ERR("Event %s%s: %s (channel %s, session %s)", event_name,
1046 exclusion_string,
1047 lttng_strerror(command_ret),
1048 command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME
1049 ? print_raw_channel_name(channel_name)
1050 : print_channel_name(channel_name),
1051 session_name);
1052 error = 1;
1053 break;
1054 }
1055 error_holder = command_ret;
1056 } else {
1057 switch (dom.type) {
1058 case LTTNG_DOMAIN_KERNEL:
1059 case LTTNG_DOMAIN_UST:
1060 MSG("%s event %s%s created in channel %s",
1061 lttng_domain_type_str(dom.type),
1062 event_name,
1063 exclusion_string,
1064 print_channel_name(channel_name));
1065 break;
1066 case LTTNG_DOMAIN_JUL:
1067 case LTTNG_DOMAIN_LOG4J:
1068 case LTTNG_DOMAIN_PYTHON:
1069 /*
1070 * Don't print the default channel
1071 * name for agent domains.
1072 */
1073 MSG("%s event %s%s enabled",
1074 lttng_domain_type_str(dom.type),
1075 event_name,
1076 exclusion_string);
1077 break;
1078 default:
1079 abort();
1080 }
1081 }
1082 free(exclusion_string);
1083 }
1084
1085 if (opt_filter) {
1086 char *exclusion_string;
1087
1088 /* Filter present */
1089 ev->filter = 1;
1090
1091 command_ret = lttng_enable_event_with_exclusions(handle, ev, channel_name,
1092 opt_filter,
1093 lttng_dynamic_pointer_array_get_count(&exclusions),
1094 (char **) exclusions.array.buffer.data);
1095 exclusion_string = print_exclusions(&exclusions);
1096 if (!exclusion_string) {
1097 PERROR("Cannot allocate exclusion_string");
1098 error = 1;
1099 goto end;
1100 }
1101 if (command_ret < 0) {
1102 switch (-command_ret) {
1103 case LTTNG_ERR_FILTER_EXIST:
1104 WARN("Filter on event %s%s is already enabled"
1105 " (channel %s, session %s)",
1106 event_name,
1107 exclusion_string,
1108 print_channel_name(channel_name), session_name);
1109 warn = 1;
1110 break;
1111 case LTTNG_ERR_TRACE_ALREADY_STARTED:
1112 {
1113 const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
1114 ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')", ev->name,
1115 exclusion_string,
1116 msg,
1117 print_channel_name(channel_name),
1118 session_name, opt_filter);
1119 error = 1;
1120 break;
1121 }
1122 default:
1123 ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')", ev->name,
1124 exclusion_string,
1125 lttng_strerror(command_ret),
1126 command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME
1127 ? print_raw_channel_name(channel_name)
1128 : print_channel_name(channel_name),
1129 session_name, opt_filter);
1130 error = 1;
1131 break;
1132 }
1133 error_holder = command_ret;
1134
1135 } else {
1136 MSG("Event %s%s: Filter '%s' successfully set",
1137 event_name, exclusion_string,
1138 opt_filter);
1139 }
1140 free(exclusion_string);
1141 }
1142
1143 if (lttng_opt_mi) {
1144 if (command_ret) {
1145 success = 0;
1146 ev->enabled = 0;
1147 } else {
1148 ev->enabled = 1;
1149 }
1150
1151 ret = mi_lttng_event(writer, ev, 1, handle->domain.type);
1152 if (ret) {
1153 ret = CMD_ERROR;
1154 goto error;
1155 }
1156
1157 /* print exclusion */
1158 ret = mi_print_exclusion(&exclusions);
1159 if (ret) {
1160 ret = CMD_ERROR;
1161 goto error;
1162 }
1163
1164 /* Success ? */
1165 ret = mi_lttng_writer_write_element_bool(writer,
1166 mi_lttng_element_command_success, success);
1167 if (ret) {
1168 ret = CMD_ERROR;
1169 goto end;
1170 }
1171
1172 /* Close event element */
1173 ret = mi_lttng_writer_close_element(writer);
1174 if (ret) {
1175 ret = CMD_ERROR;
1176 goto end;
1177 }
1178 }
1179
1180 /* Next event */
1181 event_name = strtok(NULL, ",");
1182 /* Reset warn, error and success */
1183 success = 1;
1184 }
1185
1186 end:
1187 /* Close Mi */
1188 if (lttng_opt_mi) {
1189 /* Close events element */
1190 ret = mi_lttng_writer_close_element(writer);
1191 if (ret) {
1192 ret = CMD_ERROR;
1193 goto error;
1194 }
1195 }
1196 error:
1197 if (warn) {
1198 ret = CMD_WARNING;
1199 }
1200 if (error) {
1201 ret = CMD_ERROR;
1202 }
1203 lttng_destroy_handle(handle);
1204 lttng_dynamic_pointer_array_reset(&exclusions);
1205 lttng_userspace_probe_location_destroy(uprobe_loc);
1206
1207 /* Overwrite ret with error_holder if there was an actual error with
1208 * enabling an event.
1209 */
1210 ret = error_holder ? error_holder : ret;
1211
1212 lttng_event_destroy(ev);
1213 return ret;
1214 }
1215
1216 /*
1217 * Add event to trace session
1218 */
1219 int cmd_enable_events(int argc, const char **argv)
1220 {
1221 int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
1222 static poptContext pc;
1223 char *session_name = NULL;
1224 char *event_list = NULL;
1225 const char *arg_event_list = NULL;
1226 const char *leftover = NULL;
1227 int event_type = -1;
1228
1229 pc = poptGetContext(NULL, argc, argv, long_options, 0);
1230 poptReadDefaultConfig(pc, 0);
1231
1232 /* Default event type */
1233 opt_event_type = LTTNG_EVENT_ALL;
1234
1235 while ((opt = poptGetNextOpt(pc)) != -1) {
1236 switch (opt) {
1237 case OPT_HELP:
1238 SHOW_HELP();
1239 goto end;
1240 case OPT_TRACEPOINT:
1241 opt_event_type = LTTNG_EVENT_TRACEPOINT;
1242 break;
1243 case OPT_PROBE:
1244 opt_event_type = LTTNG_EVENT_PROBE;
1245 break;
1246 case OPT_USERSPACE_PROBE:
1247 opt_event_type = LTTNG_EVENT_USERSPACE_PROBE;
1248 break;
1249 case OPT_FUNCTION:
1250 opt_event_type = LTTNG_EVENT_FUNCTION;
1251 break;
1252 case OPT_SYSCALL:
1253 opt_event_type = LTTNG_EVENT_SYSCALL;
1254 break;
1255 case OPT_USERSPACE:
1256 opt_userspace = 1;
1257 break;
1258 case OPT_LOGLEVEL:
1259 opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
1260 opt_loglevel = poptGetOptArg(pc);
1261 break;
1262 case OPT_LOGLEVEL_ONLY:
1263 opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
1264 opt_loglevel = poptGetOptArg(pc);
1265 break;
1266 case OPT_LIST_OPTIONS:
1267 list_cmd_options(stdout, long_options);
1268 goto end;
1269 case OPT_FILTER:
1270 break;
1271 case OPT_EXCLUDE:
1272 break;
1273 default:
1274 ret = CMD_UNDEFINED;
1275 goto end;
1276 }
1277
1278 /* Validate event type. Multiple event type are not supported. */
1279 if (event_type == -1) {
1280 event_type = opt_event_type;
1281 } else {
1282 if (event_type != opt_event_type) {
1283 ERR("Multiple event type not supported.");
1284 ret = CMD_ERROR;
1285 goto end;
1286 }
1287 }
1288 }
1289
1290 ret = print_missing_or_multiple_domains(
1291 opt_kernel + opt_userspace + opt_jul + opt_log4j +
1292 opt_python,
1293 true);
1294 if (ret) {
1295 ret = CMD_ERROR;
1296 goto end;
1297 }
1298
1299 /* Mi check */
1300 if (lttng_opt_mi) {
1301 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
1302 if (!writer) {
1303 ret = -LTTNG_ERR_NOMEM;
1304 goto end;
1305 }
1306
1307 /* Open command element */
1308 ret = mi_lttng_writer_command_open(writer,
1309 mi_lttng_element_command_enable_event);
1310 if (ret) {
1311 ret = CMD_ERROR;
1312 goto end;
1313 }
1314
1315 /* Open output element */
1316 ret = mi_lttng_writer_open_element(writer,
1317 mi_lttng_element_command_output);
1318 if (ret) {
1319 ret = CMD_ERROR;
1320 goto end;
1321 }
1322 }
1323
1324 arg_event_list = poptGetArg(pc);
1325 if (arg_event_list == NULL && opt_enable_all == 0) {
1326 ERR("Missing event name(s).");
1327 ret = CMD_ERROR;
1328 goto end;
1329 }
1330
1331 if (opt_enable_all == 0) {
1332 event_list = strdup(arg_event_list);
1333 if (event_list == NULL) {
1334 PERROR("Failed to copy event name(s)");
1335 ret = CMD_ERROR;
1336 goto end;
1337 }
1338 }
1339
1340 leftover = poptGetArg(pc);
1341 if (leftover) {
1342 ERR("Unknown argument: %s", leftover);
1343 ret = CMD_ERROR;
1344 goto end;
1345 }
1346
1347 if (!opt_session_name) {
1348 session_name = get_session_name();
1349 if (session_name == NULL) {
1350 command_ret = CMD_ERROR;
1351 success = 0;
1352 goto mi_closing;
1353 }
1354 } else {
1355 session_name = opt_session_name;
1356 }
1357
1358 command_ret = enable_events(session_name, event_list);
1359 if (command_ret) {
1360 success = 0;
1361 goto mi_closing;
1362 }
1363
1364 mi_closing:
1365 /* Mi closing */
1366 if (lttng_opt_mi) {
1367 /* Close output element */
1368 ret = mi_lttng_writer_close_element(writer);
1369 if (ret) {
1370 ret = CMD_ERROR;
1371 goto end;
1372 }
1373
1374 ret = mi_lttng_writer_write_element_bool(writer,
1375 mi_lttng_element_command_success, success);
1376 if (ret) {
1377 ret = CMD_ERROR;
1378 goto end;
1379 }
1380
1381 /* Command element close */
1382 ret = mi_lttng_writer_command_close(writer);
1383 if (ret) {
1384 ret = CMD_ERROR;
1385 goto end;
1386 }
1387 }
1388
1389 end:
1390 /* Mi clean-up */
1391 if (writer && mi_lttng_writer_destroy(writer)) {
1392 /* Preserve original error code */
1393 ret = ret ? ret : LTTNG_ERR_MI_IO_FAIL;
1394 }
1395
1396 if (opt_session_name == NULL) {
1397 free(session_name);
1398 }
1399
1400 free(event_list);
1401
1402 /* Overwrite ret if an error occurred in enable_events */
1403 ret = command_ret ? command_ret : ret;
1404
1405 poptFreeContext(pc);
1406 return ret;
1407 }
1408
LTTng 2.0 tools and control repository
This page took 0.097321 seconds and 4 git commands to generate.