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