X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fadd_trigger.c;h=c1926b4d61d7bd7a145fd5a3c678c627abe35032;hb=b448ef3c46885b2e713b1fda0b53134d01bb6301;hp=1cb35adc7a6ac6ff3faa7496ef83e80b0d1f16ec;hpb=bc16a30da2af295c9bd3d07e163b24e7c96c40c6;p=lttng-tools.git diff --git a/src/bin/lttng/commands/add_trigger.c b/src/bin/lttng/commands/add_trigger.c index 1cb35adc7..c1926b4d6 100644 --- a/src/bin/lttng/commands/add_trigger.c +++ b/src/bin/lttng/commands/add_trigger.c @@ -8,15 +8,19 @@ #include #include #include +#include #include "../command.h" #include "../loglevel.h" #include "../uprobe.h" #include "common/argpar/argpar.h" +#include "common/argpar-utils/argpar-utils.h" #include "common/dynamic-array.h" +#include "common/mi-lttng.h" #include "common/string-utils/string-utils.h" #include "common/utils.h" +#include /* For lttng_event_rule_type_str(). */ #include #include @@ -50,7 +54,6 @@ enum { OPT_EVENT_NAME, OPT_LOG_LEVEL, - OPT_DOMAIN, OPT_TYPE, OPT_LOCATION, @@ -70,7 +73,6 @@ static const struct argpar_opt_descr event_rule_opt_descrs[] = { { OPT_LOG_LEVEL, 'l', "log-level", true }, { OPT_EVENT_NAME, 'E', "event-name", true }, - { OPT_DOMAIN, 'd', "domain", true }, { OPT_TYPE, 't', "type", true }, { OPT_LOCATION, 'L', "location", true }, @@ -81,38 +83,27 @@ static const struct argpar_opt_descr event_rule_opt_descrs[] = { }; static -bool assign_domain_type(enum lttng_domain_type *dest, const char *arg) +bool has_syscall_prefix(const char *arg) { - bool ret; - - if (*dest != LTTNG_DOMAIN_NONE) { - ERR("More than one `--domain` was specified."); - goto error; - } - - if (strcmp(arg, "kernel") == 0) { - *dest = LTTNG_DOMAIN_KERNEL; - } else if (strcmp(arg, "user") == 0 || strcmp(arg, "userspace") == 0) { - *dest = LTTNG_DOMAIN_UST; - } else if (strcmp(arg, "jul") == 0) { - *dest = LTTNG_DOMAIN_JUL; - } else if (strcmp(arg, "log4j") == 0) { - *dest = LTTNG_DOMAIN_LOG4J; - } else if (strcmp(arg, "python") == 0) { - *dest = LTTNG_DOMAIN_PYTHON; + bool matches = false; + const char kernel_syscall_type_opt_prefix[] = "kernel:syscall"; + const size_t kernel_syscall_type_opt_prefix_len = + sizeof(kernel_syscall_type_opt_prefix) - 1; + const char syscall_type_opt_prefix[] = "syscall"; + const size_t syscall_type_opt_prefix_len = + sizeof(syscall_type_opt_prefix) - 1; + + if (strncmp(arg, syscall_type_opt_prefix, + syscall_type_opt_prefix_len) == 0) { + matches = true; + } else if (strncmp(arg, kernel_syscall_type_opt_prefix, + kernel_syscall_type_opt_prefix_len) == 0) { + matches = true; } else { - ERR("Invalid `--domain` value: %s", arg); - goto error; + matches = false; } - ret = true; - goto end; - -error: - ret = false; - -end: - return ret; + return matches; } static @@ -125,17 +116,25 @@ bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) goto error; } - if (strcmp(arg, "tracepoint") == 0 || strcmp(arg, "logging") == 0) { - *dest = LTTNG_EVENT_RULE_TYPE_TRACEPOINT; + if (strcmp(arg, "user") == 0 || strcmp(arg, "user:tracepoint") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT; + } else if (strcmp(arg, "kernel") == 0 || + strcmp(arg, "kernel:tracepoint") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT; + } else if (strcmp(arg, "jul") == 0 || strcmp(arg, "jul:logging") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_JUL_LOGGING; + } else if (strcmp(arg, "log4j") == 0 || + strcmp(arg, "log4j:logging") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING; + } else if (strcmp(arg, "python") == 0 || + strcmp(arg, "python:logging") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING; } else if (strcmp(arg, "kprobe") == 0 || - strcmp(arg, "kernel-probe") == 0) { - *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE; - } else if (strcmp(arg, "uprobe") == 0 || - strcmp(arg, "userspace-probe") == 0) { - *dest = LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE; - } else if (strcmp(arg, "function") == 0) { - *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION; - } else if (strncmp(arg, "syscall", strlen("syscall")) == 0) { + strcmp(arg, "kernel:kprobe") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE; + } else if (strcmp(arg, "kernel:uprobe") == 0) { + *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE; + } else if (has_syscall_prefix(arg)) { /* * Matches the following: * - syscall @@ -143,10 +142,15 @@ bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) * - syscall:exit * - syscall:entry+exit * - syscall:* + * - kernel:syscall + * - kernel:syscall:entry + * - kernel:syscall:exit + * - kernel:syscall:entry+exit + * - kernel:syscall:* * * Validation for the right side is left to further usage sites. */ - *dest = LTTNG_EVENT_RULE_TYPE_SYSCALL; + *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL; } else { ERR("Invalid `--type` value: %s", arg); goto error; @@ -189,16 +193,27 @@ end: } static bool parse_syscall_emission_site_from_type(const char *str, - enum lttng_event_rule_syscall_emission_site *type) + enum lttng_event_rule_kernel_syscall_emission_site *type) { bool ret = false; + const char kernel_prefix[] = "kernel:"; + const size_t kernel_prefix_len = sizeof(kernel_prefix) - 1; + + /* + * If the passed string is of the form "kernel:syscall*", move the + * pointer passed "kernel:". + */ + if (strncmp(str, kernel_prefix, kernel_prefix_len) == 0) { + str = &str[kernel_prefix_len]; + } + if (strcmp(str, "syscall") == 0 || strcmp(str, "syscall:entry+exit") == 0) { - *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT; + *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT; } else if (strcmp(str, "syscall:entry") == 0) { - *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY; + *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY; } else if (strcmp(str, "syscall:exit") == 0) { - *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT; + *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT; } else { goto error; } @@ -210,7 +225,7 @@ error: } /* - * Parse `str` as a log level in domain `domain_type`. + * Parse `str` as a log level against the passed event rule type. * * Return the log level in `*log_level`. Return true in `*log_level_only` if * the string specifies exactly this log level, false if it specifies at least @@ -219,14 +234,14 @@ error: * Return true if the string was successfully parsed as a log level string. */ static bool parse_log_level_string(const char *str, - enum lttng_domain_type domain_type, + enum lttng_event_rule_type event_rule_type, int *log_level, bool *log_level_only) { bool ret; - switch (domain_type) { - case LTTNG_DOMAIN_UST: + switch (event_rule_type) { + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: { enum lttng_loglevel log_level_min, log_level_max; if (!loglevel_parse_range_string( @@ -244,7 +259,7 @@ static bool parse_log_level_string(const char *str, *log_level_only = log_level_min == log_level_max; break; } - case LTTNG_DOMAIN_LOG4J: + case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: { enum lttng_loglevel_log4j log_level_min, log_level_max; if (!loglevel_log4j_parse_range_string( @@ -262,7 +277,7 @@ static bool parse_log_level_string(const char *str, *log_level_only = log_level_min == log_level_max; break; } - case LTTNG_DOMAIN_JUL: + case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: { enum lttng_loglevel_jul log_level_min, log_level_max; if (!loglevel_jul_parse_range_string( @@ -280,7 +295,7 @@ static bool parse_log_level_string(const char *str, *log_level_only = log_level_min == log_level_max; break; } - case LTTNG_DOMAIN_PYTHON: + case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: { enum lttng_loglevel_python log_level_min, log_level_max; if (!loglevel_python_parse_range_string( @@ -340,7 +355,7 @@ static int parse_kernel_probe_opts(const char *source, PERROR("Failed to copy kernel probe location symbol name."); goto error; } - offset = strtoul(s_hex, NULL, 0); + offset = strtoull(s_hex, NULL, 0); *location = lttng_kernel_probe_location_symbol_create( symbol_name, offset); @@ -386,7 +401,7 @@ static int parse_kernel_probe_opts(const char *source, goto error; } - address = strtoul(s_hex, NULL, 0); + address = strtoull(s_hex, NULL, 0); *location = lttng_kernel_probe_location_address_create(address); if (!*location) { ERR("Failed to create symbol kernel probe location."); @@ -634,14 +649,13 @@ struct parse_event_rule_res { }; static -struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) +struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv, + int argc_offset) { - enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE; enum lttng_event_rule_type event_rule_type = LTTNG_EVENT_RULE_TYPE_UNKNOWN; - struct argpar_state *state; - struct argpar_item *item = NULL; - char *error = NULL; + struct argpar_iter *argpar_iter = NULL; + const struct argpar_item *argpar_item = NULL; int consumed_args = -1; struct lttng_kernel_probe_location *kernel_probe_location = NULL; struct lttng_userspace_probe_location *userspace_probe_location = NULL; @@ -673,82 +687,68 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) lttng_dynamic_pointer_array_init(&exclude_names, free); - state = argpar_state_create(*argc, *argv, event_rule_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + argpar_iter = argpar_iter_create(*argc, *argv, event_rule_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; + enum parse_next_item_status status; - ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_state_parse_next(state, &item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item(argpar_iter, &argpar_item, + argc_offset, *argv, false, NULL, NULL); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - /* Just stop parsing here. */ - break; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + assert(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = + argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { - /* Domains. */ - case OPT_DOMAIN: - if (!assign_domain_type(&domain_type, - item_opt->arg)) { - goto error; - } - - break; + switch (descr->id) { case OPT_TYPE: - if (!assign_event_rule_type(&event_rule_type, - item_opt->arg)) { + if (!assign_event_rule_type(&event_rule_type, arg)) { goto error; } /* Save the string for later use. */ - if (!assign_string(&event_rule_type_str, - item_opt->arg, - "--type/-t")) { + if (!assign_string(&event_rule_type_str, arg, + "--type/-t")) { goto error; } break; case OPT_LOCATION: - if (!assign_string(&location, - item_opt->arg, + if (!assign_string(&location, arg, "--location/-L")) { goto error; } break; case OPT_EVENT_NAME: - if (!assign_string(&event_name, - item_opt->arg, - "--event-name/-E")) { + if (!assign_string(&event_name, arg, + "--event-name/-E")) { goto error; } break; case OPT_FILTER: - if (!assign_string(&filter, item_opt->arg, - "--filter/-f")) { + if (!assign_string(&filter, arg, + "--filter/-f")) { goto error; } break; case OPT_NAME: - if (!assign_string(&name, item_opt->arg, - "--name/-n")) { + if (!assign_string(&name, arg, + "--name/-n")) { goto error; } @@ -759,7 +759,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) ret = lttng_dynamic_pointer_array_add_pointer( &exclude_names, - strdup(item_opt->arg)); + strdup(arg)); if (ret != 0) { ERR("Failed to add pointer to dynamic pointer array."); goto error; @@ -768,8 +768,8 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) break; } case OPT_LOG_LEVEL: - if (!assign_string(&log_level_str, - item_opt->arg, "--log-level/-l")) { + if (!assign_string(&log_level_str, arg, + "--log-level/-l")) { goto error; } @@ -777,19 +777,16 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) case OPT_CAPTURE: { int ret; - const char *capture_str = item_opt->arg; ret = filter_parser_ctx_create_from_filter_expression( - capture_str, &parser_ctx); + arg, &parser_ctx); if (ret) { - ERR("Failed to parse capture expression `%s`.", - capture_str); + ERR("Failed to parse capture expression `%s`.", arg); goto error; } event_expr = ir_op_root_to_event_expr( - parser_ctx->ir_root, - capture_str); + parser_ctx->ir_root, arg); if (!event_expr) { /* * ir_op_root_to_event_expr has printed @@ -817,28 +814,31 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) abort(); } } else { - const struct argpar_item_non_opt *item_non_opt = - (const struct argpar_item_non_opt *) - item; + const char *arg = argpar_item_non_opt_arg(argpar_item); /* Don't accept non-option arguments. */ - ERR("Unexpected argument '%s'", item_non_opt->arg); + ERR("Unexpected argument '%s'", arg); goto error; } } if (event_rule_type == LTTNG_EVENT_RULE_TYPE_UNKNOWN) { - event_rule_type = LTTNG_EVENT_RULE_TYPE_TRACEPOINT; + ERR("Event rule requires a --type."); + goto error; } /* - * Option --name is applicable to event rules of type tracepoint - * and syscall. For tracepoint and syscall rules, if --name is - * omitted, it is implicitly "*". + * Option --name is applicable to event rules of type kernel, user, jul, + * log4j,python and syscall. If --name is omitted, it is implicitly + * "*". */ switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: + case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: + case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: if (!name) { name = strdup("*"); } @@ -868,9 +868,8 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) * If omitted, it defaults to the location. */ switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: - case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: - case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION: + case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE: + case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE: if (!location) { ERR("Event rule of type %s requires a --location.", lttng_event_rule_type_str(event_rule_type)); @@ -901,45 +900,24 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) /* * Update *argc and *argv so our caller can keep parsing what follows. */ - consumed_args = argpar_state_get_ingested_orig_args(state); + consumed_args = argpar_iter_ingested_orig_args(argpar_iter); assert(consumed_args >= 0); *argc -= consumed_args; *argv += consumed_args; - /* Need to specify a domain. */ - if (domain_type == LTTNG_DOMAIN_NONE) { - ERR("Please specify a domain (--domain=(kernel,user,jul,log4j,python))."); - goto error; - } - - /* Validate event rule type against domain. */ - switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: - case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION: - case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: - case LTTNG_EVENT_RULE_TYPE_SYSCALL: - if (domain_type != LTTNG_DOMAIN_KERNEL) { - ERR("Event type not available for user-space tracing."); - goto error; - } - break; - - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: - break; - - default: - abort(); - } - /* * Adding a filter to a probe, function or userspace-probe would be * denied by the kernel tracer as it's not supported at the moment. We * do an early check here to warn the user. */ - if (filter && domain_type == LTTNG_DOMAIN_KERNEL) { + if (filter) { switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: + case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: + case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: break; default: ERR("Filter expressions are not supported for %s event rules.", @@ -948,11 +926,15 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } } - /* If --exclude-name/-x was passed, split it into an exclusion list. */ + /* + * If --exclude-name/-x was passed, split it into an exclusion list. + * Exclusions are only supported by + * LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT for now. + */ if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) { - if (domain_type != LTTNG_DOMAIN_UST) { + if (event_rule_type != LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT) { ERR("Event name exclusions are not yet implemented for %s event rules.", - get_domain_str(domain_type)); + lttng_event_rule_type_str(event_rule_type)); goto error; } @@ -966,44 +948,76 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } if (log_level_str) { - if (event_rule_type != LTTNG_EVENT_RULE_TYPE_TRACEPOINT) { - ERR("Log levels are only applicable to tracepoint event rules."); - goto error; - } + switch (event_rule_type) { + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: + case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: + case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: + { + int log_level; + bool log_level_only; - if (domain_type == LTTNG_DOMAIN_KERNEL) { - ERR("Log levels are not supported by the kernel tracer."); + if (strcmp(log_level_str, "..") == 0) { + /* + * ".." is the same as passing no log level + * option and correspond to the "ANY" case. + */ + break; + } + + if (!parse_log_level_string(log_level_str, event_rule_type, + &log_level, &log_level_only)) { + ERR("Failed to parse log level string `%s`.", + log_level_str); + goto error; + } + + if (log_level_only) { + log_level_rule = lttng_log_level_rule_exactly_create(log_level); + } else { + log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(log_level); + } + + if (log_level_rule == NULL) { + ERR("Failed to create log level rule object."); + goto error; + } + break; + } + default: + ERR("Log levels are not supported for %s event rules.", + lttng_event_rule_type_str(event_rule_type)); goto error; } } /* Finally, create the event rule object. */ switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: { enum lttng_event_rule_status event_rule_status; - res.er = lttng_event_rule_tracepoint_create(domain_type); + res.er = lttng_event_rule_user_tracepoint_create(); if (!res.er) { - ERR("Failed to create tracepoint event rule."); + ERR("Failed to create user_tracepoint event rule."); goto error; } /* Set pattern. */ - event_rule_status = lttng_event_rule_tracepoint_set_name_pattern( + event_rule_status = lttng_event_rule_user_tracepoint_set_name_pattern( res.er, name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set tracepoint event rule's pattern to '%s'.", + ERR("Failed to set user_tracepoint event rule's pattern to '%s'.", name); goto error; } /* Set filter. */ if (filter) { - event_rule_status = lttng_event_rule_tracepoint_set_filter( + event_rule_status = lttng_event_rule_user_tracepoint_set_filter( res.er, filter); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set tracepoint event rule's filter to '%s'.", + ERR("Failed to set user_tracepoint event rule's filter to '%s'.", filter); goto error; } @@ -1022,46 +1036,95 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) n); event_rule_status = - lttng_event_rule_tracepoint_add_name_pattern_exclusion( + lttng_event_rule_user_tracepoint_add_name_pattern_exclusion( res.er, exclude_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set tracepoint exclusion list element '%s'", + ERR("Failed to set user_tracepoint exclusion list element '%s'", exclude_name); goto error; } } } - /* - * ".." is the same as passing no log level option and - * correspond the the "ANY" case. - */ - if (log_level_str && strcmp(log_level_str, "..") != 0) { - int log_level; - bool log_level_only; + if (log_level_rule) { + event_rule_status = + lttng_event_rule_user_tracepoint_set_log_level_rule( + res.er, log_level_rule); - if (!parse_log_level_string(log_level_str, domain_type, - &log_level, &log_level_only)) { - ERR("Failed to parse log level string `%s`.", - log_level_str); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set log level on event fule."); goto error; } + } - if (log_level_only) { - log_level_rule = lttng_log_level_rule_exactly_create(log_level); - } else { - log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(log_level); + break; + } + case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT: + { + enum lttng_event_rule_status event_rule_status; + + res.er = lttng_event_rule_kernel_tracepoint_create(); + if (!res.er) { + ERR("Failed to create kernel_tracepoint event rule."); + goto error; + } + + /* Set pattern. */ + event_rule_status = lttng_event_rule_kernel_tracepoint_set_name_pattern( + res.er, name); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set kernel_tracepoint event rule's pattern to '%s'.", + name); + goto error; + } + + /* Set filter. */ + if (filter) { + event_rule_status = lttng_event_rule_kernel_tracepoint_set_filter( + res.er, filter); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set kernel_tracepoint event rule's filter to '%s'.", + filter); + goto error; } + } + break; + } + case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: + { + enum lttng_event_rule_status event_rule_status; - if (log_level_rule == NULL) { - ERR("Failed to create log level rule object."); + res.er = lttng_event_rule_jul_logging_create(); + if (!res.er) { + ERR("Failed to create jul_logging event rule."); + goto error; + } + + /* Set pattern. */ + event_rule_status = lttng_event_rule_jul_logging_set_name_pattern( + res.er, name); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's pattern to '%s'.", + name); + goto error; + } + + /* Set filter. */ + if (filter) { + event_rule_status = lttng_event_rule_jul_logging_set_filter( + res.er, filter); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's filter to '%s'.", + filter); goto error; } + } + if (log_level_rule) { event_rule_status = - lttng_event_rule_tracepoint_set_log_level_rule( + lttng_event_rule_jul_logging_set_log_level_rule( res.er, log_level_rule); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { @@ -1069,10 +1132,93 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } } + break; + } + case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: + { + enum lttng_event_rule_status event_rule_status; + + res.er = lttng_event_rule_log4j_logging_create(); + if (!res.er) { + ERR("Failed to create jul_logging event rule."); + goto error; + } + + /* Set pattern. */ + event_rule_status = lttng_event_rule_log4j_logging_set_name_pattern( + res.er, name); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's pattern to '%s'.", + name); + goto error; + } + + /* Set filter. */ + if (filter) { + event_rule_status = lttng_event_rule_log4j_logging_set_filter( + res.er, filter); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's filter to '%s'.", + filter); + goto error; + } + } + + if (log_level_rule) { + event_rule_status = + lttng_event_rule_log4j_logging_set_log_level_rule( + res.er, log_level_rule); + + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set log level on event fule."); + goto error; + } + } + break; + } + case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: + { + enum lttng_event_rule_status event_rule_status; + + res.er = lttng_event_rule_python_logging_create(); + if (!res.er) { + ERR("Failed to create jul_logging event rule."); + goto error; + } + + /* Set pattern. */ + event_rule_status = lttng_event_rule_python_logging_set_name_pattern( + res.er, name); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's pattern to '%s'.", + name); + goto error; + } + /* Set filter. */ + if (filter) { + event_rule_status = lttng_event_rule_python_logging_set_filter( + res.er, filter); + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set jul_logging event rule's filter to '%s'.", + filter); + goto error; + } + } + + if (log_level_rule) { + event_rule_status = + lttng_event_rule_python_logging_set_log_level_rule( + res.er, log_level_rule); + + if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { + ERR("Failed to set log level on event fule."); + goto error; + } + } break; } - case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: + case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE: { int ret; enum lttng_event_rule_status event_rule_status; @@ -1085,14 +1231,14 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } assert(kernel_probe_location); - res.er = lttng_event_rule_kernel_probe_create(kernel_probe_location); + res.er = lttng_event_rule_kernel_kprobe_create(kernel_probe_location); if (!res.er) { ERR("Failed to create kprobe event rule."); goto error; } event_rule_status = - lttng_event_rule_kernel_probe_set_event_name( + lttng_event_rule_kernel_kprobe_set_event_name( res.er, event_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set kprobe event rule's name to '%s'.", @@ -1102,7 +1248,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) break; } - case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: + case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE: { int ret; enum lttng_event_rule_status event_rule_status; @@ -1114,14 +1260,14 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - res.er = lttng_event_rule_userspace_probe_create(userspace_probe_location); + res.er = lttng_event_rule_kernel_uprobe_create(userspace_probe_location); if (!res.er) { ERR("Failed to create userspace probe event rule."); goto error; } event_rule_status = - lttng_event_rule_userspace_probe_set_event_name( + lttng_event_rule_kernel_uprobe_set_event_name( res.er, event_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set user space probe event rule's name to '%s'.", @@ -1131,10 +1277,10 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) break; } - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: { enum lttng_event_rule_status event_rule_status; - enum lttng_event_rule_syscall_emission_site emission_site; + enum lttng_event_rule_kernel_syscall_emission_site emission_site; if (!parse_syscall_emission_site_from_type( event_rule_type_str, &emission_site)) { @@ -1142,13 +1288,13 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - res.er = lttng_event_rule_syscall_create(emission_site); + res.er = lttng_event_rule_kernel_syscall_create(emission_site); if (!res.er) { ERR("Failed to create syscall event rule."); goto error; } - event_rule_status = lttng_event_rule_syscall_set_name_pattern( + event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern( res.er, name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set syscall event rule's pattern to '%s'.", @@ -1157,7 +1303,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } if (filter) { - event_rule_status = lttng_event_rule_syscall_set_filter( + event_rule_status = lttng_event_rule_kernel_syscall_set_filter( res.er, filter); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set syscall event rule's filter to '%s'.", @@ -1186,9 +1332,8 @@ end: } lttng_event_expr_destroy(event_expr); - argpar_item_destroy(item); - free(error); - argpar_state_destroy(state); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); free(filter); free(name); lttng_dynamic_pointer_array_reset(&exclude_names); @@ -1204,13 +1349,14 @@ end: } static -struct lttng_condition *handle_condition_event(int *argc, const char ***argv) +struct lttng_condition *handle_condition_event(int *argc, const char ***argv, + int argc_offset) { struct parse_event_rule_res res; struct lttng_condition *c; size_t i; - res = parse_event_rule(argc, argv); + res = parse_event_rule(argc, argv, argc_offset); if (!res.er) { c = NULL; goto error; @@ -1260,7 +1406,8 @@ end: struct condition_descr { const char *name; - struct lttng_condition *(*handler) (int *argc, const char ***argv); + struct lttng_condition *(*handler) (int *argc, const char ***argv, + int argc_offset); }; static const @@ -1268,9 +1415,22 @@ struct condition_descr condition_descrs[] = { { "event-rule-matches", handle_condition_event }, }; +static +void print_valid_condition_names(void) +{ + unsigned int i; + + ERR("Valid condition names are:"); + + for (i = 0; i < ARRAY_SIZE(condition_descrs); ++i) { + ERR(" %s", condition_descrs[i].name); + } +} + static struct lttng_condition *parse_condition(const char *condition_name, int *argc, - const char ***argv) + const char ***argv, int argc_offset, int orig_arg_index, + const char *orig_arg) { int i; struct lttng_condition *cond; @@ -1284,11 +1444,13 @@ struct lttng_condition *parse_condition(const char *condition_name, int *argc, } if (!descr) { - ERR("Unknown condition name '%s'", condition_name); + ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown condition name '%s'", + orig_arg_index + 1, orig_arg, condition_name); + print_valid_condition_names(); goto error; } - cond = descr->handler(argc, argv); + cond = descr->handler(argc, argv, argc_offset); if (!cond) { /* The handler has already printed an error message. */ goto error; @@ -1381,45 +1543,44 @@ static const struct argpar_opt_descr notify_action_opt_descrs[] = { }; static -struct lttng_action *handle_action_notify(int *argc, const char ***argv) +struct lttng_action *handle_action_notify(int *argc, const char ***argv, + int argc_offset) { struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; - char *error = NULL; + struct argpar_iter *argpar_iter = NULL; + const struct argpar_item *argpar_item = NULL; struct lttng_rate_policy *policy = NULL; - state = argpar_state_create(*argc, *argv, notify_action_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + argpar_iter = argpar_iter_create(*argc, *argv, notify_action_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; + enum parse_next_item_status status; - ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_state_parse_next(state, &item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item(argpar_iter, &argpar_item, + argc_offset, *argv, false, NULL, + "While parsing `notify` action:"); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - /* Just stop parsing here. */ - break; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + assert(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = + argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1429,23 +1590,15 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; - - assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT); - - item_non_opt = (const struct argpar_item_non_opt *) item; + const char *arg = argpar_item_non_opt_arg(argpar_item); - switch (item_non_opt->non_opt_index) { - default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); - goto error; - } + ERR("Unexpected argument `%s`.", arg); + goto error; } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); action = lttng_action_notify_create(); if (!action) { @@ -1468,10 +1621,9 @@ error: lttng_action_destroy(action); action = NULL; end: - free(error); lttng_rate_policy_destroy(policy); - argpar_state_destroy(state); - argpar_item_destroy(item); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } @@ -1482,6 +1634,7 @@ end: static struct lttng_action *handle_action_simple_session_with_policy(int *argc, const char ***argv, + int argc_offset, struct lttng_action *(*create_action_cb)(void), enum lttng_action_status (*set_session_name_cb)( struct lttng_action *, const char *), @@ -1491,10 +1644,9 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, const char *action_name) { struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; + struct argpar_iter *argpar_iter = NULL; + const struct argpar_item *argpar_item = NULL; const char *session_name_arg = NULL; - char *error = NULL; enum lttng_action_status action_status; struct lttng_rate_policy *policy = NULL; @@ -1506,37 +1658,36 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, ARGPAR_OPT_DESCR_SENTINEL }; - state = argpar_state_create(*argc, *argv, rate_policy_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + argpar_iter = argpar_iter_create(*argc, *argv, rate_policy_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; + enum parse_next_item_status status; - ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_state_parse_next(state, &item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item(argpar_iter, &argpar_item, argc_offset, + *argv, false, NULL, + "While parsing `%s` action:", action_name); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == - ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - /* Just stop parsing here. */ - break; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + assert(status == PARSE_NEXT_ITEM_STATUS_OK); + + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = + argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1546,23 +1697,22 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; - item_non_opt = (const struct argpar_item_non_opt *) item; + const char *arg = argpar_item_non_opt_arg(argpar_item); + unsigned int idx = argpar_item_non_opt_non_opt_index(argpar_item); - switch (item_non_opt->non_opt_index) { + switch (idx) { case 0: - session_name_arg = item_non_opt->arg; + session_name_arg = arg; break; default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); + ERR("Unexpected argument `%s`.", arg); goto error; } } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); if (!session_name_arg) { ERR("Missing session name."); @@ -1595,19 +1745,20 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, error: lttng_action_destroy(action); action = NULL; - argpar_item_destroy(item); + end: lttng_rate_policy_destroy(policy); - free(error); - argpar_state_destroy(state); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } static struct lttng_action *handle_action_start_session(int *argc, - const char ***argv) + const char ***argv, int argc_offset) { return handle_action_simple_session_with_policy(argc, argv, + argc_offset, lttng_action_start_session_create, lttng_action_start_session_set_session_name, lttng_action_start_session_set_rate_policy, "start"); @@ -1615,9 +1766,10 @@ struct lttng_action *handle_action_start_session(int *argc, static struct lttng_action *handle_action_stop_session(int *argc, - const char ***argv) + const char ***argv, int argc_offset) { return handle_action_simple_session_with_policy(argc, argv, + argc_offset, lttng_action_stop_session_create, lttng_action_stop_session_set_session_name, lttng_action_stop_session_set_rate_policy, "stop"); @@ -1625,9 +1777,10 @@ struct lttng_action *handle_action_stop_session(int *argc, static struct lttng_action *handle_action_rotate_session(int *argc, - const char ***argv) + const char ***argv, int argc_offset) { return handle_action_simple_session_with_policy(argc, argv, + argc_offset, lttng_action_rotate_session_create, lttng_action_rotate_session_set_session_name, lttng_action_rotate_session_set_rate_policy, @@ -1647,11 +1800,11 @@ static const struct argpar_opt_descr snapshot_action_opt_descrs[] = { static struct lttng_action *handle_action_snapshot_session(int *argc, - const char ***argv) + const char ***argv, int argc_offset) { struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; + struct argpar_iter *argpar_iter = NULL; + const struct argpar_item *argpar_item = NULL; const char *session_name_arg = NULL; char *snapshot_name_arg = NULL; char *ctrl_url_arg = NULL; @@ -1666,73 +1819,71 @@ struct lttng_action *handle_action_snapshot_session(int *argc, int ret; unsigned int locations_specified = 0; - state = argpar_state_create(*argc, *argv, snapshot_action_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + argpar_iter = argpar_iter_create(*argc, *argv, snapshot_action_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; + enum parse_next_item_status status; - ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_state_parse_next(state, &item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item(argpar_iter, &argpar_item, argc_offset, + *argv, false, NULL, "While parsing `snapshot` action:"); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - /* Just stop parsing here. */ - break; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + assert(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = + argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_NAME: - if (!assign_string(&snapshot_name_arg, item_opt->arg, "--name/-n")) { + if (!assign_string(&snapshot_name_arg, arg, "--name/-n")) { goto error; } break; case OPT_MAX_SIZE: - if (!assign_string(&max_size_arg, item_opt->arg, "--max-size/-m")) { + if (!assign_string(&max_size_arg, arg, "--max-size/-m")) { goto error; } break; case OPT_CTRL_URL: - if (!assign_string(&ctrl_url_arg, item_opt->arg, "--ctrl-url")) { + if (!assign_string(&ctrl_url_arg, arg, "--ctrl-url")) { goto error; } break; case OPT_DATA_URL: - if (!assign_string(&data_url_arg, item_opt->arg, "--data-url")) { + if (!assign_string(&data_url_arg, arg, "--data-url")) { goto error; } break; case OPT_URL: - if (!assign_string(&url_arg, item_opt->arg, "--url")) { + if (!assign_string(&url_arg, arg, "--url")) { goto error; } break; case OPT_PATH: - if (!assign_string(&path_arg, item_opt->arg, "--path")) { + if (!assign_string(&path_arg, arg, "--path")) { goto error; } break; case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1742,26 +1893,22 @@ struct lttng_action *handle_action_snapshot_session(int *argc, abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; + const char *arg = argpar_item_non_opt_arg(argpar_item); + unsigned int idx = argpar_item_non_opt_non_opt_index(argpar_item); - assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT); - - item_non_opt = (const struct argpar_item_non_opt *) item; - - switch (item_non_opt->non_opt_index) { + switch (idx) { case 0: - session_name_arg = item_non_opt->arg; + session_name_arg = arg; break; default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); + ERR("Unexpected argument `%s`.", arg); goto error; } } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); if (!session_name_arg) { ERR("Missing session name."); @@ -1947,14 +2094,15 @@ end: free(snapshot_output); free(max_size_arg); lttng_rate_policy_destroy(policy); - argpar_state_destroy(state); - argpar_item_destroy(item); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } struct action_descr { const char *name; - struct lttng_action *(*handler) (int *argc, const char ***argv); + struct lttng_action *(*handler) (int *argc, const char ***argv, + int argc_offset); }; static const @@ -1967,7 +2115,21 @@ struct action_descr action_descrs[] = { }; static -struct lttng_action *parse_action(const char *action_name, int *argc, const char ***argv) +void print_valid_action_names(void) +{ + unsigned int i; + + ERR("Valid action names are:"); + + for (i = 0; i < ARRAY_SIZE(condition_descrs); ++i) { + ERR(" %s", action_descrs[i].name); + } +} + +static +struct lttng_action *parse_action(const char *action_name, int *argc, + const char ***argv, int argc_offset, int orig_arg_index, + const char *orig_arg) { int i; struct lttng_action *action; @@ -1981,11 +2143,13 @@ struct lttng_action *parse_action(const char *action_name, int *argc, const char } if (!descr) { - ERR("Unknown action name: %s", action_name); + ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown action name '%s'", + orig_arg_index + 1, orig_arg, action_name); + print_valid_action_names(); goto error; } - action = descr->handler(argc, argv); + action = descr->handler(argc, argv, argc_offset); if (!action) { /* The handler has already printed an error message. */ goto error; @@ -2024,64 +2188,98 @@ int cmd_add_trigger(int argc, const char **argv) const char **my_argv = argv + 1; struct lttng_condition *condition = NULL; struct lttng_dynamic_pointer_array actions; - struct argpar_state *argpar_state = NULL; - struct argpar_item *argpar_item = NULL; + struct argpar_iter *argpar_iter = NULL; + const struct argpar_item *argpar_item = NULL; + const struct argpar_error *argpar_error = NULL; struct lttng_action *action_list = NULL; struct lttng_action *action = NULL; struct lttng_trigger *trigger = NULL; - char *error = NULL; char *name = NULL; int i; char *owner_uid = NULL; enum lttng_error_code ret_code; + struct mi_writer *mi_writer = NULL; lttng_dynamic_pointer_array_init(&actions, lttng_actions_destructor); + if (lttng_opt_mi) { + mi_writer = mi_lttng_writer_create( + fileno(stdout), lttng_opt_mi); + if (!mi_writer) { + ret = CMD_ERROR; + goto error; + } + + /* Open command element. */ + ret = mi_lttng_writer_command_open(mi_writer, + mi_lttng_element_command_add_trigger); + if (ret) { + ret = CMD_ERROR; + goto error; + } + + /* Open output element. */ + ret = mi_lttng_writer_open_element( + mi_writer, mi_lttng_element_command_output); + if (ret) { + ret = CMD_ERROR; + goto error; + } + } + while (true) { - enum argpar_state_parse_next_status status; - const struct argpar_item_opt *item_opt; + enum parse_next_item_status status; int ingested_args; + const struct argpar_opt_descr *descr; + const char *arg; - argpar_state_destroy(argpar_state); - argpar_state = argpar_state_create(my_argc, my_argv, + argpar_iter_destroy(argpar_iter); + argpar_iter = argpar_iter_create(my_argc, my_argv, add_trigger_options); - if (!argpar_state) { - ERR("Failed to create argpar state."); + if (!argpar_iter) { + ERR("Failed to create argpar iter."); goto error; } - ARGPAR_ITEM_DESTROY_AND_RESET(argpar_item); - status = argpar_state_parse_next(argpar_state, &argpar_item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item(argpar_iter, &argpar_item, + argc - my_argc, my_argv, true, &argpar_error, NULL); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR) { + + if (argpar_error_type(argpar_error) == + ARGPAR_ERROR_TYPE_MISSING_OPT_ARG) { + int opt_id = argpar_error_opt_descr(argpar_error, NULL)->id; + + if (opt_id == OPT_CONDITION) { + print_valid_condition_names(); + } else if (opt_id == OPT_ACTION) { + print_valid_action_names(); + } + } + goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - ERR("%s", error); + } else if (status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + assert(status == PARSE_NEXT_ITEM_STATUS_OK); - if (argpar_item->type == ARGPAR_ITEM_TYPE_NON_OPT) { - const struct argpar_item_non_opt *item_non_opt = - (const struct argpar_item_non_opt *) - argpar_item; - - ERR("Unexpected argument `%s`.", item_non_opt->arg); + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_NON_OPT) { + ERR("Unexpected argument `%s`.", + argpar_item_non_opt_arg(argpar_item)); goto error; } - item_opt = (const struct argpar_item_opt *) argpar_item; - - ingested_args = argpar_state_get_ingested_orig_args( - argpar_state); + ingested_args = argpar_iter_ingested_orig_args(argpar_iter); my_argc -= ingested_args; my_argv += ingested_args; - switch (item_opt->descr->id) { + descr = argpar_item_opt_descr(argpar_item); + arg = argpar_item_opt_arg(argpar_item); + + switch (descr->id) { case OPT_HELP: SHOW_HELP(); ret = 0; @@ -2097,7 +2295,9 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - condition = parse_condition(item_opt->arg, &my_argc, &my_argv); + condition = parse_condition(arg, &my_argc, &my_argv, + argc - my_argc, argc - my_argc - ingested_args, + my_argv[-ingested_args]); if (!condition) { /* * An error message was already printed by @@ -2110,7 +2310,9 @@ int cmd_add_trigger(int argc, const char **argv) } case OPT_ACTION: { - action = parse_action(item_opt->arg, &my_argc, &my_argv); + action = parse_action(arg, &my_argc, &my_argv, + argc - my_argc, argc - my_argc - ingested_args, + my_argv[-ingested_args]); if (!action) { /* * An error message was already printed by @@ -2126,14 +2328,14 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - /* Ownership of the action was transferred to the group. */ + /* Ownership of the action was transferred to the list. */ action = NULL; break; } case OPT_NAME: { - if (!assign_string(&name, item_opt->arg, "--name")) { + if (!assign_string(&name, arg, "--name")) { goto error; } @@ -2141,7 +2343,7 @@ int cmd_add_trigger(int argc, const char **argv) } case OPT_OWNER_UID: { - if (!assign_string(&owner_uid, item_opt->arg, + if (!assign_string(&owner_uid, arg, "--owner-uid")) { goto error; } @@ -2222,7 +2424,24 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - MSG("Trigger registered successfully."); + if (lttng_opt_mi) { + ret_code = lttng_trigger_mi_serialize(trigger, mi_writer, NULL); + if (ret_code != LTTNG_OK) { + goto error; + } + } else { + const char *returned_trigger_name; + const enum lttng_trigger_status trigger_status = + lttng_trigger_get_name(trigger, + &returned_trigger_name); + + if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { + WARN("Failed to retrieve the added trigger's name."); + } else { + MSG("Added trigger `%s`.", returned_trigger_name); + } + } + ret = 0; goto end; @@ -2231,15 +2450,47 @@ error: ret = 1; end: - argpar_state_destroy(argpar_state); + /* Mi closing. */ + if (lttng_opt_mi && mi_writer) { + int mi_ret; + + /* Close output element. */ + mi_ret = mi_lttng_writer_close_element(mi_writer); + if (mi_ret) { + ret = 1; + goto cleanup; + } + + mi_ret = mi_lttng_writer_write_element_bool(mi_writer, + mi_lttng_element_command_success, ret ? 0 : 1); + if (mi_ret) { + ret = 1; + goto cleanup; + } + + /* Command element close. */ + mi_ret = mi_lttng_writer_command_close(mi_writer); + if (mi_ret) { + ret = 1; + goto cleanup; + } + } + +cleanup: + argpar_error_destroy(argpar_error); + argpar_iter_destroy(argpar_iter); argpar_item_destroy(argpar_item); lttng_dynamic_pointer_array_reset(&actions); lttng_condition_destroy(condition); lttng_action_destroy(action_list); lttng_action_destroy(action); lttng_trigger_destroy(trigger); - free(error); free(name); free(owner_uid); + if (mi_writer && mi_lttng_writer_destroy(mi_writer)) { + /* Preserve original error code. */ + ret = ret ? ret : CMD_ERROR; + } + return ret; }