X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fadd_trigger.c;h=8fb79d3786c577842475ea9724f92293ec591800;hp=d460c0ffbda494a31aedd1b1832f498587254c00;hb=1004b7191b421c7c07acf964d0110d93bb022699;hpb=bbadb5e0b423348492c56ef7d8430087d9d9349d diff --git a/src/bin/lttng/commands/add_trigger.c b/src/bin/lttng/commands/add_trigger.c index d460c0ffb..8fb79d378 100644 --- a/src/bin/lttng/commands/add_trigger.c +++ b/src/bin/lttng/commands/add_trigger.c @@ -7,6 +7,7 @@ #include #include +#include #include "../command.h" #include "../loglevel.h" @@ -14,8 +15,10 @@ #include "common/argpar/argpar.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 @@ -40,28 +43,18 @@ enum { OPT_CONDITION, OPT_ACTION, OPT_ID, - OPT_USER_ID, + OPT_OWNER_UID, OPT_RATE_POLICY, - OPT_ALL, + OPT_NAME, OPT_FILTER, - OPT_EXCLUDE, - OPT_LOGLEVEL, - OPT_LOGLEVEL_ONLY, - - OPT_USERSPACE, - OPT_KERNEL, - OPT_LOG4J, - OPT_JUL, - OPT_PYTHON, - - OPT_FUNCTION, - OPT_PROBE, - OPT_USERSPACE_PROBE, - OPT_SYSCALL, - OPT_TRACEPOINT, + OPT_EXCLUDE_NAME, + OPT_EVENT_NAME, + OPT_LOG_LEVEL, + + OPT_TYPE, + OPT_LOCATION, - OPT_NAME, OPT_MAX_SIZE, OPT_DATA_URL, OPT_CTRL_URL, @@ -72,25 +65,14 @@ enum { }; static const struct argpar_opt_descr event_rule_opt_descrs[] = { - { OPT_ALL, 'a', "all", false }, { OPT_FILTER, 'f', "filter", true }, - { OPT_EXCLUDE, 'x', "exclude", true }, - { OPT_LOGLEVEL, '\0', "loglevel", true }, - { OPT_LOGLEVEL_ONLY, '\0', "loglevel-only", true }, - - /* Domains */ - { OPT_USERSPACE, 'u', "userspace", false }, - { OPT_KERNEL, 'k', "kernel", false }, - { OPT_LOG4J, 'l', "log4j", false }, - { OPT_JUL, 'j', "jul", false }, - { OPT_PYTHON, 'p', "python", false }, - - /* Event rule types */ - { OPT_FUNCTION, '\0', "function", true }, - { OPT_PROBE, '\0', "probe", true }, - { OPT_USERSPACE_PROBE, '\0', "userspace-probe", true }, - { OPT_SYSCALL, '\0', "syscall" }, - { OPT_TRACEPOINT, '\0', "tracepoint" }, + { OPT_NAME, 'n', "name", true }, + { OPT_EXCLUDE_NAME, 'x', "exclude-name", true }, + { OPT_LOG_LEVEL, 'l', "log-level", true }, + { OPT_EVENT_NAME, 'E', "event-name", true }, + + { OPT_TYPE, 't', "type", true }, + { OPT_LOCATION, 'L', "location", true }, /* Capture descriptor */ { OPT_CAPTURE, '\0', "capture", true }, @@ -99,36 +81,86 @@ static const struct argpar_opt_descr event_rule_opt_descrs[] = { }; static -bool assign_domain_type(enum lttng_domain_type *dest, - enum lttng_domain_type src) +bool has_syscall_prefix(const char *arg) { - bool ret; - - if (*dest == LTTNG_DOMAIN_NONE || *dest == src) { - *dest = src; - ret = true; + 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("Multiple domains specified."); - ret = false; + matches = false; } - return ret; + return matches; } static -bool assign_event_rule_type(enum lttng_event_rule_type *dest, - enum lttng_event_rule_type src) +bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) { bool ret; - if (*dest == LTTNG_EVENT_RULE_TYPE_UNKNOWN || *dest == src) { - *dest = src; - ret = true; + if (*dest != LTTNG_EVENT_RULE_TYPE_UNKNOWN) { + ERR("More than one `--type` was specified."); + goto error; + } + + 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: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 + * - syscall:entry + * - 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_KERNEL_SYSCALL; } else { - ERR("Multiple event types specified."); - ret = false; + ERR("Invalid `--type` value: %s", arg); + goto error; } + ret = true; + goto end; + +error: + ret = false; + +end: return ret; } @@ -158,52 +190,141 @@ end: return ret; } -/* This is defined in enable_events.c. */ -LTTNG_HIDDEN -int create_exclusion_list_and_validate(const char *event_name, - const char *exclusions_arg, - char ***exclusion_list); +static bool parse_syscall_emission_site_from_type(const char *str, + 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_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT; + } else if (strcmp(str, "syscall:entry") == 0) { + *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY; + } else if (strcmp(str, "syscall:exit") == 0) { + *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT; + } else { + goto error; + } + + ret = true; + +error: + return ret; +} /* - * Parse `str` as a log level in domain `domain_type`. Return -1 if the string - * is not recognized as a valid log level. + * 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 + * this log level. + * + * Return true if the string was successfully parsed as a log level string. */ -static -int parse_loglevel_string(const char *str, enum lttng_domain_type domain_type) +static bool parse_log_level_string(const char *str, + enum lttng_event_rule_type event_rule_type, + int *log_level, + bool *log_level_only) { - switch (domain_type) { - case LTTNG_DOMAIN_UST: + bool ret; + + switch (event_rule_type) { + case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: { - enum lttng_loglevel loglevel; - const int ret = loglevel_name_to_value(str, &loglevel); + enum lttng_loglevel log_level_min, log_level_max; + if (!loglevel_parse_range_string( + str, &log_level_min, &log_level_max)) { + goto error; + } + + /* Only support VAL and VAL.. for now. */ + if (log_level_min != log_level_max && + log_level_max != LTTNG_LOGLEVEL_EMERG) { + goto error; + } - return ret == -1 ? ret : (int) loglevel; + *log_level = (int) log_level_min; + *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 loglevel; - const int ret = loglevel_log4j_name_to_value(str, &loglevel); + enum lttng_loglevel_log4j log_level_min, log_level_max; + if (!loglevel_log4j_parse_range_string( + str, &log_level_min, &log_level_max)) { + goto error; + } - return ret == -1 ? ret : (int) loglevel; + /* Only support VAL and VAL.. for now. */ + if (log_level_min != log_level_max && + log_level_max != LTTNG_LOGLEVEL_LOG4J_FATAL) { + goto error; + } + + *log_level = (int) log_level_min; + *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 loglevel; - const int ret = loglevel_jul_name_to_value(str, &loglevel); + enum lttng_loglevel_jul log_level_min, log_level_max; + if (!loglevel_jul_parse_range_string( + str, &log_level_min, &log_level_max)) { + goto error; + } - return ret == -1 ? ret : (int) loglevel; + /* Only support VAL and VAL.. for now. */ + if (log_level_min != log_level_max && + log_level_max != LTTNG_LOGLEVEL_JUL_SEVERE) { + goto error; + } + + *log_level = (int) log_level_min; + *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 loglevel; - const int ret = loglevel_python_name_to_value(str, &loglevel); + enum lttng_loglevel_python log_level_min, log_level_max; + if (!loglevel_python_parse_range_string( + str, &log_level_min, &log_level_max)) { + goto error; + } + + /* Only support VAL and VAL.. for now. */ + if (log_level_min != log_level_max && + log_level_max != + LTTNG_LOGLEVEL_PYTHON_CRITICAL) { + goto error; + } - return ret == -1 ? ret : (int) loglevel; + *log_level = (int) log_level_min; + *log_level_only = log_level_min == log_level_max; + break; } default: /* Invalid domain type. */ abort(); } + + ret = true; + goto end; + +error: + ret = false; + +end: + return ret; } static int parse_kernel_probe_opts(const char *source, @@ -528,7 +649,6 @@ struct parse_event_rule_res { static struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) { - 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; @@ -542,28 +662,29 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) struct filter_parser_ctx *parser_ctx = NULL; struct lttng_log_level_rule *log_level_rule = NULL; - /* Was the -a/--all flag provided? */ - bool all_events = false; + /* Event rule type option */ + char *event_rule_type_str = NULL; - /* Tracepoint name (non-option argument). */ - const char *tracepoint_name = NULL; + /* Tracepoint and syscall options. */ + char *name = NULL; + /* Array of strings. */ + struct lttng_dynamic_pointer_array exclude_names; - /* Holds the argument of --probe / --userspace-probe. */ - char *source = NULL; + /* For userspace / kernel probe and function. */ + char *location = NULL; + char *event_name = NULL; /* Filter. */ char *filter = NULL; - /* Exclude. */ - char *exclude = NULL; - char **exclusion_list = NULL; - /* Log level. */ - char *loglevel_str = NULL; - bool loglevel_only = false; + char *log_level_str = NULL; lttng_dynamic_pointer_array_init(&res.capture_descriptors, destroy_event_expr); + + 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."); @@ -592,108 +713,70 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) (const struct argpar_item_opt *) item; switch (item_opt->descr->id) { - /* Domains. */ - case OPT_USERSPACE: - if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_UST)) { - goto error; - } - - break; - case OPT_KERNEL: - if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_KERNEL)) { - goto error; - } - - break; - case OPT_LOG4J: - if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_LOG4J)) { - goto error; - } - - break; - case OPT_JUL: - if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_JUL)) { - goto error; - } - - break; - case OPT_PYTHON: - if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_PYTHON)) { - goto error; - } - - break; - - /* Event rule types */ - case OPT_FUNCTION: + case OPT_TYPE: if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION)) { + item_opt->arg)) { goto error; } - break; - case OPT_PROBE: - if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE)) { - goto error; - } - - if (!assign_string(&source, item_opt->arg, "source")) { + /* Save the string for later use. */ + if (!assign_string(&event_rule_type_str, + item_opt->arg, + "--type/-t")) { goto error; } break; - case OPT_USERSPACE_PROBE: - if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE)) { + case OPT_LOCATION: + if (!assign_string(&location, + item_opt->arg, + "--location/-L")) { goto error; } - if (!assign_string(&source, item_opt->arg, "source")) { - goto error; - } - break; - case OPT_SYSCALL: - if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_SYSCALL)) { + case OPT_EVENT_NAME: + if (!assign_string(&event_name, + item_opt->arg, + "--event-name/-E")) { goto error; } break; - case OPT_TRACEPOINT: - if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_TRACEPOINT)) { + case OPT_FILTER: + if (!assign_string(&filter, item_opt->arg, + "--filter/-f")) { goto error; } break; - case OPT_ALL: - all_events = true; - break; - case OPT_FILTER: - if (!assign_string(&filter, item_opt->arg, - "--filter/-f")) { + case OPT_NAME: + if (!assign_string(&name, item_opt->arg, + "--name/-n")) { goto error; } break; - case OPT_EXCLUDE: - if (!assign_string(&exclude, item_opt->arg, - "--exclude/-x")) { + case OPT_EXCLUDE_NAME: + { + int ret; + + ret = lttng_dynamic_pointer_array_add_pointer( + &exclude_names, + strdup(item_opt->arg)); + if (ret != 0) { + ERR("Failed to add pointer to dynamic pointer array."); goto error; } break; - case OPT_LOGLEVEL: - case OPT_LOGLEVEL_ONLY: - if (!assign_string(&loglevel_str, item_opt->arg, - "--loglevel/--loglevel-only")) { + } + case OPT_LOG_LEVEL: + if (!assign_string(&log_level_str, + item_opt->arg, "--log-level/-l")) { goto error; } - loglevel_only = item_opt->descr->id == - OPT_LOGLEVEL_ONLY; break; case OPT_CAPTURE: { @@ -742,63 +825,84 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) (const struct argpar_item_non_opt *) item; - /* - * Don't accept two non-option arguments/tracepoint - * names. - */ - if (tracepoint_name) { - ERR("Unexpected argument '%s'", - item_non_opt->arg); - goto error; - } - - tracepoint_name = item_non_opt->arg; + /* Don't accept non-option arguments. */ + ERR("Unexpected argument '%s'", item_non_opt->arg); + goto error; } } if (event_rule_type == LTTNG_EVENT_RULE_TYPE_UNKNOWN) { - event_rule_type = LTTNG_EVENT_RULE_TYPE_TRACEPOINT; + event_rule_type = LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT; } /* - * Option -a is applicable to event rules of type tracepoint and - * syscall, and it is equivalent to using "*" as the tracepoint name. + * Option --name is applicable to event rules of type kernel, user, jul, + * log4j,python and syscall. If --name is omitted, it is implicitly + * "*". */ - if (all_events) { - switch (event_rule_type) { - case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: - case LTTNG_EVENT_RULE_TYPE_SYSCALL: - break; - default: - ERR("Can't use -a/--all with %s event rules.", - lttng_event_rule_type_str(event_rule_type)); - goto error; + switch (event_rule_type) { + 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("*"); } + break; - if (tracepoint_name) { - ERR("Can't provide a tracepoint name with -a/--all."); + default: + if (name) { + ERR("Can't use --name with %s event rules.", + lttng_event_rule_type_str( + event_rule_type)); goto error; } - /* In which case, it's equivalent to tracepoint name "*". */ - tracepoint_name = "*"; + if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) { + ERR("Can't use --exclude-name/-x with %s event rules.", + lttng_event_rule_type_str( + event_rule_type)); + goto error; + } } /* - * A tracepoint name (or -a, for the event rule types that accept it) - * is required. + * Option --location is only applicable to (and mandatory for) event + * rules of type {k,u}probe and function. + * + * Option --event-name is only applicable to event rules of type probe. + * If omitted, it defaults to the location. */ - if (!tracepoint_name) { - ERR("Need to provide either a tracepoint name or -a/--all."); - goto error; - } + switch (event_rule_type) { + 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)); + goto error; + } - /* - * We don't support multiple tracepoint names for now. - */ - if (strchr(tracepoint_name, ',')) { - ERR("Comma separated tracepoint names are not supported."); - goto error; + if (!event_name) { + event_name = strdup(location); + } + + break; + + default: + if (location) { + ERR("Can't use --location with %s event rules.", + lttng_event_rule_type_str(event_rule_type)); + goto error; + } + + if (event_name) { + ERR("Can't use --event-name with %s event rules.", + lttng_event_rule_type_str( + event_rule_type)); + goto error; + } } /* @@ -809,40 +913,19 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) *argc -= consumed_args; *argv += consumed_args; - /* Need to specify a domain. */ - if (domain_type == LTTNG_DOMAIN_NONE) { - ERR("Please specify a domain (--kernel/--userspace/--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.", @@ -851,105 +934,247 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } } - /* If --exclude/-x was passed, split it into an exclusion list. */ - if (exclude) { - if (domain_type != LTTNG_DOMAIN_UST) { + /* + * 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 (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; } - - if (create_exclusion_list_and_validate(tracepoint_name, exclude, - &exclusion_list) != 0) { - ERR("Failed to create exclusion list."); + if (validate_exclusion_list(name, &exclude_names) != 0) { + /* + * Assume validate_exclusion_list already prints an + * error message. + */ goto error; } } - if (loglevel_str && event_rule_type != LTTNG_EVENT_RULE_TYPE_TRACEPOINT) { - ERR("Log levels are only applicable to tracepoint event rules."); - goto error; + if (log_level_str) { + 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 (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_pattern( - res.er, tracepoint_name); + 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'.", - tracepoint_name); + 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; } } /* Set exclusion list. */ - if (exclusion_list) { + if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) { int n; - - for (n = 0; exclusion_list[n]; n++) { - event_rule_status = lttng_event_rule_tracepoint_add_exclusion( - res.er, - exclusion_list[n]); + int count = lttng_dynamic_pointer_array_get_count( + &exclude_names); + + for (n = 0; n < count; n++) { + const char *exclude_name = + lttng_dynamic_pointer_array_get_pointer( + &exclude_names, + n); + + event_rule_status = + 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'", - exclusion_list[n]); + ERR("Failed to set user_tracepoint exclusion list element '%s'", + exclude_name); goto error; } } } - if (loglevel_str) { - int loglevel; + if (log_level_rule) { + event_rule_status = + lttng_event_rule_user_tracepoint_set_log_level_rule( + res.er, log_level_rule); - if (domain_type == LTTNG_DOMAIN_KERNEL) { - ERR("Log levels are not supported by the kernel tracer."); + 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_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; + } - loglevel = parse_loglevel_string( - loglevel_str, domain_type); - if (loglevel < 0) { - ERR("Failed to parse `%s` as a log level.", - loglevel_str); + /* 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 (loglevel_only) { - log_level_rule = lttng_log_level_rule_exactly_create(loglevel); - } else { - log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(loglevel); + 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 == NULL) { - ERR("Failed to create log level rule object."); + if (log_level_rule) { + event_rule_status = + lttng_event_rule_jul_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_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_tracepoint_set_log_level_rule( + lttng_event_rule_log4j_logging_set_log_level_rule( res.er, log_level_rule); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { @@ -957,84 +1182,136 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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; - - ret = parse_kernel_probe_opts(source, &kernel_probe_location); + ret = parse_kernel_probe_opts( + location, &kernel_probe_location); if (ret) { ERR("Failed to parse kernel probe location."); goto error; } 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(res.er, tracepoint_name); + event_rule_status = + 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'.", tracepoint_name); + ERR("Failed to set kprobe event rule's name to '%s'.", + event_name); goto error; } 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; ret = parse_userspace_probe_opts( - source, &userspace_probe_location); + location, &userspace_probe_location); if (ret) { ERR("Failed to parse user space probe location."); 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( - res.er, tracepoint_name); + event_rule_status = + 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'.", - tracepoint_name); + event_name); goto error; } 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_kernel_syscall_emission_site emission_site; - res.er = lttng_event_rule_syscall_create(); + if (!parse_syscall_emission_site_from_type( + event_rule_type_str, &emission_site)) { + ERR("Failed to parse syscall type '%s'.", event_rule_type_str); + goto error; + } + + 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_pattern( - res.er, tracepoint_name); + 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'.", - tracepoint_name); + name); goto error; } 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'.", @@ -1067,10 +1344,13 @@ end: free(error); argpar_state_destroy(state); free(filter); - free(exclude); - free(loglevel_str); - free(source); - strutils_free_null_terminated_array_of_strings(exclusion_list); + free(name); + lttng_dynamic_pointer_array_reset(&exclude_names); + free(log_level_str); + free(location); + free(event_name); + free(event_rule_type_str); + lttng_kernel_probe_location_destroy(kernel_probe_location); lttng_userspace_probe_location_destroy(userspace_probe_location); lttng_log_level_rule_destroy(log_level_rule); @@ -1090,7 +1370,7 @@ struct lttng_condition *handle_condition_event(int *argc, const char ***argv) goto error; } - c = lttng_condition_on_event_create(res.er); + c = lttng_condition_event_rule_matches_create(res.er); lttng_event_rule_destroy(res.er); res.er = NULL; if (!c) { @@ -1106,7 +1386,7 @@ struct lttng_condition *handle_condition_event(int *argc, const char ***argv) assert(expr); assert(*expr); - status = lttng_condition_on_event_append_capture_descriptor( + status = lttng_condition_event_rule_matches_append_capture_descriptor( c, *expr); if (status != LTTNG_CONDITION_STATUS_OK) { if (status == LTTNG_CONDITION_STATUS_UNSUPPORTED) { @@ -1132,151 +1412,6 @@ end: return c; } -static -struct lttng_condition *handle_condition_session_consumed_size(int *argc, const char ***argv) -{ - struct lttng_condition *cond = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; - const char *threshold_arg = NULL; - const char *session_name_arg = NULL; - uint64_t threshold; - char *error = NULL; - enum lttng_condition_status condition_status; - - state = argpar_state_create(*argc, *argv, event_rule_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); - goto error; - } - - while (true) { - enum argpar_state_parse_next_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); - 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) { - 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; - - switch (item_opt->descr->id) { - default: - 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; - - switch (item_non_opt->non_opt_index) { - case 0: - session_name_arg = item_non_opt->arg; - break; - case 1: - threshold_arg = item_non_opt->arg; - break; - default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); - goto error; - } - } - } - - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); - - if (!session_name_arg) { - ERR("Missing session name argument."); - goto error; - } - - if (!threshold_arg) { - ERR("Missing threshold argument."); - goto error; - } - - if (utils_parse_size_suffix(threshold_arg, &threshold) != 0) { - ERR("Failed to parse `%s` as a size.", threshold_arg); - goto error; - } - - cond = lttng_condition_session_consumed_size_create(); - if (!cond) { - ERR("Failed to allocate a session consumed size condition."); - goto error; - } - - condition_status = lttng_condition_session_consumed_size_set_session_name( - cond, session_name_arg); - if (condition_status != LTTNG_CONDITION_STATUS_OK) { - ERR("Failed to set session consumed size condition's session name to '%s'.", - session_name_arg); - goto error; - } - - condition_status = lttng_condition_session_consumed_size_set_threshold( - cond, threshold); - if (condition_status != LTTNG_CONDITION_STATUS_OK) { - ERR("Failed to set session consumed size condition threshold."); - goto error; - } - - goto end; - -error: - lttng_condition_destroy(cond); - cond = NULL; - -end: - argpar_state_destroy(state); - argpar_item_destroy(item); - free(error); - return cond; -} - -static -struct lttng_condition *handle_condition_buffer_usage_high(int *argc, const char ***argv) -{ - ERR("High buffer usage threshold conditions are unsupported for the moment."); - return NULL; -} - -static -struct lttng_condition *handle_condition_buffer_usage_low(int *argc, const char ***argv) -{ - ERR("Low buffer usage threshold conditions are unsupported for the moment."); - return NULL; -} - -static -struct lttng_condition *handle_condition_session_rotation_ongoing(int *argc, const char ***argv) -{ - ERR("Session rotation ongoing conditions are unsupported for the moment."); - return NULL; -} - -static -struct lttng_condition *handle_condition_session_rotation_completed(int *argc, const char ***argv) -{ - ERR("Session rotation completed conditions are unsupported for the moment."); - return NULL; -} - struct condition_descr { const char *name; struct lttng_condition *(*handler) (int *argc, const char ***argv); @@ -1284,32 +1419,17 @@ struct condition_descr { static const struct condition_descr condition_descrs[] = { - { "on-event", handle_condition_event }, - { "on-session-consumed-size", handle_condition_session_consumed_size }, - { "on-buffer-usage-high", handle_condition_buffer_usage_high }, - { "on-buffer-usage-low", handle_condition_buffer_usage_low }, - { "on-session-rotation-ongoing", handle_condition_session_rotation_ongoing }, - { "on-session-rotation-completed", handle_condition_session_rotation_completed }, + { "event-rule-matches", handle_condition_event }, }; static -struct lttng_condition *parse_condition(int *argc, const char ***argv) +struct lttng_condition *parse_condition(const char *condition_name, int *argc, + const char ***argv) { int i; struct lttng_condition *cond; - const char *condition_name; const struct condition_descr *descr = NULL; - if (*argc == 0) { - ERR("Missing condition name."); - goto error; - } - - condition_name = (*argv)[0]; - - (*argc)--; - (*argv)++; - for (i = 0; i < ARRAY_SIZE(condition_descrs); i++) { if (strcmp(condition_name, condition_descrs[i].name) == 0) { descr = &condition_descrs[i]; @@ -1337,8 +1457,9 @@ end: static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) { - int num_token; - char **tokens = NULL; + int ret; + size_t num_token = 0; + struct lttng_dynamic_pointer_array tokens; struct lttng_rate_policy *policy = NULL; enum lttng_rate_policy_type policy_type; unsigned long long value; @@ -1346,12 +1467,13 @@ static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) char *policy_value_str; assert(policy_str); + lttng_dynamic_pointer_array_init(&tokens, NULL); - /* - * rate policy fields are separated by ':'. - */ - tokens = strutils_split(policy_str, ':', 1); - num_token = strutils_array_of_strings_len(tokens); + /* Rate policy fields are separated by ':'. */ + ret = strutils_split(policy_str, ':', 1, &tokens); + if (ret == 0) { + num_token = lttng_dynamic_pointer_array_get_count(&tokens); + } /* * Early sanity check that the number of parameter is exactly 2. @@ -1362,8 +1484,8 @@ static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) goto end; } - policy_type_str = tokens[0]; - policy_value_str = tokens[1]; + policy_type_str = lttng_dynamic_pointer_array_get_pointer(&tokens, 0); + policy_value_str = lttng_dynamic_pointer_array_get_pointer(&tokens, 1); /* Parse the type. */ if (strcmp(policy_type_str, "once-after") == 0) { @@ -1403,7 +1525,7 @@ static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) } end: - strutils_free_null_terminated_array_of_strings(tokens); + lttng_dynamic_pointer_array_reset(&tokens); return policy; } @@ -1499,8 +1621,8 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) error: lttng_action_destroy(action); action = NULL; - free(error); end: + free(error); lttng_rate_policy_destroy(policy); argpar_state_destroy(state); argpar_item_destroy(item); @@ -1537,7 +1659,7 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL }; - + state = argpar_state_create(*argc, *argv, rate_policy_opt_descrs); if (!state) { ERR("Failed to allocate an argpar state."); @@ -1999,23 +2121,12 @@ struct action_descr action_descrs[] = { }; static -struct lttng_action *parse_action(int *argc, const char ***argv) +struct lttng_action *parse_action(const char *action_name, int *argc, const char ***argv) { int i; struct lttng_action *action; - const char *action_name; const struct action_descr *descr = NULL; - if (*argc == 0) { - ERR("Missing action name."); - goto error; - } - - action_name = (*argv)[0]; - - (*argc)--; - (*argv)++; - for (i = 0; i < ARRAY_SIZE(action_descrs); i++) { if (strcmp(action_name, action_descrs[i].name) == 0) { descr = &action_descrs[i]; @@ -2045,10 +2156,10 @@ static const struct argpar_opt_descr add_trigger_options[] = { { OPT_HELP, 'h', "help", false }, { OPT_LIST_OPTIONS, '\0', "list-options", false }, - { OPT_CONDITION, '\0', "condition", false }, - { OPT_ACTION, '\0', "action", false }, - { OPT_ID, '\0', "id", true }, - { OPT_USER_ID, '\0', "user-id", true }, + { OPT_CONDITION, '\0', "condition", true }, + { OPT_ACTION, '\0', "action", true }, + { OPT_NAME, '\0', "name", true }, + { OPT_OWNER_UID, '\0', "owner-uid", true }, ARGPAR_OPT_DESCR_SENTINEL, }; @@ -2069,16 +2180,43 @@ int cmd_add_trigger(int argc, const char **argv) struct lttng_dynamic_pointer_array actions; struct argpar_state *argpar_state = NULL; struct argpar_item *argpar_item = NULL; - struct lttng_action *action_group = NULL; + struct lttng_action *action_list = NULL; struct lttng_action *action = NULL; struct lttng_trigger *trigger = NULL; char *error = NULL; - char *id = NULL; + char *name = NULL; int i; - char *user_id = NULL; + 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; @@ -2139,7 +2277,7 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - condition = parse_condition(&my_argc, &my_argv); + condition = parse_condition(item_opt->arg, &my_argc, &my_argv); if (!condition) { /* * An error message was already printed by @@ -2152,7 +2290,7 @@ int cmd_add_trigger(int argc, const char **argv) } case OPT_ACTION: { - action = parse_action(&my_argc, &my_argv); + action = parse_action(item_opt->arg, &my_argc, &my_argv); if (!action) { /* * An error message was already printed by @@ -2168,23 +2306,23 @@ 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_ID: + case OPT_NAME: { - if (!assign_string(&id, item_opt->arg, "--id")) { + if (!assign_string(&name, item_opt->arg, "--name")) { goto error; } break; } - case OPT_USER_ID: + case OPT_OWNER_UID: { - if (!assign_string(&user_id, item_opt->arg, - "--user-id")) { + if (!assign_string(&owner_uid, item_opt->arg, + "--owner-uid")) { goto error; } @@ -2205,8 +2343,8 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - action_group = lttng_action_group_create(); - if (!action_group) { + action_list = lttng_action_list_create(); + if (!action_list) { goto error; } @@ -2215,43 +2353,34 @@ int cmd_add_trigger(int argc, const char **argv) action = lttng_dynamic_pointer_array_steal_pointer(&actions, i); - status = lttng_action_group_add_action(action_group, action); + status = lttng_action_list_add_action(action_list, action); if (status != LTTNG_ACTION_STATUS_OK) { goto error; } /* - * The `lttng_action_group_add_action()` takes a reference to + * The `lttng_action_list_add_action()` takes a reference to * the action. We can destroy ours. */ lttng_action_destroy(action); action = NULL; } - trigger = lttng_trigger_create(condition, action_group); + trigger = lttng_trigger_create(condition, action_list); if (!trigger) { goto error; } - if (id) { - enum lttng_trigger_status trigger_status = - lttng_trigger_set_name(trigger, id); - - if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { - ERR("Failed to set trigger id."); - goto error; - } - } - - if (user_id) { + if (owner_uid) { enum lttng_trigger_status trigger_status; char *end; long long uid; errno = 0; - uid = strtol(user_id, &end, 10); - if (end == user_id || *end != '\0' || errno != 0) { - ERR("Failed to parse `%s` as a user id.", user_id); + uid = strtol(owner_uid, &end, 10); + if (end == owner_uid || *end != '\0' || errno != 0) { + ERR("Failed to parse `%s` as a user id.", owner_uid); + goto error; } trigger_status = lttng_trigger_set_owner_uid(trigger, uid); @@ -2261,13 +2390,37 @@ int cmd_add_trigger(int argc, const char **argv) } } - ret = lttng_register_trigger(trigger); - if (ret) { - ERR("Failed to register trigger: %s.", lttng_strerror(ret)); + if (name) { + ret_code = lttng_register_trigger_with_name(trigger, name); + } else { + ret_code = lttng_register_trigger_with_automatic_name(trigger); + } + + if (ret_code != LTTNG_OK) { + ERR("Failed to register trigger: %s.", + lttng_strerror(-ret_code)); 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; @@ -2275,15 +2428,47 @@ error: ret = 1; end: + /* 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_state_destroy(argpar_state); argpar_item_destroy(argpar_item); lttng_dynamic_pointer_array_reset(&actions); lttng_condition_destroy(condition); - lttng_action_destroy(action_group); + lttng_action_destroy(action_list); lttng_action_destroy(action); lttng_trigger_destroy(trigger); free(error); - free(id); - free(user_id); + 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; }