projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lttng: enable-event: wrap the use of poptContext into a unique_ptr
[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 <stdio.h>
20 #include <stdlib.h>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24
25 /* Mi dependancy */
26 #include "../command.hpp"
27 #include "../loglevel.hpp"
28 #include "../uprobe.hpp"
29
30 #include <common/mi-lttng.hpp>
31
32 #include <lttng/domain-internal.hpp>
33 #include <lttng/event-internal.hpp>
34
35 #if (LTTNG_SYMBOL_NAME_LEN == 256)
36 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
37 #endif
38
39 namespace {
40 void _mi_lttng_writer_deleter_func(mi_writer *writer)
41 {
42 if (writer && mi_lttng_writer_destroy(writer)) {
43 LTTNG_THROW_ERROR("Failed to destroy mi_writer instance");
44 }
45 }
46
47 using mi_writer_uptr = std::unique_ptr<
48 mi_writer,
49 lttng::memory::create_deleter_class<mi_writer, _mi_lttng_writer_deleter_func>::deleter>;
50
51 int opt_event_type;
52 const char *opt_loglevel;
53 int opt_loglevel_type;
54 int opt_kernel;
55 char *opt_session_name;
56 int opt_userspace;
57 int opt_jul;
58 int opt_log4j;
59 int opt_python;
60 int opt_enable_all;
61 char *opt_probe;
62 char *opt_userspace_probe;
63 char *opt_function;
64 char *opt_channel_name;
65 char *opt_filter;
66 char *opt_exclude;
67
68 struct lttng_handle *handle;
69 mi_writer_uptr writer;
70
71 #ifdef LTTNG_EMBED_HELP
72 static const char help_msg[] =
73 #include <lttng-enable-event.1.h>
74 ;
75 #endif
76
77 enum {
78 OPT_HELP = 1,
79 OPT_TRACEPOINT,
80 OPT_PROBE,
81 OPT_USERSPACE_PROBE,
82 OPT_FUNCTION,
83 OPT_SYSCALL,
84 OPT_USERSPACE,
85 OPT_LOGLEVEL,
86 OPT_LOGLEVEL_ONLY,
87 OPT_LIST_OPTIONS,
88 OPT_FILTER,
89 OPT_EXCLUDE,
90 };
91
92 struct poptOption long_options[] = {
93 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
94 { "help", 'h', POPT_ARG_NONE, nullptr, OPT_HELP, nullptr, nullptr },
95 { "session", 's', POPT_ARG_STRING, &opt_session_name, 0, nullptr, nullptr },
96 { "all", 'a', POPT_ARG_VAL, &opt_enable_all, 1, nullptr, nullptr },
97 { "channel", 'c', POPT_ARG_STRING, &opt_channel_name, 0, nullptr, nullptr },
98 { "kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, nullptr, nullptr },
99 { "userspace", 'u', POPT_ARG_NONE, nullptr, OPT_USERSPACE, nullptr, nullptr },
100 { "jul", 'j', POPT_ARG_VAL, &opt_jul, 1, nullptr, nullptr },
101 { "log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, nullptr, nullptr },
102 { "python", 'p', POPT_ARG_VAL, &opt_python, 1, nullptr, nullptr },
103 { "tracepoint", 0, POPT_ARG_NONE, nullptr, OPT_TRACEPOINT, nullptr, nullptr },
104 { "probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, nullptr, nullptr },
105 { "userspace-probe",
106 0,
107 POPT_ARG_STRING,
108 &opt_userspace_probe,
109 OPT_USERSPACE_PROBE,
110 nullptr,
111 nullptr },
112 { "function", 0, POPT_ARG_STRING, &opt_function, OPT_FUNCTION, nullptr, nullptr },
113 { "syscall", 0, POPT_ARG_NONE, nullptr, OPT_SYSCALL, nullptr, nullptr },
114 { "loglevel", 0, POPT_ARG_STRING, nullptr, OPT_LOGLEVEL, nullptr, nullptr },
115 { "loglevel-only", 0, POPT_ARG_STRING, nullptr, OPT_LOGLEVEL_ONLY, nullptr, nullptr },
116 { "list-options", 0, POPT_ARG_NONE, nullptr, OPT_LIST_OPTIONS, nullptr, nullptr },
117 { "filter", 'f', POPT_ARG_STRING, &opt_filter, OPT_FILTER, nullptr, nullptr },
118 { "exclude", 'x', POPT_ARG_STRING, &opt_exclude, OPT_EXCLUDE, nullptr, nullptr },
119 { nullptr, 0, 0, nullptr, 0, nullptr, nullptr }
120 };
121
122 /*
123 * Parse probe options.
124 */
125 int parse_probe_opts(struct lttng_event *ev, char *opt)
126 {
127 int ret = CMD_SUCCESS;
128 int match;
129 char s_hex[19];
130 #define S_HEX_LEN_SCANF_IS_A_BROKEN_API "18" /* 18 is (19 - 1) (\0 is extra) */
131 char name[LTTNG_SYMBOL_NAME_LEN];
132
133 if (opt == nullptr) {
134 ret = CMD_ERROR;
135 goto end;
136 }
137
138 /* Check for symbol+offset */
139 match = sscanf(opt,
140 "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
141 "[^'+']+%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s",
142 name,
143 s_hex);
144 if (match == 2) {
145 strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
146 ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
147 DBG("probe symbol %s", ev->attr.probe.symbol_name);
148 if (*s_hex == '\0') {
149 ERR("Invalid probe offset %s", s_hex);
150 ret = CMD_ERROR;
151 goto end;
152 }
153 ev->attr.probe.offset = strtoull(s_hex, nullptr, 0);
154 DBG("probe offset %" PRIu64, ev->attr.probe.offset);
155 ev->attr.probe.addr = 0;
156 goto end;
157 }
158
159 /* Check for symbol */
160 if (isalpha(name[0]) || name[0] == '_') {
161 match = sscanf(opt, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "s", name);
162 if (match == 1) {
163 strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
164 ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
165 DBG("probe symbol %s", ev->attr.probe.symbol_name);
166 ev->attr.probe.offset = 0;
167 DBG("probe offset %" PRIu64, ev->attr.probe.offset);
168 ev->attr.probe.addr = 0;
169 goto end;
170 }
171 }
172
173 /* Check for address */
174 match = sscanf(opt, "%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s", s_hex);
175 if (match > 0) {
176 /*
177 * Return an error if the first character of the tentative
178 * address is NULL or not a digit. It can be "0" if the address
179 * is in hexadecimal and can be 1 to 9 if it's in decimal.
180 */
181 if (*s_hex == '\0' || !isdigit(*s_hex)) {
182 ERR("Invalid probe description %s", s_hex);
183 ret = CMD_ERROR;
184 goto end;
185 }
186 ev->attr.probe.addr = strtoull(s_hex, nullptr, 0);
187 DBG("probe addr %" PRIu64, ev->attr.probe.addr);
188 ev->attr.probe.offset = 0;
189 memset(ev->attr.probe.symbol_name, 0, LTTNG_SYMBOL_NAME_LEN);
190 goto end;
191 }
192
193 /* No match */
194 ret = CMD_ERROR;
195
196 end:
197 return ret;
198 }
199
200 const char *print_channel_name(const char *name)
201 {
202 return name ?: DEFAULT_CHANNEL_NAME;
203 }
204
205 const char *print_raw_channel_name(const char *name)
206 {
207 return name ?: "<default>";
208 }
209
210 /*
211 * Mi print exlcusion list
212 */
213 int mi_print_exclusion(const struct lttng_dynamic_pointer_array *exclusions)
214 {
215 int ret;
216 size_t i;
217 const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
218
219 LTTNG_ASSERT(writer);
220
221 if (count == 0) {
222 ret = 0;
223 goto end;
224 }
225
226 ret = mi_lttng_writer_open_element(writer.get(), config_element_exclusions);
227 if (ret) {
228 goto end;
229 }
230
231 for (i = 0; i < count; i++) {
232 const char *exclusion =
233 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
234
235 ret = mi_lttng_writer_write_element_string(
236 writer.get(), config_element_exclusion, exclusion);
237 if (ret) {
238 goto end;
239 }
240 }
241
242 /* Close exclusions element */
243 ret = mi_lttng_writer_close_element(writer.get());
244
245 end:
246 return ret;
247 }
248
249 /*
250 * Return allocated string for pretty-printing exclusion names.
251 */
252 char *print_exclusions(const struct lttng_dynamic_pointer_array *exclusions)
253 {
254 int length = 0;
255 size_t i;
256 const char preamble[] = " excluding ";
257 char *ret;
258 const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
259
260 if (count == 0) {
261 return strdup("");
262 }
263
264 /* Calculate total required length. */
265 for (i = 0; i < count; i++) {
266 const char *exclusion =
267 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
268
269 length += strlen(exclusion) + 4;
270 }
271
272 length += sizeof(preamble);
273 ret = calloc<char>(length);
274 if (!ret) {
275 return nullptr;
276 }
277
278 strncpy(ret, preamble, length);
279 for (i = 0; i < count; i++) {
280 const char *exclusion =
281 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
282
283 strcat(ret, "\"");
284 strcat(ret, exclusion);
285 strcat(ret, "\"");
286 if (i != count - 1) {
287 strcat(ret, ", ");
288 }
289 }
290
291 return ret;
292 }
293
294 int check_exclusion_subsets(const char *event_name, const char *exclusion)
295 {
296 bool warn = false;
297 int ret = 0;
298 const char *e = event_name;
299 const char *x = exclusion;
300
301 /* Scan both the excluder and the event letter by letter */
302 while (true) {
303 if (*e == '\\') {
304 if (*x != *e) {
305 warn = true;
306 goto end;
307 }
308
309 e++;
310 x++;
311 goto cmp_chars;
312 }
313
314 if (*x == '*') {
315 /* Event is a subset of the excluder */
316 ERR("Event %s: %s excludes all events from %s",
317 event_name,
318 exclusion,
319 event_name);
320 goto error;
321 }
322
323 if (*e == '*') {
324 /*
325 * Reached the end of the event name before the
326 * end of the exclusion: this is valid.
327 */
328 goto end;
329 }
330
331 cmp_chars:
332 if (*x != *e) {
333 warn = true;
334 break;
335 }
336
337 x++;
338 e++;
339 }
340
341 goto end;
342
343 error:
344 ret = -1;
345
346 end:
347 if (warn) {
348 WARN("Event %s: %s does not exclude any events from %s",
349 event_name,
350 exclusion,
351 event_name);
352 }
353
354 return ret;
355 }
356
357 int create_exclusion_list_and_validate(const char *event_name,
358 const char *exclusions_arg,
359 struct lttng_dynamic_pointer_array *exclusions)
360 {
361 int ret = 0;
362
363 /* Split exclusions. */
364 ret = strutils_split(exclusions_arg, ',', true, exclusions);
365 if (ret < 0) {
366 goto error;
367 }
368
369 if (validate_exclusion_list(event_name, exclusions) != 0) {
370 goto error;
371 }
372
373 goto end;
374
375 error:
376 ret = -1;
377 lttng_dynamic_pointer_array_reset(exclusions);
378
379 end:
380 return ret;
381 }
382
383 void warn_on_truncated_exclusion_names(const struct lttng_dynamic_pointer_array *exclusions,
384 int *warn)
385 {
386 size_t i;
387 const size_t num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
388
389 for (i = 0; i < num_exclusions; i++) {
390 const char *const exclusion =
391 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
392
393 if (strlen(exclusion) >= LTTNG_SYMBOL_NAME_LEN) {
394 WARN("Event exclusion \"%s\" will be truncated", exclusion);
395 *warn = 1;
396 }
397 }
398 }
399
400 /*
401 * Enabling event using the lttng API.
402 * Note: in case of error only the last error code will be return.
403 */
404 int enable_events(char *session_name, char *event_list)
405 {
406 int ret = CMD_SUCCESS, command_ret = CMD_SUCCESS;
407 int error_holder = CMD_SUCCESS, warn = 0, error = 0, success = 1;
408 char *event_name, *channel_name = nullptr;
409 struct lttng_event *ev;
410 struct lttng_domain dom = {};
411 struct lttng_dynamic_pointer_array exclusions;
412 struct lttng_userspace_probe_location *uprobe_loc = nullptr;
413
414 lttng_dynamic_pointer_array_init(&exclusions, nullptr);
415
416 ev = lttng_event_create();
417 if (!ev) {
418 ret = CMD_ERROR;
419 goto error;
420 }
421
422 if (opt_kernel) {
423 if (opt_loglevel) {
424 WARN("Kernel loglevels are not supported.");
425 }
426 }
427
428 /* Create lttng domain */
429 if (opt_kernel) {
430 dom.type = LTTNG_DOMAIN_KERNEL;
431 dom.buf_type = LTTNG_BUFFER_GLOBAL;
432 } else if (opt_userspace) {
433 dom.type = LTTNG_DOMAIN_UST;
434 /* Default. */
435 dom.buf_type = LTTNG_BUFFER_PER_UID;
436 } else if (opt_jul) {
437 dom.type = LTTNG_DOMAIN_JUL;
438 /* Default. */
439 dom.buf_type = LTTNG_BUFFER_PER_UID;
440 } else if (opt_log4j) {
441 dom.type = LTTNG_DOMAIN_LOG4J;
442 /* Default. */
443 dom.buf_type = LTTNG_BUFFER_PER_UID;
444 } else if (opt_python) {
445 dom.type = LTTNG_DOMAIN_PYTHON;
446 /* Default. */
447 dom.buf_type = LTTNG_BUFFER_PER_UID;
448 } else {
449 /* Checked by the caller. */
450 abort();
451 }
452
453 if (opt_exclude) {
454 switch (dom.type) {
455 case LTTNG_DOMAIN_KERNEL:
456 case LTTNG_DOMAIN_JUL:
457 case LTTNG_DOMAIN_LOG4J:
458 case LTTNG_DOMAIN_PYTHON:
459 ERR("Event name exclusions are not yet implemented for %s events",
460 lttng_domain_type_str(dom.type));
461 ret = CMD_ERROR;
462 goto error;
463 case LTTNG_DOMAIN_UST:
464 /* Exclusions supported */
465 break;
466 default:
467 abort();
468 }
469 }
470
471 /*
472 * Adding a filter to a probe, function or userspace-probe would be
473 * denied by the kernel tracer as it's not supported at the moment. We
474 * do an early check here to warn the user.
475 */
476 if (opt_filter && opt_kernel) {
477 switch (opt_event_type) {
478 case LTTNG_EVENT_ALL:
479 case LTTNG_EVENT_TRACEPOINT:
480 case LTTNG_EVENT_SYSCALL:
481 break;
482 case LTTNG_EVENT_PROBE:
483 case LTTNG_EVENT_USERSPACE_PROBE:
484 case LTTNG_EVENT_FUNCTION:
485 ERR("Filter expressions are not supported for %s events",
486 get_event_type_str((lttng_event_type) opt_event_type));
487 ret = CMD_ERROR;
488 goto error;
489 default:
490 ret = CMD_UNDEFINED;
491 goto error;
492 }
493 }
494
495 channel_name = opt_channel_name;
496
497 handle = lttng_create_handle(session_name, &dom);
498 if (handle == nullptr) {
499 ret = -1;
500 goto error;
501 }
502
503 /* Prepare Mi */
504 if (lttng_opt_mi) {
505 /* Open a events element */
506 ret = mi_lttng_writer_open_element(writer.get(), config_element_events);
507 if (ret) {
508 ret = CMD_ERROR;
509 goto error;
510 }
511 }
512
513 if (opt_enable_all) {
514 /* Default setup for enable all */
515 if (opt_kernel) {
516 ev->type = (lttng_event_type) opt_event_type;
517 strcpy(ev->name, "*");
518 /* kernel loglevels not implemented */
519 ev->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
520 } else {
521 ev->type = LTTNG_EVENT_TRACEPOINT;
522 strcpy(ev->name, "*");
523 ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
524 if (opt_loglevel) {
525 int name_search_ret;
526
527 LTTNG_ASSERT(opt_userspace || opt_jul || opt_log4j || opt_python);
528
529 if (opt_userspace) {
530 enum lttng_loglevel loglevel;
531
532 name_search_ret =
533 loglevel_name_to_value(opt_loglevel, &loglevel);
534 ev->loglevel = (int) loglevel;
535 } else if (opt_jul) {
536 enum lttng_loglevel_jul loglevel;
537
538 name_search_ret =
539 loglevel_jul_name_to_value(opt_loglevel, &loglevel);
540 ev->loglevel = (int) loglevel;
541 } else if (opt_log4j) {
542 enum lttng_loglevel_log4j loglevel;
543
544 name_search_ret = loglevel_log4j_name_to_value(opt_loglevel,
545 &loglevel);
546 ev->loglevel = (int) loglevel;
547 } else {
548 /* python domain. */
549 enum lttng_loglevel_python loglevel;
550
551 name_search_ret = loglevel_python_name_to_value(
552 opt_loglevel, &loglevel);
553 ev->loglevel = (int) loglevel;
554 }
555
556 if (name_search_ret == -1) {
557 ERR("Unknown loglevel %s", opt_loglevel);
558 ret = -LTTNG_ERR_INVALID;
559 goto error;
560 }
561 } else {
562 LTTNG_ASSERT(opt_userspace || opt_jul || opt_log4j || opt_python);
563 if (opt_userspace) {
564 ev->loglevel = -1;
565 } else if (opt_jul) {
566 ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
567 } else if (opt_log4j) {
568 ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
569 } else if (opt_python) {
570 ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
571 }
572 }
573 }
574
575 if (opt_exclude) {
576 ret = create_exclusion_list_and_validate("*", opt_exclude, &exclusions);
577 if (ret) {
578 ret = CMD_ERROR;
579 goto error;
580 }
581
582 ev->exclusion = 1;
583 warn_on_truncated_exclusion_names(&exclusions, &warn);
584 }
585 if (!opt_filter) {
586 ret = lttng_enable_event_with_exclusions(
587 handle,
588 ev,
589 channel_name,
590 nullptr,
591 lttng_dynamic_pointer_array_get_count(&exclusions),
592 (char **) exclusions.array.buffer.data);
593 if (ret < 0) {
594 switch (-ret) {
595 case LTTNG_ERR_KERN_EVENT_EXIST:
596 WARN("Kernel events already enabled (channel %s, session %s)",
597 print_channel_name(channel_name),
598 session_name);
599 warn = 1;
600 break;
601 case LTTNG_ERR_TRACE_ALREADY_STARTED:
602 {
603 const char *msg =
604 "The command tried to enable an event in a new domain for a session that has already been started once.";
605 ERR("Events: %s (channel %s, session %s)",
606 msg,
607 print_channel_name(channel_name),
608 session_name);
609 error = 1;
610 break;
611 }
612 default:
613 ERR("Events: %s (channel %s, session %s)",
614 lttng_strerror(ret),
615 ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
616 print_raw_channel_name(channel_name) :
617 print_channel_name(channel_name),
618 session_name);
619 error = 1;
620 break;
621 }
622 goto end;
623 }
624
625 switch (opt_event_type) {
626 case LTTNG_EVENT_TRACEPOINT:
627 if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
628 char *exclusion_string = print_exclusions(&exclusions);
629
630 if (!exclusion_string) {
631 PERROR("Cannot allocate exclusion_string");
632 error = 1;
633 goto end;
634 }
635 MSG("All %s tracepoints%s are enabled in channel %s for loglevel %s",
636 lttng_domain_type_str(dom.type),
637 exclusion_string,
638 print_channel_name(channel_name),
639 opt_loglevel);
640 free(exclusion_string);
641 } else {
642 char *exclusion_string = print_exclusions(&exclusions);
643
644 if (!exclusion_string) {
645 PERROR("Cannot allocate exclusion_string");
646 error = 1;
647 goto end;
648 }
649 MSG("All %s tracepoints%s are enabled in channel %s",
650 lttng_domain_type_str(dom.type),
651 exclusion_string,
652 print_channel_name(channel_name));
653 free(exclusion_string);
654 }
655 break;
656 case LTTNG_EVENT_SYSCALL:
657 if (opt_kernel) {
658 MSG("All %s system calls are enabled in channel %s",
659 lttng_domain_type_str(dom.type),
660 print_channel_name(channel_name));
661 }
662 break;
663 case LTTNG_EVENT_ALL:
664 if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
665 char *exclusion_string = print_exclusions(&exclusions);
666
667 if (!exclusion_string) {
668 PERROR("Cannot allocate exclusion_string");
669 error = 1;
670 goto end;
671 }
672 MSG("All %s events%s are enabled in channel %s for loglevel %s",
673 lttng_domain_type_str(dom.type),
674 exclusion_string,
675 print_channel_name(channel_name),
676 opt_loglevel);
677 free(exclusion_string);
678 } else {
679 char *exclusion_string = print_exclusions(&exclusions);
680
681 if (!exclusion_string) {
682 PERROR("Cannot allocate exclusion_string");
683 error = 1;
684 goto end;
685 }
686 MSG("All %s events%s are enabled in channel %s",
687 lttng_domain_type_str(dom.type),
688 exclusion_string,
689 print_channel_name(channel_name));
690 free(exclusion_string);
691 }
692 break;
693 default:
694 /*
695 * We should not be here since lttng_enable_event should have
696 * failed on the event type.
697 */
698 goto error;
699 }
700 }
701
702 if (opt_filter) {
703 command_ret = lttng_enable_event_with_exclusions(
704 handle,
705 ev,
706 channel_name,
707 opt_filter,
708 lttng_dynamic_pointer_array_get_count(&exclusions),
709 (char **) exclusions.array.buffer.data);
710 if (command_ret < 0) {
711 switch (-command_ret) {
712 case LTTNG_ERR_FILTER_EXIST:
713 WARN("Filter on all events is already enabled"
714 " (channel %s, session %s)",
715 print_channel_name(channel_name),
716 session_name);
717 warn = 1;
718 break;
719 case LTTNG_ERR_TRACE_ALREADY_STARTED:
720 {
721 const char *msg =
722 "The command tried to enable an event in a new domain for a session that has already been started once.";
723 ERR("All events: %s (channel %s, session %s, filter \'%s\')",
724 msg,
725 print_channel_name(channel_name),
726 session_name,
727 opt_filter);
728 error = 1;
729 break;
730 }
731 default:
732 ERR("All events: %s (channel %s, session %s, filter \'%s\')",
733 lttng_strerror(command_ret),
734 command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
735 print_raw_channel_name(channel_name) :
736 print_channel_name(channel_name),
737 session_name,
738 opt_filter);
739 error = 1;
740 break;
741 }
742 error_holder = command_ret;
743 } else {
744 ev->filter = 1;
745 MSG("Filter '%s' successfully set", opt_filter);
746 }
747 }
748
749 if (lttng_opt_mi) {
750 /* The wildcard * is used for kernel and ust domain to
751 * represent ALL. We copy * in event name to force the wildcard use
752 * for kernel domain
753 *
754 * Note: this is strictly for semantic and printing while in
755 * machine interface mode.
756 */
757 strcpy(ev->name, "*");
758
759 /* If we reach here the events are enabled */
760 if (!error && !warn) {
761 ev->enabled = 1;
762 } else {
763 ev->enabled = 0;
764 success = 0;
765 }
766 ret = mi_lttng_event(writer.get(), ev, 1, handle->domain.type);
767 if (ret) {
768 ret = CMD_ERROR;
769 goto error;
770 }
771
772 /* print exclusion */
773 ret = mi_print_exclusion(&exclusions);
774 if (ret) {
775 ret = CMD_ERROR;
776 goto error;
777 }
778
779 /* Success ? */
780 ret = mi_lttng_writer_write_element_bool(
781 writer.get(), mi_lttng_element_command_success, success);
782 if (ret) {
783 ret = CMD_ERROR;
784 goto error;
785 }
786
787 /* Close event element */
788 ret = mi_lttng_writer_close_element(writer.get());
789 if (ret) {
790 ret = CMD_ERROR;
791 goto error;
792 }
793 }
794
795 goto end;
796 }
797
798 /* Strip event list */
799 event_name = strtok(event_list, ",");
800 while (event_name != nullptr) {
801 /* Copy name and type of the event */
802 strncpy(ev->name, event_name, 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("Enabling kernel event %s for channel %s",
809 event_name,
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 event_name,
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, event_name, 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 event_name, 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, event_name, 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 event_name,
1015 exclusion_string,
1016 print_channel_name(channel_name),
1017 session_name);
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 event_name,
1026 exclusion_string,
1027 msg,
1028 print_channel_name(channel_name),
1029 session_name);
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 event_name,
1036 print_channel_name(channel_name),
1037 session_name);
1038 error = 1;
1039 break;
1040 default:
1041 ERR("Event %s%s: %s (channel %s, session %s)",
1042 event_name,
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);
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 event_name,
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 event_name,
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 event_name,
1107 exclusion_string,
1108 print_channel_name(channel_name),
1109 session_name);
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,
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,
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 event_name,
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 /* Next event */
1188 event_name = strtok(nullptr, ",");
1189 /* Reset warn, error and success */
1190 success = 1;
1191 }
1192
1193 end:
1194 /* Close Mi */
1195 if (lttng_opt_mi) {
1196 /* Close events element */
1197 ret = mi_lttng_writer_close_element(writer.get());
1198 if (ret) {
1199 ret = CMD_ERROR;
1200 goto error;
1201 }
1202 }
1203 error:
1204 if (warn) {
1205 ret = CMD_WARNING;
1206 }
1207 if (error) {
1208 ret = CMD_ERROR;
1209 }
1210 lttng_destroy_handle(handle);
1211 lttng_dynamic_pointer_array_reset(&exclusions);
1212 lttng_userspace_probe_location_destroy(uprobe_loc);
1213
1214 /* Overwrite ret with error_holder if there was an actual error with
1215 * enabling an event.
1216 */
1217 ret = error_holder ? error_holder : ret;
1218
1219 lttng_event_destroy(ev);
1220 return ret;
1221 }
1222
1223 void _poptContextFree_deleter_func(poptContext ctx)
1224 {
1225 poptFreeContext(ctx);
1226 }
1227
1228 } /* namespace */
1229
1230 int validate_exclusion_list(const char *event_name,
1231 const struct lttng_dynamic_pointer_array *exclusions)
1232 {
1233 int ret;
1234
1235 /* Event name must be a valid globbing pattern to allow exclusions. */
1236 if (!strutils_is_star_glob_pattern(event_name)) {
1237 ERR("Event %s: Exclusions can only be used with a globbing pattern", event_name);
1238 goto error;
1239 }
1240
1241 /*
1242 * If the event name is a star-at-end only globbing pattern,
1243 * then we can validate the individual exclusions. Otherwise
1244 * all exclusions are passed to the session daemon.
1245 */
1246 if (strutils_is_star_at_the_end_only_glob_pattern(event_name)) {
1247 size_t i, num_exclusions;
1248
1249 num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
1250
1251 for (i = 0; i < num_exclusions; i++) {
1252 const char *exclusion =
1253 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions,
1254 i);
1255
1256 if (!strutils_is_star_glob_pattern(exclusion) ||
1257 strutils_is_star_at_the_end_only_glob_pattern(exclusion)) {
1258 ret = check_exclusion_subsets(event_name, exclusion);
1259 if (ret) {
1260 goto error;
1261 }
1262 }
1263 }
1264 }
1265
1266 ret = 0;
1267 goto end;
1268
1269 error:
1270 ret = -1;
1271
1272 end:
1273 return ret;
1274 }
1275
1276 /*
1277 * Add event to trace session
1278 */
1279 int cmd_enable_events(int argc, const char **argv)
1280 {
1281 int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
1282 char *session_name = nullptr;
1283 char *event_list = nullptr;
1284 const char *arg_event_list = nullptr;
1285 const char *leftover = nullptr;
1286 int event_type = -1;
1287
1288 auto pc = lttng::make_unique_wrapper<poptContext_s, _poptContextFree_deleter_func>(
1289 poptGetContext(nullptr, argc, argv, long_options, 0));
1290 poptReadDefaultConfig(pc.get(), 0);
1291
1292 /* Default event type */
1293 opt_event_type = LTTNG_EVENT_ALL;
1294
1295 while ((opt = poptGetNextOpt(pc.get())) != -1) {
1296 switch (opt) {
1297 case OPT_HELP:
1298 SHOW_HELP();
1299 goto end;
1300 case OPT_TRACEPOINT:
1301 opt_event_type = LTTNG_EVENT_TRACEPOINT;
1302 break;
1303 case OPT_PROBE:
1304 opt_event_type = LTTNG_EVENT_PROBE;
1305 break;
1306 case OPT_USERSPACE_PROBE:
1307 opt_event_type = LTTNG_EVENT_USERSPACE_PROBE;
1308 break;
1309 case OPT_FUNCTION:
1310 opt_event_type = LTTNG_EVENT_FUNCTION;
1311 break;
1312 case OPT_SYSCALL:
1313 opt_event_type = LTTNG_EVENT_SYSCALL;
1314 break;
1315 case OPT_USERSPACE:
1316 opt_userspace = 1;
1317 break;
1318 case OPT_LOGLEVEL:
1319 opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
1320 opt_loglevel = poptGetOptArg(pc.get());
1321 break;
1322 case OPT_LOGLEVEL_ONLY:
1323 opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
1324 opt_loglevel = poptGetOptArg(pc.get());
1325 break;
1326 case OPT_LIST_OPTIONS:
1327 list_cmd_options(stdout, long_options);
1328 goto end;
1329 case OPT_FILTER:
1330 break;
1331 case OPT_EXCLUDE:
1332 break;
1333 default:
1334 ret = CMD_UNDEFINED;
1335 goto end;
1336 }
1337
1338 /* Validate event type. Multiple event type are not supported. */
1339 if (event_type == -1) {
1340 event_type = opt_event_type;
1341 } else {
1342 if (event_type != opt_event_type) {
1343 ERR("Multiple event type not supported.");
1344 ret = CMD_ERROR;
1345 goto end;
1346 }
1347 }
1348 }
1349
1350 ret = print_missing_or_multiple_domains(
1351 opt_kernel + opt_userspace + opt_jul + opt_log4j + opt_python, true);
1352 if (ret) {
1353 ret = CMD_ERROR;
1354 goto end;
1355 }
1356
1357 /* Mi check */
1358 if (lttng_opt_mi) {
1359 writer = mi_writer_uptr(mi_lttng_writer_create(fileno(stdout), lttng_opt_mi));
1360 if (!writer) {
1361 ret = -LTTNG_ERR_NOMEM;
1362 goto end;
1363 }
1364
1365 /* Open command element */
1366 ret = mi_lttng_writer_command_open(writer.get(),
1367 mi_lttng_element_command_enable_event);
1368 if (ret) {
1369 ret = CMD_ERROR;
1370 goto end;
1371 }
1372
1373 /* Open output element */
1374 ret = mi_lttng_writer_open_element(writer.get(), mi_lttng_element_command_output);
1375 if (ret) {
1376 ret = CMD_ERROR;
1377 goto end;
1378 }
1379 }
1380
1381 arg_event_list = poptGetArg(pc.get());
1382 if (arg_event_list == nullptr && opt_enable_all == 0) {
1383 ERR("Missing event name(s).");
1384 ret = CMD_ERROR;
1385 goto end;
1386 }
1387
1388 if (opt_enable_all == 0) {
1389 event_list = strdup(arg_event_list);
1390 if (event_list == nullptr) {
1391 PERROR("Failed to copy event name(s)");
1392 ret = CMD_ERROR;
1393 goto end;
1394 }
1395 }
1396
1397 leftover = poptGetArg(pc.get());
1398 if (leftover) {
1399 ERR("Unknown argument: %s", leftover);
1400 ret = CMD_ERROR;
1401 goto end;
1402 }
1403
1404 if (!opt_session_name) {
1405 session_name = get_session_name();
1406 if (session_name == nullptr) {
1407 command_ret = CMD_ERROR;
1408 success = 0;
1409 goto mi_closing;
1410 }
1411 } else {
1412 session_name = opt_session_name;
1413 }
1414
1415 command_ret = enable_events(session_name, event_list);
1416 if (command_ret) {
1417 success = 0;
1418 goto mi_closing;
1419 }
1420
1421 mi_closing:
1422 /* Mi closing */
1423 if (lttng_opt_mi) {
1424 /* Close output element */
1425 ret = mi_lttng_writer_close_element(writer.get());
1426 if (ret) {
1427 ret = CMD_ERROR;
1428 goto end;
1429 }
1430
1431 ret = mi_lttng_writer_write_element_bool(
1432 writer.get(), mi_lttng_element_command_success, success);
1433 if (ret) {
1434 ret = CMD_ERROR;
1435 goto end;
1436 }
1437
1438 /* Command element close */
1439 ret = mi_lttng_writer_command_close(writer.get());
1440 if (ret) {
1441 ret = CMD_ERROR;
1442 goto end;
1443 }
1444 }
1445
1446 end:
1447 if (opt_session_name == nullptr) {
1448 free(session_name);
1449 }
1450
1451 free(event_list);
1452
1453 /* Overwrite ret if an error occurred in enable_events */
1454 ret = command_ret ? command_ret : ret;
1455 return ret;
1456 }
LTTng 2.0 tools and control repository
This page took 0.090237 seconds and 4 git commands to generate.