2 * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
13 #include "../command.hpp"
14 #include "../loglevel.hpp"
15 #include "../uprobe.hpp"
17 #include "common/argpar/argpar.h"
18 #include "common/argpar-utils/argpar-utils.hpp"
19 #include "common/dynamic-array.hpp"
20 #include "common/mi-lttng.hpp"
21 #include "common/string-utils/string-utils.hpp"
22 #include "common/utils.hpp"
23 #include <lttng/domain-internal.hpp>
24 /* For lttng_event_rule_type_str(). */
25 #include <lttng/event-rule/event-rule-internal.hpp>
26 #include <lttng/lttng.h>
27 #include "common/filter/filter-ast.hpp"
28 #include "common/filter/filter-ir.hpp"
29 #include "common/dynamic-array.hpp"
31 #if (LTTNG_SYMBOL_NAME_LEN == 256)
32 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
35 #ifdef LTTNG_EMBED_HELP
36 static const char help_msg
[] =
37 #include <lttng-add-trigger.1.h>
69 static const struct argpar_opt_descr event_rule_opt_descrs
[] = {
70 { OPT_FILTER
, 'f', "filter", true },
71 { OPT_NAME
, 'n', "name", true },
72 { OPT_EXCLUDE_NAME
, 'x', "exclude-name", true },
73 { OPT_LOG_LEVEL
, 'l', "log-level", true },
74 { OPT_EVENT_NAME
, 'E', "event-name", true },
76 { OPT_TYPE
, 't', "type", true },
77 { OPT_LOCATION
, 'L', "location", true },
79 /* Capture descriptor */
80 { OPT_CAPTURE
, '\0', "capture", true },
82 ARGPAR_OPT_DESCR_SENTINEL
86 bool has_syscall_prefix(const char *arg
)
89 const char kernel_syscall_type_opt_prefix
[] = "kernel:syscall";
90 const size_t kernel_syscall_type_opt_prefix_len
=
91 sizeof(kernel_syscall_type_opt_prefix
) - 1;
92 const char syscall_type_opt_prefix
[] = "syscall";
93 const size_t syscall_type_opt_prefix_len
=
94 sizeof(syscall_type_opt_prefix
) - 1;
96 if (strncmp(arg
, syscall_type_opt_prefix
,
97 syscall_type_opt_prefix_len
) == 0) {
99 } else if (strncmp(arg
, kernel_syscall_type_opt_prefix
,
100 kernel_syscall_type_opt_prefix_len
) == 0) {
110 bool assign_event_rule_type(enum lttng_event_rule_type
*dest
, const char *arg
)
114 if (*dest
!= LTTNG_EVENT_RULE_TYPE_UNKNOWN
) {
115 ERR("More than one `--type` was specified.");
119 if (strcmp(arg
, "user") == 0 || strcmp(arg
, "user:tracepoint") == 0) {
120 *dest
= LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
;
121 } else if (strcmp(arg
, "kernel") == 0 ||
122 strcmp(arg
, "kernel:tracepoint") == 0) {
123 *dest
= LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
;
124 } else if (strcmp(arg
, "jul") == 0 || strcmp(arg
, "jul:logging") == 0) {
125 *dest
= LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
;
126 } else if (strcmp(arg
, "log4j") == 0 ||
127 strcmp(arg
, "log4j:logging") == 0) {
128 *dest
= LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
;
129 } else if (strcmp(arg
, "python") == 0 ||
130 strcmp(arg
, "python:logging") == 0) {
131 *dest
= LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
;
132 } else if (strcmp(arg
, "kprobe") == 0 ||
133 strcmp(arg
, "kernel:kprobe") == 0) {
134 *dest
= LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
;
135 } else if (strcmp(arg
, "kernel:uprobe") == 0) {
136 *dest
= LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
;
137 } else if (has_syscall_prefix(arg
)) {
139 * Matches the following:
143 * - syscall:entry+exit
146 * - kernel:syscall:entry
147 * - kernel:syscall:exit
148 * - kernel:syscall:entry+exit
151 * Validation for the right side is left to further usage sites.
153 *dest
= LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
;
155 ERR("Invalid `--type` value: %s", arg
);
170 bool assign_string(char **dest
, const char *src
, const char *opt_name
)
175 ERR("Duplicate '%s' given.", opt_name
);
181 PERROR("Failed to allocate string '%s'.", opt_name
);
195 static bool parse_syscall_emission_site_from_type(const char *str
,
196 enum lttng_event_rule_kernel_syscall_emission_site
*type
)
199 const char kernel_prefix
[] = "kernel:";
200 const size_t kernel_prefix_len
= sizeof(kernel_prefix
) - 1;
203 * If the passed string is of the form "kernel:syscall*", move the
204 * pointer passed "kernel:".
206 if (strncmp(str
, kernel_prefix
, kernel_prefix_len
) == 0) {
207 str
= &str
[kernel_prefix_len
];
210 if (strcmp(str
, "syscall") == 0 ||
211 strcmp(str
, "syscall:entry+exit") == 0) {
212 *type
= LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT
;
213 } else if (strcmp(str
, "syscall:entry") == 0) {
214 *type
= LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
;
215 } else if (strcmp(str
, "syscall:exit") == 0) {
216 *type
= LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT
;
228 * Parse `str` as a log level against the passed event rule type.
230 * Return the log level in `*log_level`. Return true in `*log_level_only` if
231 * the string specifies exactly this log level, false if it specifies at least
234 * Return true if the string was successfully parsed as a log level string.
236 static bool parse_log_level_string(const char *str
,
237 enum lttng_event_rule_type event_rule_type
,
239 bool *log_level_only
)
243 switch (event_rule_type
) {
244 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
246 enum lttng_loglevel log_level_min
, log_level_max
;
247 if (!loglevel_parse_range_string(
248 str
, &log_level_min
, &log_level_max
)) {
252 /* Only support VAL and VAL.. for now. */
253 if (log_level_min
!= log_level_max
&&
254 log_level_max
!= LTTNG_LOGLEVEL_EMERG
) {
258 *log_level
= (int) log_level_min
;
259 *log_level_only
= log_level_min
== log_level_max
;
262 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
264 enum lttng_loglevel_log4j log_level_min
, log_level_max
;
265 if (!loglevel_log4j_parse_range_string(
266 str
, &log_level_min
, &log_level_max
)) {
270 /* Only support VAL and VAL.. for now. */
271 if (log_level_min
!= log_level_max
&&
272 log_level_max
!= LTTNG_LOGLEVEL_LOG4J_FATAL
) {
276 *log_level
= (int) log_level_min
;
277 *log_level_only
= log_level_min
== log_level_max
;
280 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
282 enum lttng_loglevel_jul log_level_min
, log_level_max
;
283 if (!loglevel_jul_parse_range_string(
284 str
, &log_level_min
, &log_level_max
)) {
288 /* Only support VAL and VAL.. for now. */
289 if (log_level_min
!= log_level_max
&&
290 log_level_max
!= LTTNG_LOGLEVEL_JUL_SEVERE
) {
294 *log_level
= (int) log_level_min
;
295 *log_level_only
= log_level_min
== log_level_max
;
298 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
300 enum lttng_loglevel_python log_level_min
, log_level_max
;
301 if (!loglevel_python_parse_range_string(
302 str
, &log_level_min
, &log_level_max
)) {
306 /* Only support VAL and VAL.. for now. */
307 if (log_level_min
!= log_level_max
&&
309 LTTNG_LOGLEVEL_PYTHON_CRITICAL
) {
313 *log_level
= (int) log_level_min
;
314 *log_level_only
= log_level_min
== log_level_max
;
318 /* Invalid domain type. */
332 static int parse_kernel_probe_opts(const char *source
,
333 struct lttng_kernel_probe_location
**location
)
338 char name
[LTTNG_SYMBOL_NAME_LEN
];
339 char *symbol_name
= NULL
;
342 /* Check for symbol+offset. */
343 match
= sscanf(source
,
344 "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
348 if (*s_hex
== '\0') {
349 ERR("Kernel probe symbol offset is missing.");
353 symbol_name
= strndup(name
, LTTNG_SYMBOL_NAME_LEN
);
355 PERROR("Failed to copy kernel probe location symbol name.");
358 offset
= strtoull(s_hex
, NULL
, 0);
360 *location
= lttng_kernel_probe_location_symbol_create(
361 symbol_name
, offset
);
363 ERR("Failed to create symbol kernel probe location.");
370 /* Check for symbol. */
371 if (isalpha(name
[0]) || name
[0] == '_') {
372 match
= sscanf(source
,
373 "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
377 symbol_name
= strndup(name
, LTTNG_SYMBOL_NAME_LEN
);
379 ERR("Failed to copy kernel probe location symbol name.");
383 *location
= lttng_kernel_probe_location_symbol_create(
386 ERR("Failed to create symbol kernel probe location.");
394 /* Check for address. */
395 match
= sscanf(source
, "%18s", s_hex
);
399 if (*s_hex
== '\0') {
400 ERR("Invalid kernel probe location address.");
404 address
= strtoull(s_hex
, NULL
, 0);
405 *location
= lttng_kernel_probe_location_address_create(address
);
407 ERR("Failed to create symbol kernel probe location.");
425 struct lttng_event_expr
*ir_op_load_expr_to_event_expr(
426 const struct ir_load_expression
*load_expr
,
427 const char *capture_str
)
429 char *provider_name
= NULL
;
430 struct lttng_event_expr
*event_expr
= NULL
;
431 const struct ir_load_expression_op
*load_expr_op
= load_expr
->child
;
432 const enum ir_load_expression_type load_expr_child_type
=
435 switch (load_expr_child_type
) {
436 case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT
:
437 case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT
:
439 const char *field_name
;
441 load_expr_op
= load_expr_op
->next
;
442 LTTNG_ASSERT(load_expr_op
);
443 LTTNG_ASSERT(load_expr_op
->type
== IR_LOAD_EXPRESSION_GET_SYMBOL
);
444 field_name
= load_expr_op
->u
.symbol
;
445 LTTNG_ASSERT(field_name
);
447 event_expr
= load_expr_child_type
== IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT
?
448 lttng_event_expr_event_payload_field_create(field_name
) :
449 lttng_event_expr_channel_context_field_create(field_name
);
451 ERR("Failed to create %s event expression: field name = `%s`.",
452 load_expr_child_type
== IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT
?
453 "payload field" : "channel context",
460 case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT
:
463 const char *type_name
;
464 const char *field_name
;
466 load_expr_op
= load_expr_op
->next
;
467 LTTNG_ASSERT(load_expr_op
);
468 LTTNG_ASSERT(load_expr_op
->type
== IR_LOAD_EXPRESSION_GET_SYMBOL
);
469 field_name
= load_expr_op
->u
.symbol
;
470 LTTNG_ASSERT(field_name
);
473 * The field name needs to be of the form PROVIDER:TYPE. We
476 colon
= strchr(field_name
, ':');
478 ERR("Invalid app-specific context field name: missing colon in `%s`.",
483 type_name
= colon
+ 1;
484 if (*type_name
== '\0') {
485 ERR("Invalid app-specific context field name: missing type name after colon in `%s`.",
490 provider_name
= strndup(field_name
, colon
- field_name
);
491 if (!provider_name
) {
492 PERROR("Failed to allocate field name string");
496 event_expr
= lttng_event_expr_app_specific_context_field_create(
497 provider_name
, type_name
);
499 ERR("Failed to create app-specific context field event expression: provider name = `%s`, type name = `%s`",
500 provider_name
, type_name
);
507 ERR("%s: unexpected load expr type %d.", __func__
,
512 load_expr_op
= load_expr_op
->next
;
514 /* There may be a single array index after that. */
515 if (load_expr_op
->type
== IR_LOAD_EXPRESSION_GET_INDEX
) {
516 struct lttng_event_expr
*index_event_expr
;
517 const uint64_t index
= load_expr_op
->u
.index
;
519 index_event_expr
= lttng_event_expr_array_field_element_create(event_expr
, index
);
520 if (!index_event_expr
) {
521 ERR("Failed to create array field element event expression.");
525 event_expr
= index_event_expr
;
526 load_expr_op
= load_expr_op
->next
;
529 switch (load_expr_op
->type
) {
530 case IR_LOAD_EXPRESSION_LOAD_FIELD
:
532 * This is what we expect, IR_LOAD_EXPRESSION_LOAD_FIELD is
533 * always found at the end of the chain.
536 case IR_LOAD_EXPRESSION_GET_SYMBOL
:
537 ERR("While parsing expression `%s`: Capturing subfields is not supported.",
542 ERR("%s: unexpected load expression operator %s.", __func__
,
543 ir_load_expression_type_str(load_expr_op
->type
));
550 lttng_event_expr_destroy(event_expr
);
560 struct lttng_event_expr
*ir_op_load_to_event_expr(
561 const struct ir_op
*ir
, const char *capture_str
)
563 struct lttng_event_expr
*event_expr
= NULL
;
565 LTTNG_ASSERT(ir
->op
== IR_OP_LOAD
);
567 switch (ir
->data_type
) {
568 case IR_DATA_EXPRESSION
:
570 const struct ir_load_expression
*ir_load_expr
=
571 ir
->u
.load
.u
.expression
;
573 event_expr
= ir_op_load_expr_to_event_expr(
574 ir_load_expr
, capture_str
);
578 ERR("%s: unexpected data type: %s.", __func__
,
579 ir_data_type_str(ir
->data_type
));
587 const char *ir_operator_type_human_str(enum ir_op_type op
)
609 struct lttng_event_expr
*ir_op_root_to_event_expr(const struct ir_op
*ir
,
610 const char *capture_str
)
612 struct lttng_event_expr
*event_expr
= NULL
;
614 LTTNG_ASSERT(ir
->op
== IR_OP_ROOT
);
615 ir
= ir
->u
.root
.child
;
619 event_expr
= ir_op_load_to_event_expr(ir
, capture_str
);
624 ERR("While parsing expression `%s`: %s operators are not allowed in capture expressions.",
626 ir_operator_type_human_str(ir
->op
));
629 ERR("%s: unexpected IR op type: %s.", __func__
,
630 ir_op_type_str(ir
->op
));
638 void destroy_event_expr(void *ptr
)
640 lttng_event_expr_destroy((lttng_event_expr
*) ptr
);
644 struct parse_event_rule_res
{
646 struct lttng_event_rule
*er
;
648 /* Array of `struct lttng_event_expr *` */
649 struct lttng_dynamic_pointer_array capture_descriptors
;
654 struct parse_event_rule_res
parse_event_rule(int *argc
, const char ***argv
,
657 enum lttng_event_rule_type event_rule_type
=
658 LTTNG_EVENT_RULE_TYPE_UNKNOWN
;
659 struct argpar_iter
*argpar_iter
= NULL
;
660 const struct argpar_item
*argpar_item
= NULL
;
661 int consumed_args
= -1;
662 struct lttng_kernel_probe_location
*kernel_probe_location
= NULL
;
663 struct lttng_userspace_probe_location
*userspace_probe_location
= NULL
;
664 struct parse_event_rule_res res
= {};
665 struct lttng_event_expr
*event_expr
= NULL
;
666 struct filter_parser_ctx
*parser_ctx
= NULL
;
667 struct lttng_log_level_rule
*log_level_rule
= NULL
;
669 /* Event rule type option */
670 char *event_rule_type_str
= NULL
;
672 /* Tracepoint and syscall options. */
674 /* Array of strings. */
675 struct lttng_dynamic_pointer_array exclude_names
;
677 /* For userspace / kernel probe and function. */
678 char *location
= NULL
;
679 char *event_name
= NULL
;
685 char *log_level_str
= NULL
;
687 lttng_dynamic_pointer_array_init(&res
.capture_descriptors
,
690 lttng_dynamic_pointer_array_init(&exclude_names
, free
);
692 argpar_iter
= argpar_iter_create(*argc
, *argv
, event_rule_opt_descrs
);
694 ERR("Failed to allocate an argpar iter.");
699 enum parse_next_item_status status
;
701 status
= parse_next_item(argpar_iter
, &argpar_item
,
702 argc_offset
, *argv
, false, NULL
, NULL
);
703 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
704 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
706 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
710 LTTNG_ASSERT(status
== PARSE_NEXT_ITEM_STATUS_OK
);
712 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
713 const struct argpar_opt_descr
*descr
=
714 argpar_item_opt_descr(argpar_item
);
715 const char *arg
= argpar_item_opt_arg(argpar_item
);
719 if (!assign_event_rule_type(&event_rule_type
, arg
)) {
723 /* Save the string for later use. */
724 if (!assign_string(&event_rule_type_str
, arg
,
731 if (!assign_string(&location
, arg
,
738 if (!assign_string(&event_name
, arg
,
739 "--event-name/-E")) {
745 if (!assign_string(&filter
, arg
,
752 if (!assign_string(&name
, arg
,
758 case OPT_EXCLUDE_NAME
:
762 ret
= lttng_dynamic_pointer_array_add_pointer(
766 ERR("Failed to add pointer to dynamic pointer array.");
773 if (!assign_string(&log_level_str
, arg
,
783 ret
= filter_parser_ctx_create_from_filter_expression(
786 ERR("Failed to parse capture expression `%s`.", arg
);
790 event_expr
= ir_op_root_to_event_expr(
791 parser_ctx
->ir_root
, arg
);
794 * ir_op_root_to_event_expr has printed
800 ret
= lttng_dynamic_pointer_array_add_pointer(
801 &res
.capture_descriptors
,
808 * The ownership of event expression was
809 * transferred to the dynamic array.
819 const char *arg
= argpar_item_non_opt_arg(argpar_item
);
821 /* Don't accept non-option arguments. */
822 ERR("Unexpected argument '%s'", arg
);
827 if (event_rule_type
== LTTNG_EVENT_RULE_TYPE_UNKNOWN
) {
828 ERR("Event rule requires a --type.");
833 * Option --name is applicable to event rules of type kernel, user, jul,
834 * log4j,python and syscall. If --name is omitted, it is implicitly
837 switch (event_rule_type
) {
838 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
839 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
840 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
841 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
842 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
843 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
851 ERR("Can't use --name with %s event rules.",
852 lttng_event_rule_type_str(
857 if (lttng_dynamic_pointer_array_get_count(&exclude_names
) > 0) {
858 ERR("Can't use --exclude-name/-x with %s event rules.",
859 lttng_event_rule_type_str(
866 * Option --location is only applicable to (and mandatory for) event
867 * rules of type {k,u}probe and function.
869 * Option --event-name is only applicable to event rules of type probe.
870 * If omitted, it defaults to the location.
872 switch (event_rule_type
) {
873 case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
:
874 case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
:
876 ERR("Event rule of type %s requires a --location.",
877 lttng_event_rule_type_str(event_rule_type
));
882 event_name
= strdup(location
);
889 ERR("Can't use --location with %s event rules.",
890 lttng_event_rule_type_str(event_rule_type
));
895 ERR("Can't use --event-name with %s event rules.",
896 lttng_event_rule_type_str(
903 * Update *argc and *argv so our caller can keep parsing what follows.
905 consumed_args
= argpar_iter_ingested_orig_args(argpar_iter
);
906 LTTNG_ASSERT(consumed_args
>= 0);
907 *argc
-= consumed_args
;
908 *argv
+= consumed_args
;
911 * Adding a filter to a probe, function or userspace-probe would be
912 * denied by the kernel tracer as it's not supported at the moment. We
913 * do an early check here to warn the user.
916 switch (event_rule_type
) {
917 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
918 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
919 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
920 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
921 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
922 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
925 ERR("Filter expressions are not supported for %s event rules.",
926 lttng_event_rule_type_str(event_rule_type
));
932 * If --exclude-name/-x was passed, split it into an exclusion list.
933 * Exclusions are only supported by
934 * LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT for now.
936 if (lttng_dynamic_pointer_array_get_count(&exclude_names
) > 0) {
937 if (event_rule_type
!= LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
) {
938 ERR("Event name exclusions are not yet implemented for %s event rules.",
939 lttng_event_rule_type_str(event_rule_type
));
943 if (validate_exclusion_list(name
, &exclude_names
) != 0) {
945 * Assume validate_exclusion_list already prints an
953 switch (event_rule_type
) {
954 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
955 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
956 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
957 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
962 if (strcmp(log_level_str
, "..") == 0) {
964 * ".." is the same as passing no log level
965 * option and correspond to the "ANY" case.
970 if (!parse_log_level_string(log_level_str
, event_rule_type
,
971 &log_level
, &log_level_only
)) {
972 ERR("Failed to parse log level string `%s`.",
977 if (log_level_only
) {
978 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
980 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(log_level
);
983 if (log_level_rule
== NULL
) {
984 ERR("Failed to create log level rule object.");
990 ERR("Log levels are not supported for %s event rules.",
991 lttng_event_rule_type_str(event_rule_type
));
996 /* Finally, create the event rule object. */
997 switch (event_rule_type
) {
998 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
1000 enum lttng_event_rule_status event_rule_status
;
1002 res
.er
= lttng_event_rule_user_tracepoint_create();
1004 ERR("Failed to create user_tracepoint event rule.");
1009 event_rule_status
= lttng_event_rule_user_tracepoint_set_name_pattern(
1011 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1012 ERR("Failed to set user_tracepoint event rule's pattern to '%s'.",
1019 event_rule_status
= lttng_event_rule_user_tracepoint_set_filter(
1021 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1022 ERR("Failed to set user_tracepoint event rule's filter to '%s'.",
1028 /* Set exclusion list. */
1029 if (lttng_dynamic_pointer_array_get_count(&exclude_names
) > 0) {
1031 int count
= lttng_dynamic_pointer_array_get_count(
1034 for (n
= 0; n
< count
; n
++) {
1035 const char *exclude_name
=
1036 (const char *) lttng_dynamic_pointer_array_get_pointer(
1041 lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
1044 if (event_rule_status
!=
1045 LTTNG_EVENT_RULE_STATUS_OK
) {
1046 ERR("Failed to set user_tracepoint exclusion list element '%s'",
1053 if (log_level_rule
) {
1055 lttng_event_rule_user_tracepoint_set_log_level_rule(
1056 res
.er
, log_level_rule
);
1058 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1059 ERR("Failed to set log level on event fule.");
1066 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
1068 enum lttng_event_rule_status event_rule_status
;
1070 res
.er
= lttng_event_rule_kernel_tracepoint_create();
1072 ERR("Failed to create kernel_tracepoint event rule.");
1077 event_rule_status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(
1079 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1080 ERR("Failed to set kernel_tracepoint event rule's pattern to '%s'.",
1087 event_rule_status
= lttng_event_rule_kernel_tracepoint_set_filter(
1089 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1090 ERR("Failed to set kernel_tracepoint event rule's filter to '%s'.",
1097 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
1099 enum lttng_event_rule_status event_rule_status
;
1101 res
.er
= lttng_event_rule_jul_logging_create();
1103 ERR("Failed to create jul_logging event rule.");
1108 event_rule_status
= lttng_event_rule_jul_logging_set_name_pattern(
1110 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1111 ERR("Failed to set jul_logging event rule's pattern to '%s'.",
1118 event_rule_status
= lttng_event_rule_jul_logging_set_filter(
1120 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1121 ERR("Failed to set jul_logging event rule's filter to '%s'.",
1127 if (log_level_rule
) {
1129 lttng_event_rule_jul_logging_set_log_level_rule(
1130 res
.er
, log_level_rule
);
1132 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1133 ERR("Failed to set log level on event fule.");
1139 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
1141 enum lttng_event_rule_status event_rule_status
;
1143 res
.er
= lttng_event_rule_log4j_logging_create();
1145 ERR("Failed to create jul_logging event rule.");
1150 event_rule_status
= lttng_event_rule_log4j_logging_set_name_pattern(
1152 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1153 ERR("Failed to set jul_logging event rule's pattern to '%s'.",
1160 event_rule_status
= lttng_event_rule_log4j_logging_set_filter(
1162 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1163 ERR("Failed to set jul_logging event rule's filter to '%s'.",
1169 if (log_level_rule
) {
1171 lttng_event_rule_log4j_logging_set_log_level_rule(
1172 res
.er
, log_level_rule
);
1174 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1175 ERR("Failed to set log level on event fule.");
1181 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
1183 enum lttng_event_rule_status event_rule_status
;
1185 res
.er
= lttng_event_rule_python_logging_create();
1187 ERR("Failed to create jul_logging event rule.");
1192 event_rule_status
= lttng_event_rule_python_logging_set_name_pattern(
1194 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1195 ERR("Failed to set jul_logging event rule's pattern to '%s'.",
1202 event_rule_status
= lttng_event_rule_python_logging_set_filter(
1204 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1205 ERR("Failed to set jul_logging event rule's filter to '%s'.",
1211 if (log_level_rule
) {
1213 lttng_event_rule_python_logging_set_log_level_rule(
1214 res
.er
, log_level_rule
);
1216 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1217 ERR("Failed to set log level on event fule.");
1223 case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
:
1226 enum lttng_event_rule_status event_rule_status
;
1228 ret
= parse_kernel_probe_opts(
1229 location
, &kernel_probe_location
);
1231 ERR("Failed to parse kernel probe location.");
1235 LTTNG_ASSERT(kernel_probe_location
);
1236 res
.er
= lttng_event_rule_kernel_kprobe_create(kernel_probe_location
);
1238 ERR("Failed to create kprobe event rule.");
1243 lttng_event_rule_kernel_kprobe_set_event_name(
1244 res
.er
, event_name
);
1245 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1246 ERR("Failed to set kprobe event rule's name to '%s'.",
1253 case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
:
1256 enum lttng_event_rule_status event_rule_status
;
1258 ret
= parse_userspace_probe_opts(
1259 location
, &userspace_probe_location
);
1261 ERR("Failed to parse user space probe location.");
1265 res
.er
= lttng_event_rule_kernel_uprobe_create(userspace_probe_location
);
1267 ERR("Failed to create userspace probe event rule.");
1272 lttng_event_rule_kernel_uprobe_set_event_name(
1273 res
.er
, event_name
);
1274 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1275 ERR("Failed to set user space probe event rule's name to '%s'.",
1282 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
1284 enum lttng_event_rule_status event_rule_status
;
1285 enum lttng_event_rule_kernel_syscall_emission_site emission_site
;
1287 if (!parse_syscall_emission_site_from_type(
1288 event_rule_type_str
, &emission_site
)) {
1289 ERR("Failed to parse syscall type '%s'.", event_rule_type_str
);
1293 res
.er
= lttng_event_rule_kernel_syscall_create(emission_site
);
1295 ERR("Failed to create syscall event rule.");
1299 event_rule_status
= lttng_event_rule_kernel_syscall_set_name_pattern(
1301 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1302 ERR("Failed to set syscall event rule's pattern to '%s'.",
1308 event_rule_status
= lttng_event_rule_kernel_syscall_set_filter(
1310 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1311 ERR("Failed to set syscall event rule's filter to '%s'.",
1327 lttng_event_rule_destroy(res
.er
);
1329 lttng_dynamic_pointer_array_reset(&res
.capture_descriptors
);
1333 filter_parser_ctx_free(parser_ctx
);
1336 lttng_event_expr_destroy(event_expr
);
1337 argpar_item_destroy(argpar_item
);
1338 argpar_iter_destroy(argpar_iter
);
1341 lttng_dynamic_pointer_array_reset(&exclude_names
);
1342 free(log_level_str
);
1345 free(event_rule_type_str
);
1347 lttng_kernel_probe_location_destroy(kernel_probe_location
);
1348 lttng_userspace_probe_location_destroy(userspace_probe_location
);
1349 lttng_log_level_rule_destroy(log_level_rule
);
1354 struct lttng_condition
*handle_condition_event(int *argc
, const char ***argv
,
1357 struct parse_event_rule_res res
;
1358 struct lttng_condition
*c
;
1361 res
= parse_event_rule(argc
, argv
, argc_offset
);
1367 c
= lttng_condition_event_rule_matches_create(res
.er
);
1368 lttng_event_rule_destroy(res
.er
);
1374 for (i
= 0; i
< lttng_dynamic_pointer_array_get_count(&res
.capture_descriptors
);
1376 enum lttng_condition_status status
;
1377 struct lttng_event_expr
**expr
=
1378 (lttng_event_expr
**) lttng_dynamic_array_get_element(
1379 &res
.capture_descriptors
.array
, i
);
1382 LTTNG_ASSERT(*expr
);
1383 status
= lttng_condition_event_rule_matches_append_capture_descriptor(
1385 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
1386 if (status
== LTTNG_CONDITION_STATUS_UNSUPPORTED
) {
1387 ERR("The capture feature is unsupported by the event-rule condition type");
1393 /* Ownership of event expression moved to `c` */
1400 lttng_condition_destroy(c
);
1404 lttng_dynamic_pointer_array_reset(&res
.capture_descriptors
);
1405 lttng_event_rule_destroy(res
.er
);
1410 struct condition_descr
{
1412 struct lttng_condition
*(*handler
) (int *argc
, const char ***argv
,
1418 struct condition_descr condition_descrs
[] = {
1419 { "event-rule-matches", handle_condition_event
},
1423 void print_valid_condition_names(void)
1427 ERR("Valid condition names are:");
1429 for (i
= 0; i
< ARRAY_SIZE(condition_descrs
); ++i
) {
1430 ERR(" %s", condition_descrs
[i
].name
);
1435 struct lttng_condition
*parse_condition(const char *condition_name
, int *argc
,
1436 const char ***argv
, int argc_offset
, int orig_arg_index
,
1437 const char *orig_arg
)
1440 struct lttng_condition
*cond
;
1441 const struct condition_descr
*descr
= NULL
;
1443 for (i
= 0; i
< ARRAY_SIZE(condition_descrs
); i
++) {
1444 if (strcmp(condition_name
, condition_descrs
[i
].name
) == 0) {
1445 descr
= &condition_descrs
[i
];
1451 ERR(WHILE_PARSING_ARG_N_ARG_FMT
"Unknown condition name '%s'",
1452 orig_arg_index
+ 1, orig_arg
, condition_name
);
1453 print_valid_condition_names();
1457 cond
= descr
->handler(argc
, argv
, argc_offset
);
1459 /* The handler has already printed an error message. */
1470 static struct lttng_rate_policy
*parse_rate_policy(const char *policy_str
)
1473 size_t num_token
= 0;
1474 struct lttng_dynamic_pointer_array tokens
;
1475 struct lttng_rate_policy
*policy
= NULL
;
1476 enum lttng_rate_policy_type policy_type
;
1477 unsigned long long value
;
1478 char *policy_type_str
;
1479 char *policy_value_str
;
1481 LTTNG_ASSERT(policy_str
);
1482 lttng_dynamic_pointer_array_init(&tokens
, NULL
);
1484 /* Rate policy fields are separated by ':'. */
1485 ret
= strutils_split(policy_str
, ':', 1, &tokens
);
1487 num_token
= lttng_dynamic_pointer_array_get_count(&tokens
);
1491 * Early sanity check that the number of parameter is exactly 2.
1494 if (num_token
!= 2) {
1495 ERR("Rate policy format is invalid.");
1499 policy_type_str
= (char *) lttng_dynamic_pointer_array_get_pointer(&tokens
, 0);
1500 policy_value_str
= (char *) lttng_dynamic_pointer_array_get_pointer(&tokens
, 1);
1502 /* Parse the type. */
1503 if (strcmp(policy_type_str
, "once-after") == 0) {
1504 policy_type
= LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N
;
1505 } else if (strcmp(policy_type_str
, "every") == 0) {
1506 policy_type
= LTTNG_RATE_POLICY_TYPE_EVERY_N
;
1508 ERR("Rate policy type `%s` unknown.", policy_type_str
);
1512 /* Parse the value. */
1513 if (utils_parse_unsigned_long_long(policy_value_str
, &value
) != 0) {
1514 ERR("Failed to parse rate policy value `%s` as an integer.",
1520 ERR("Rate policy value `%s` must be > 0.", policy_value_str
);
1524 switch (policy_type
) {
1525 case LTTNG_RATE_POLICY_TYPE_EVERY_N
:
1526 policy
= lttng_rate_policy_every_n_create(value
);
1528 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N
:
1529 policy
= lttng_rate_policy_once_after_n_create(value
);
1535 if (policy
== NULL
) {
1536 ERR("Failed to create rate policy `%s`.", policy_str
);
1540 lttng_dynamic_pointer_array_reset(&tokens
);
1544 static const struct argpar_opt_descr notify_action_opt_descrs
[] = {
1545 { OPT_RATE_POLICY
, '\0', "rate-policy", true },
1546 ARGPAR_OPT_DESCR_SENTINEL
1550 struct lttng_action
*handle_action_notify(int *argc
, const char ***argv
,
1553 struct lttng_action
*action
= NULL
;
1554 struct argpar_iter
*argpar_iter
= NULL
;
1555 const struct argpar_item
*argpar_item
= NULL
;
1556 struct lttng_rate_policy
*policy
= NULL
;
1558 argpar_iter
= argpar_iter_create(*argc
, *argv
, notify_action_opt_descrs
);
1560 ERR("Failed to allocate an argpar iter.");
1565 enum parse_next_item_status status
;
1567 status
= parse_next_item(argpar_iter
, &argpar_item
,
1568 argc_offset
, *argv
, false, NULL
,
1569 "While parsing `notify` action:");
1570 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1571 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1573 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1577 LTTNG_ASSERT(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1579 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1580 const struct argpar_opt_descr
*descr
=
1581 argpar_item_opt_descr(argpar_item
);
1582 const char *arg
= argpar_item_opt_arg(argpar_item
);
1584 switch (descr
->id
) {
1585 case OPT_RATE_POLICY
:
1587 policy
= parse_rate_policy(arg
);
1597 const char *arg
= argpar_item_non_opt_arg(argpar_item
);
1599 ERR("Unexpected argument `%s`.", arg
);
1604 *argc
-= argpar_iter_ingested_orig_args(argpar_iter
);
1605 *argv
+= argpar_iter_ingested_orig_args(argpar_iter
);
1607 action
= lttng_action_notify_create();
1609 ERR("Failed to create notify action");
1614 enum lttng_action_status status
;
1615 status
= lttng_action_notify_set_rate_policy(action
, policy
);
1616 if (status
!= LTTNG_ACTION_STATUS_OK
) {
1617 ERR("Failed to set rate policy");
1625 lttng_action_destroy(action
);
1628 lttng_rate_policy_destroy(policy
);
1629 argpar_item_destroy(argpar_item
);
1630 argpar_iter_destroy(argpar_iter
);
1635 * Generic handler for a kind of action that takes a session name and an
1636 * optional rate policy.
1639 static struct lttng_action
*handle_action_simple_session_with_policy(int *argc
,
1642 struct lttng_action
*(*create_action_cb
)(void),
1643 enum lttng_action_status (*set_session_name_cb
)(
1644 struct lttng_action
*, const char *),
1645 enum lttng_action_status (*set_rate_policy_cb
)(
1646 struct lttng_action
*,
1647 const struct lttng_rate_policy
*),
1648 const char *action_name
)
1650 struct lttng_action
*action
= NULL
;
1651 struct argpar_iter
*argpar_iter
= NULL
;
1652 const struct argpar_item
*argpar_item
= NULL
;
1653 const char *session_name_arg
= NULL
;
1654 enum lttng_action_status action_status
;
1655 struct lttng_rate_policy
*policy
= NULL
;
1657 LTTNG_ASSERT(set_session_name_cb
);
1658 LTTNG_ASSERT(set_rate_policy_cb
);
1660 const struct argpar_opt_descr rate_policy_opt_descrs
[] = {
1661 { OPT_RATE_POLICY
, '\0', "rate-policy", true },
1662 ARGPAR_OPT_DESCR_SENTINEL
1665 argpar_iter
= argpar_iter_create(*argc
, *argv
, rate_policy_opt_descrs
);
1667 ERR("Failed to allocate an argpar iter.");
1672 enum parse_next_item_status status
;
1674 status
= parse_next_item(argpar_iter
, &argpar_item
, argc_offset
,
1676 "While parsing `%s` action:", action_name
);
1677 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1678 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1680 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1684 LTTNG_ASSERT(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1686 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1687 const struct argpar_opt_descr
*descr
=
1688 argpar_item_opt_descr(argpar_item
);
1689 const char *arg
= argpar_item_opt_arg(argpar_item
);
1691 switch (descr
->id
) {
1692 case OPT_RATE_POLICY
:
1694 policy
= parse_rate_policy(arg
);
1704 const char *arg
= argpar_item_non_opt_arg(argpar_item
);
1705 unsigned int idx
= argpar_item_non_opt_non_opt_index(argpar_item
);
1709 session_name_arg
= arg
;
1712 ERR("Unexpected argument `%s`.", arg
);
1718 *argc
-= argpar_iter_ingested_orig_args(argpar_iter
);
1719 *argv
+= argpar_iter_ingested_orig_args(argpar_iter
);
1721 if (!session_name_arg
) {
1722 ERR("Missing session name.");
1726 action
= create_action_cb();
1728 ERR("Failed to allocate %s session action.", action_name
);
1732 action_status
= set_session_name_cb(action
, session_name_arg
);
1733 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
1734 ERR("Failed to set action %s session's session name to '%s'.",
1735 action_name
, session_name_arg
);
1740 action_status
= set_rate_policy_cb(action
, policy
);
1741 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
1742 ERR("Failed to set rate policy");
1750 lttng_action_destroy(action
);
1754 lttng_rate_policy_destroy(policy
);
1755 argpar_item_destroy(argpar_item
);
1756 argpar_iter_destroy(argpar_iter
);
1761 struct lttng_action
*handle_action_start_session(int *argc
,
1762 const char ***argv
, int argc_offset
)
1764 return handle_action_simple_session_with_policy(argc
, argv
,
1766 lttng_action_start_session_create
,
1767 lttng_action_start_session_set_session_name
,
1768 lttng_action_start_session_set_rate_policy
, "start");
1772 struct lttng_action
*handle_action_stop_session(int *argc
,
1773 const char ***argv
, int argc_offset
)
1775 return handle_action_simple_session_with_policy(argc
, argv
,
1777 lttng_action_stop_session_create
,
1778 lttng_action_stop_session_set_session_name
,
1779 lttng_action_stop_session_set_rate_policy
, "stop");
1783 struct lttng_action
*handle_action_rotate_session(int *argc
,
1784 const char ***argv
, int argc_offset
)
1786 return handle_action_simple_session_with_policy(argc
, argv
,
1788 lttng_action_rotate_session_create
,
1789 lttng_action_rotate_session_set_session_name
,
1790 lttng_action_rotate_session_set_rate_policy
,
1794 static const struct argpar_opt_descr snapshot_action_opt_descrs
[] = {
1795 { OPT_NAME
, 'n', "name", true },
1796 { OPT_MAX_SIZE
, 'm', "max-size", true },
1797 { OPT_CTRL_URL
, '\0', "ctrl-url", true },
1798 { OPT_DATA_URL
, '\0', "data-url", true },
1799 { OPT_URL
, '\0', "url", true },
1800 { OPT_PATH
, '\0', "path", true },
1801 { OPT_RATE_POLICY
, '\0', "rate-policy", true },
1802 ARGPAR_OPT_DESCR_SENTINEL
1806 struct lttng_action
*handle_action_snapshot_session(int *argc
,
1807 const char ***argv
, int argc_offset
)
1809 struct lttng_action
*action
= NULL
;
1810 struct argpar_iter
*argpar_iter
= NULL
;
1811 const struct argpar_item
*argpar_item
= NULL
;
1812 const char *session_name_arg
= NULL
;
1813 char *snapshot_name_arg
= NULL
;
1814 char *ctrl_url_arg
= NULL
;
1815 char *data_url_arg
= NULL
;
1816 char *max_size_arg
= NULL
;
1817 char *url_arg
= NULL
;
1818 char *path_arg
= NULL
;
1820 enum lttng_action_status action_status
;
1821 struct lttng_snapshot_output
*snapshot_output
= NULL
;
1822 struct lttng_rate_policy
*policy
= NULL
;
1824 unsigned int locations_specified
= 0;
1826 argpar_iter
= argpar_iter_create(*argc
, *argv
, snapshot_action_opt_descrs
);
1828 ERR("Failed to allocate an argpar iter.");
1833 enum parse_next_item_status status
;
1835 status
= parse_next_item(argpar_iter
, &argpar_item
, argc_offset
,
1836 *argv
, false, NULL
, "While parsing `snapshot` action:");
1837 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1838 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1840 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1844 LTTNG_ASSERT(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1846 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1847 const struct argpar_opt_descr
*descr
=
1848 argpar_item_opt_descr(argpar_item
);
1849 const char *arg
= argpar_item_opt_arg(argpar_item
);
1851 switch (descr
->id
) {
1853 if (!assign_string(&snapshot_name_arg
, arg
, "--name/-n")) {
1859 if (!assign_string(&max_size_arg
, arg
, "--max-size/-m")) {
1865 if (!assign_string(&ctrl_url_arg
, arg
, "--ctrl-url")) {
1871 if (!assign_string(&data_url_arg
, arg
, "--data-url")) {
1877 if (!assign_string(&url_arg
, arg
, "--url")) {
1883 if (!assign_string(&path_arg
, arg
, "--path")) {
1888 case OPT_RATE_POLICY
:
1890 policy
= parse_rate_policy(arg
);
1900 const char *arg
= argpar_item_non_opt_arg(argpar_item
);
1901 const unsigned int idx
= argpar_item_non_opt_non_opt_index(argpar_item
);
1905 session_name_arg
= arg
;
1908 ERR("Unexpected argument `%s`.", arg
);
1914 *argc
-= argpar_iter_ingested_orig_args(argpar_iter
);
1915 *argv
+= argpar_iter_ingested_orig_args(argpar_iter
);
1917 if (!session_name_arg
) {
1918 ERR("Missing session name.");
1922 /* --ctrl-url and --data-url must come in pair. */
1923 if (ctrl_url_arg
&& !data_url_arg
) {
1924 ERR("--ctrl-url is specified, but --data-url is missing.");
1928 if (!ctrl_url_arg
&& data_url_arg
) {
1929 ERR("--data-url is specified, but --ctrl-url is missing.");
1933 locations_specified
+= !!(ctrl_url_arg
|| data_url_arg
);
1934 locations_specified
+= !!url_arg
;
1935 locations_specified
+= !!path_arg
;
1937 /* --ctrl-url/--data-url, --url and --path are mutually exclusive. */
1938 if (locations_specified
> 1) {
1939 ERR("The --ctrl-url/--data-url, --url, and --path options can't be used together.");
1944 * Did the user specify an option that implies using a
1945 * custom/unregistered output?
1947 if (url_arg
|| ctrl_url_arg
|| path_arg
) {
1948 snapshot_output
= lttng_snapshot_output_create();
1949 if (!snapshot_output
) {
1950 ERR("Failed to allocate a snapshot output.");
1955 action
= lttng_action_snapshot_session_create();
1957 ERR("Failed to allocate snapshot session action.");
1961 action_status
= lttng_action_snapshot_session_set_session_name(
1962 action
, session_name_arg
);
1963 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
1964 ERR("Failed to set action snapshot session's session name to '%s'.",
1969 if (snapshot_name_arg
) {
1970 if (!snapshot_output
) {
1971 ERR("Can't provide a snapshot output name without a snapshot output destination.");
1975 ret
= lttng_snapshot_output_set_name(
1976 snapshot_name_arg
, snapshot_output
);
1978 ERR("Failed to set name of snapshot output.");
1986 if (!snapshot_output
) {
1987 ERR("Can't provide a snapshot output max size without a snapshot output destination.");
1991 ret
= utils_parse_size_suffix(max_size_arg
, &max_size
);
1993 ERR("Failed to parse `%s` as a size.", max_size_arg
);
1997 ret
= lttng_snapshot_output_set_size(max_size
, snapshot_output
);
1999 ERR("Failed to set snapshot output's max size to %" PRIu64
" bytes.",
2007 struct lttng_uri
*uris
;
2009 if (!strstr(url_arg
, "://")) {
2010 ERR("Failed to parse '%s' as an URL.", url_arg
);
2014 num_uris
= uri_parse_str_urls(url_arg
, NULL
, &uris
);
2016 ERR("Failed to parse '%s' as an URL.", url_arg
);
2020 if (uris
[0].dtype
== LTTNG_DST_PATH
) {
2021 ret
= lttng_snapshot_output_set_local_path(
2022 uris
[0].dst
.path
, snapshot_output
);
2025 ERR("Failed to assign '%s' as a local destination.",
2030 ret
= lttng_snapshot_output_set_network_url(
2031 url_arg
, snapshot_output
);
2034 ERR("Failed to assign '%s' as a network URL.",
2042 ret
= lttng_snapshot_output_set_local_path(
2043 path_arg
, snapshot_output
);
2045 ERR("Failed to parse '%s' as a local path.", path_arg
);
2052 * Two argument form, network output with separate control and
2055 ret
= lttng_snapshot_output_set_network_urls(
2056 ctrl_url_arg
, data_url_arg
, snapshot_output
);
2058 ERR("Failed to parse `%s` and `%s` as control and data URLs.",
2059 ctrl_url_arg
, data_url_arg
);
2064 if (snapshot_output
) {
2065 action_status
= lttng_action_snapshot_session_set_output(
2066 action
, snapshot_output
);
2067 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
2068 ERR("Failed to set snapshot session action's output.");
2072 /* Ownership of `snapshot_output` has been transferred to the action. */
2073 snapshot_output
= NULL
;
2077 enum lttng_action_status status
;
2078 status
= lttng_action_snapshot_session_set_rate_policy(
2080 if (status
!= LTTNG_ACTION_STATUS_OK
) {
2081 ERR("Failed to set rate policy");
2089 lttng_action_destroy(action
);
2093 free(snapshot_name_arg
);
2098 free(snapshot_output
);
2100 lttng_rate_policy_destroy(policy
);
2101 argpar_item_destroy(argpar_item
);
2102 argpar_iter_destroy(argpar_iter
);
2107 struct action_descr
{
2109 struct lttng_action
*(*handler
) (int *argc
, const char ***argv
,
2115 struct action_descr action_descrs
[] = {
2116 { "notify", handle_action_notify
},
2117 { "start-session", handle_action_start_session
},
2118 { "stop-session", handle_action_stop_session
},
2119 { "rotate-session", handle_action_rotate_session
},
2120 { "snapshot-session", handle_action_snapshot_session
},
2124 void print_valid_action_names(void)
2128 ERR("Valid action names are:");
2130 for (i
= 0; i
< ARRAY_SIZE(condition_descrs
); ++i
) {
2131 ERR(" %s", action_descrs
[i
].name
);
2136 struct lttng_action
*parse_action(const char *action_name
, int *argc
,
2137 const char ***argv
, int argc_offset
, int orig_arg_index
,
2138 const char *orig_arg
)
2141 struct lttng_action
*action
;
2142 const struct action_descr
*descr
= NULL
;
2144 for (i
= 0; i
< ARRAY_SIZE(action_descrs
); i
++) {
2145 if (strcmp(action_name
, action_descrs
[i
].name
) == 0) {
2146 descr
= &action_descrs
[i
];
2152 ERR(WHILE_PARSING_ARG_N_ARG_FMT
"Unknown action name '%s'",
2153 orig_arg_index
+ 1, orig_arg
, action_name
);
2154 print_valid_action_names();
2158 action
= descr
->handler(argc
, argv
, argc_offset
);
2160 /* The handler has already printed an error message. */
2172 struct argpar_opt_descr add_trigger_options
[] = {
2173 { OPT_HELP
, 'h', "help", false },
2174 { OPT_LIST_OPTIONS
, '\0', "list-options", false },
2175 { OPT_CONDITION
, '\0', "condition", true },
2176 { OPT_ACTION
, '\0', "action", true },
2177 { OPT_NAME
, '\0', "name", true },
2178 { OPT_OWNER_UID
, '\0', "owner-uid", true },
2179 ARGPAR_OPT_DESCR_SENTINEL
,
2183 void lttng_actions_destructor(void *p
)
2185 struct lttng_action
*action
= (lttng_action
*) p
;
2187 lttng_action_destroy(action
);
2190 int cmd_add_trigger(int argc
, const char **argv
)
2193 int my_argc
= argc
- 1;
2194 const char **my_argv
= argv
+ 1;
2195 struct lttng_condition
*condition
= NULL
;
2196 struct lttng_dynamic_pointer_array actions
;
2197 struct argpar_iter
*argpar_iter
= NULL
;
2198 const struct argpar_item
*argpar_item
= NULL
;
2199 const struct argpar_error
*argpar_error
= NULL
;
2200 struct lttng_action
*action_list
= NULL
;
2201 struct lttng_action
*action
= NULL
;
2202 struct lttng_trigger
*trigger
= NULL
;
2205 char *owner_uid
= NULL
;
2206 enum lttng_error_code ret_code
;
2207 struct mi_writer
*mi_writer
= NULL
;
2209 lttng_dynamic_pointer_array_init(&actions
, lttng_actions_destructor
);
2212 mi_writer
= mi_lttng_writer_create(
2213 fileno(stdout
), lttng_opt_mi
);
2219 /* Open command element. */
2220 ret
= mi_lttng_writer_command_open(mi_writer
,
2221 mi_lttng_element_command_add_trigger
);
2227 /* Open output element. */
2228 ret
= mi_lttng_writer_open_element(
2229 mi_writer
, mi_lttng_element_command_output
);
2237 enum parse_next_item_status status
;
2239 const struct argpar_opt_descr
*descr
;
2242 argpar_iter_destroy(argpar_iter
);
2243 argpar_iter
= argpar_iter_create(my_argc
, my_argv
,
2244 add_trigger_options
);
2246 ERR("Failed to create argpar iter.");
2250 status
= parse_next_item(argpar_iter
, &argpar_item
,
2251 argc
- my_argc
, my_argv
, true, &argpar_error
, NULL
);
2252 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
) {
2254 if (argpar_error_type(argpar_error
) ==
2255 ARGPAR_ERROR_TYPE_MISSING_OPT_ARG
) {
2256 int opt_id
= argpar_error_opt_descr(argpar_error
, NULL
)->id
;
2258 if (opt_id
== OPT_CONDITION
) {
2259 print_valid_condition_names();
2260 } else if (opt_id
== OPT_ACTION
) {
2261 print_valid_action_names();
2266 } else if (status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
2268 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
2272 LTTNG_ASSERT(status
== PARSE_NEXT_ITEM_STATUS_OK
);
2274 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_NON_OPT
) {
2275 ERR("Unexpected argument `%s`.",
2276 argpar_item_non_opt_arg(argpar_item
));
2280 ingested_args
= argpar_iter_ingested_orig_args(argpar_iter
);
2282 my_argc
-= ingested_args
;
2283 my_argv
+= ingested_args
;
2285 descr
= argpar_item_opt_descr(argpar_item
);
2286 arg
= argpar_item_opt_arg(argpar_item
);
2288 switch (descr
->id
) {
2293 case OPT_LIST_OPTIONS
:
2294 list_cmd_options_argpar(stdout
, add_trigger_options
);
2300 ERR("A --condition was already given.");
2304 condition
= parse_condition(arg
, &my_argc
, &my_argv
,
2305 argc
- my_argc
, argc
- my_argc
- ingested_args
,
2306 my_argv
[-ingested_args
]);
2309 * An error message was already printed by
2319 action
= parse_action(arg
, &my_argc
, &my_argv
,
2320 argc
- my_argc
, argc
- my_argc
- ingested_args
,
2321 my_argv
[-ingested_args
]);
2324 * An error message was already printed by
2330 ret
= lttng_dynamic_pointer_array_add_pointer(
2333 ERR("Failed to add pointer to pointer array.");
2337 /* Ownership of the action was transferred to the list. */
2344 if (!assign_string(&name
, arg
, "--name")) {
2352 if (!assign_string(&owner_uid
, arg
,
2365 ERR("Missing --condition.");
2369 if (lttng_dynamic_pointer_array_get_count(&actions
) == 0) {
2370 ERR("Need at least one --action.");
2374 action_list
= lttng_action_list_create();
2379 for (i
= 0; i
< lttng_dynamic_pointer_array_get_count(&actions
); i
++) {
2380 enum lttng_action_status status
;
2382 action
= (lttng_action
*) lttng_dynamic_pointer_array_steal_pointer(&actions
, i
);
2384 status
= lttng_action_list_add_action(action_list
, action
);
2385 if (status
!= LTTNG_ACTION_STATUS_OK
) {
2390 * The `lttng_action_list_add_action()` takes a reference to
2391 * the action. We can destroy ours.
2393 lttng_action_destroy(action
);
2397 trigger
= lttng_trigger_create(condition
, action_list
);
2403 enum lttng_trigger_status trigger_status
;
2408 uid
= strtol(owner_uid
, &end
, 10);
2409 if (end
== owner_uid
|| *end
!= '\0' || errno
!= 0) {
2410 ERR("Failed to parse `%s` as a user id.", owner_uid
);
2414 trigger_status
= lttng_trigger_set_owner_uid(trigger
, uid
);
2415 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
2416 ERR("Failed to set trigger's user identity.");
2422 ret_code
= lttng_register_trigger_with_name(trigger
, name
);
2424 ret_code
= lttng_register_trigger_with_automatic_name(trigger
);
2427 if (ret_code
!= LTTNG_OK
) {
2428 ERR("Failed to register trigger: %s.",
2429 lttng_strerror(-ret_code
));
2434 ret_code
= lttng_trigger_mi_serialize(trigger
, mi_writer
, NULL
);
2435 if (ret_code
!= LTTNG_OK
) {
2439 const char *returned_trigger_name
;
2440 const enum lttng_trigger_status trigger_status
=
2441 lttng_trigger_get_name(trigger
,
2442 &returned_trigger_name
);
2444 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
2445 WARN("Failed to retrieve the added trigger's name.");
2447 MSG("Added trigger `%s`.", returned_trigger_name
);
2460 if (lttng_opt_mi
&& mi_writer
) {
2463 /* Close output element. */
2464 mi_ret
= mi_lttng_writer_close_element(mi_writer
);
2470 mi_ret
= mi_lttng_writer_write_element_bool(mi_writer
,
2471 mi_lttng_element_command_success
, ret
? 0 : 1);
2477 /* Command element close. */
2478 mi_ret
= mi_lttng_writer_command_close(mi_writer
);
2486 argpar_error_destroy(argpar_error
);
2487 argpar_iter_destroy(argpar_iter
);
2488 argpar_item_destroy(argpar_item
);
2489 lttng_dynamic_pointer_array_reset(&actions
);
2490 lttng_condition_destroy(condition
);
2491 lttng_action_destroy(action_list
);
2492 lttng_action_destroy(action
);
2493 lttng_trigger_destroy(trigger
);
2496 if (mi_writer
&& mi_lttng_writer_destroy(mi_writer
)) {
2497 /* Preserve original error code. */
2498 ret
= ret
? ret
: CMD_ERROR
;