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=27a666c5da97dba8c8ab900d336ef7229f5f0184;hb=1004b7191b421c7c07acf964d0110d93bb022699;hpb=7f4d5b07cf7be895b38b69073389a4fcc318ec29 diff --git a/src/bin/lttng/commands/add_trigger.c b/src/bin/lttng/commands/add_trigger.c index 27a666c5d..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,29 +43,18 @@ enum { OPT_CONDITION, OPT_ACTION, OPT_ID, - OPT_FIRE_ONCE_AFTER, - OPT_FIRE_EVERY, - 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, @@ -73,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 }, @@ -100,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; } @@ -159,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; + } - 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_EMERG) { + goto error; + } + + *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; + } + + /* Only support VAL and VAL.. for now. */ + if (log_level_min != log_level_max && + log_level_max != LTTNG_LOGLEVEL_LOG4J_FATAL) { + 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_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, @@ -529,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; @@ -543,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."); @@ -593,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: { @@ -743,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; + } } /* @@ -810,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.", @@ -852,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 (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; + } + + /* 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; + } - if (domain_type == LTTNG_DOMAIN_KERNEL) { - ERR("Log levels are not supported by the kernel tracer."); + /* 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; + + 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; + } - loglevel = parse_loglevel_string( - loglevel_str, domain_type); - if (loglevel < 0) { - ERR("Failed to parse `%s` as a log level.", - loglevel_str); + /* 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 (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); + 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; - if (log_level_rule == NULL) { - ERR("Failed to create log level rule object."); + 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) { @@ -958,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'.", @@ -1068,214 +1344,72 @@ 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); return res; } -static -struct lttng_condition *handle_condition_event(int *argc, const char ***argv) -{ - struct parse_event_rule_res res; - struct lttng_condition *c; - size_t i; - - res = parse_event_rule(argc, argv); - if (!res.er) { - c = NULL; - goto error; - } - - c = lttng_condition_on_event_create(res.er); - lttng_event_rule_destroy(res.er); - res.er = NULL; - if (!c) { - goto error; - } - - for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors); - i++) { - enum lttng_condition_status status; - struct lttng_event_expr **expr = - lttng_dynamic_array_get_element( - &res.capture_descriptors.array, i); - - assert(expr); - assert(*expr); - status = lttng_condition_on_event_append_capture_descriptor( - c, *expr); - if (status != LTTNG_CONDITION_STATUS_OK) { - if (status == LTTNG_CONDITION_STATUS_UNSUPPORTED) { - ERR("The capture feature is unsupported by the event-rule condition type"); - } - - goto error; - } - - /* Ownership of event expression moved to `c` */ - *expr = NULL; - } - - goto end; - -error: - lttng_condition_destroy(c); - c = NULL; - -end: - lttng_dynamic_pointer_array_reset(&res.capture_descriptors); - lttng_event_rule_destroy(res.er); - 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; - } +static +struct lttng_condition *handle_condition_event(int *argc, const char ***argv) +{ + struct parse_event_rule_res res; + struct lttng_condition *c; + size_t i; - if (!threshold_arg) { - ERR("Missing threshold argument."); + res = parse_event_rule(argc, argv); + if (!res.er) { + c = NULL; goto error; } - if (utils_parse_size_suffix(threshold_arg, &threshold) != 0) { - ERR("Failed to parse `%s` as a size.", threshold_arg); + c = lttng_condition_event_rule_matches_create(res.er); + lttng_event_rule_destroy(res.er); + res.er = NULL; + if (!c) { goto error; } - cond = lttng_condition_session_consumed_size_create(); - if (!cond) { - ERR("Failed to allocate a session consumed size condition."); - goto error; - } + for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors); + i++) { + enum lttng_condition_status status; + struct lttng_event_expr **expr = + lttng_dynamic_array_get_element( + &res.capture_descriptors.array, i); - 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; - } + assert(expr); + assert(*expr); + status = lttng_condition_event_rule_matches_append_capture_descriptor( + c, *expr); + if (status != LTTNG_CONDITION_STATUS_OK) { + if (status == LTTNG_CONDITION_STATUS_UNSUPPORTED) { + ERR("The capture feature is unsupported by the event-rule condition type"); + } - 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 error; + } + + /* Ownership of event expression moved to `c` */ + *expr = NULL; } goto end; error: - lttng_condition_destroy(cond); - cond = NULL; + lttng_condition_destroy(c); + c = 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; + lttng_dynamic_pointer_array_reset(&res.capture_descriptors); + lttng_event_rule_destroy(res.er); + return c; } struct condition_descr { @@ -1285,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]; @@ -1335,13 +1454,86 @@ error: end: return cond; } + +static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) +{ + 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; + char *policy_type_str; + char *policy_value_str; + + assert(policy_str); + lttng_dynamic_pointer_array_init(&tokens, NULL); + + /* 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. + * i.e : type:value + */ + if (num_token != 2) { + ERR("Rate policy format is invalid."); + goto end; + } + + 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) { + policy_type = LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N; + } else if (strcmp(policy_type_str, "every") == 0) { + policy_type = LTTNG_RATE_POLICY_TYPE_EVERY_N; + } else { + ERR("Rate policy type `%s` unknown.", policy_type_str); + goto end; + } + + /* Parse the value. */ + if (utils_parse_unsigned_long_long(policy_value_str, &value) != 0) { + ERR("Failed to parse rate policy value `%s` as an integer.", + policy_value_str); + goto end; + } + + if (value == 0) { + ERR("Rate policy value `%s` must be > 0.", policy_value_str); + goto end; + } + + switch (policy_type) { + case LTTNG_RATE_POLICY_TYPE_EVERY_N: + policy = lttng_rate_policy_every_n_create(value); + break; + case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N: + policy = lttng_rate_policy_once_after_n_create(value); + break; + default: + abort(); + } + + if (policy == NULL) { + ERR("Failed to create rate policy `%s`.", policy_str); + } + +end: + lttng_dynamic_pointer_array_reset(&tokens); + return policy; +} + static const struct argpar_opt_descr notify_action_opt_descrs[] = { - { OPT_FIRE_ONCE_AFTER, '\0', "fire-once-after", true }, - { OPT_FIRE_EVERY, '\0', "fire-every", true }, + { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL }; - static struct lttng_action *handle_action_notify(int *argc, const char ***argv) { @@ -1349,8 +1541,6 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) struct argpar_state *state = NULL; struct argpar_item *item = NULL; char *error = NULL; - char *fire_once_after_str = NULL; - char *fire_every_str = NULL; struct lttng_rate_policy *policy = NULL; state = argpar_state_create(*argc, *argv, notify_action_opt_descrs); @@ -1381,27 +1571,14 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) (const struct argpar_item_opt *) item; switch (item_opt->descr->id) { - case OPT_FIRE_ONCE_AFTER: - { - if (!assign_string(&fire_once_after_str, - item_opt->arg, - "--fire-once-after")) { - goto error; - } - - break; - } - case OPT_FIRE_EVERY: + case OPT_RATE_POLICY: { - if (!assign_string(&fire_every_str, - item_opt->arg, - "--fire-every")) { + policy = parse_rate_policy(item_opt->arg); + if (!policy) { goto error; } - break; } - default: abort(); } @@ -1424,55 +1601,6 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) *argc -= argpar_state_get_ingested_orig_args(state); *argv += argpar_state_get_ingested_orig_args(state); - if (fire_once_after_str && fire_every_str) { - ERR("--fire-once and --fire-every are mutually exclusive."); - goto error; - } - - if (fire_once_after_str) { - unsigned long long threshold; - - if (utils_parse_unsigned_long_long( - fire_once_after_str, &threshold) != 0) { - ERR("Failed to parse `%s` as an integer.", - fire_once_after_str); - goto error; - } - - if (threshold == 0) { - ERR("Once after N policy threshold cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_once_after_n_create(threshold); - if (!policy) { - ERR("Failed to create policy once after `%s`.", - fire_once_after_str); - goto error; - } - } - - if (fire_every_str) { - unsigned long long interval; - if (utils_parse_unsigned_long_long(fire_every_str, &interval) != - 0) { - ERR("Failed to parse `%s` as an integer.", - fire_every_str); - goto error; - } - if (interval == 0) { - ERR("Every N policy interval cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_every_n_create(interval); - if (!policy) { - ERR("Failed to create policy every `%s`.", - fire_every_str); - goto error; - } - } - action = lttng_action_notify_create(); if (!action) { ERR("Failed to create notify action"); @@ -1493,10 +1621,8 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) error: lttng_action_destroy(action); action = NULL; - free(error); end: - free(fire_once_after_str); - free(fire_every_str); + free(error); lttng_rate_policy_destroy(policy); argpar_state_destroy(state); argpar_item_destroy(item); @@ -1522,8 +1648,6 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, struct argpar_state *state = NULL; struct argpar_item *item = NULL; const char *session_name_arg = NULL; - char *fire_once_after_str = NULL; - char *fire_every_str = NULL; char *error = NULL; enum lttng_action_status action_status; struct lttng_rate_policy *policy = NULL; @@ -1532,11 +1656,10 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, assert(set_rate_policy_cb); const struct argpar_opt_descr rate_policy_opt_descrs[] = { - { OPT_FIRE_ONCE_AFTER, '\0', "fire-once-after", true }, - { OPT_FIRE_EVERY, '\0', "fire-every", true }, + { 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."); @@ -1565,27 +1688,14 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, (const struct argpar_item_opt *) item; switch (item_opt->descr->id) { - case OPT_FIRE_ONCE_AFTER: + case OPT_RATE_POLICY: { - if (!assign_string(&fire_once_after_str, - item_opt->arg, - "--fire-once-after")) { - goto error; - } - - break; - } - case OPT_FIRE_EVERY: - { - if (!assign_string(&fire_every_str, - item_opt->arg, - "--fire-every")) { + policy = parse_rate_policy(item_opt->arg); + if (!policy) { goto error; } - break; } - default: abort(); } @@ -1613,55 +1723,6 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, goto error; } - if (fire_once_after_str && fire_every_str) { - ERR("--fire-once and --fire-every are mutually exclusive."); - goto error; - } - - if (fire_once_after_str) { - unsigned long long threshold; - - if (utils_parse_unsigned_long_long( - fire_once_after_str, &threshold) != 0) { - ERR("Failed to parse `%s` as an integer.", - fire_once_after_str); - goto error; - } - - if (threshold == 0) { - ERR("Once after N policy threshold cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_once_after_n_create(threshold); - if (!policy) { - ERR("Failed to create policy once after `%s`.", - fire_once_after_str); - goto error; - } - } - - if (fire_every_str) { - unsigned long long interval; - if (utils_parse_unsigned_long_long(fire_every_str, &interval) != - 0) { - ERR("Failed to parse `%s` as an integer.", - fire_every_str); - goto error; - } - if (interval == 0) { - ERR("Every N policy interval cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_every_n_create(interval); - if (!policy) { - ERR("Failed to create policy every `%s`.", - fire_every_str); - goto error; - } - } - action = create_action_cb(); if (!action) { ERR("Failed to allocate %s session action.", action_name); @@ -1734,8 +1795,7 @@ static const struct argpar_opt_descr snapshot_action_opt_descrs[] = { { OPT_DATA_URL, '\0', "data-url", true }, { OPT_URL, '\0', "url", true }, { OPT_PATH, '\0', "path", true }, - { OPT_FIRE_ONCE_AFTER, '\0', "fire-once-after", true }, - { OPT_FIRE_EVERY, '\0', "fire-every", true }, + { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL }; @@ -1754,8 +1814,6 @@ struct lttng_action *handle_action_snapshot_session(int *argc, char *url_arg = NULL; char *path_arg = NULL; char *error = NULL; - char *fire_once_after_str = NULL; - char *fire_every_str = NULL; enum lttng_action_status action_status; struct lttng_snapshot_output *snapshot_output = NULL; struct lttng_rate_policy *policy = NULL; @@ -1826,27 +1884,14 @@ struct lttng_action *handle_action_snapshot_session(int *argc, } break; - case OPT_FIRE_ONCE_AFTER: - { - if (!assign_string(&fire_once_after_str, - item_opt->arg, - "--fire-once-after")) { - goto error; - } - - break; - } - case OPT_FIRE_EVERY: + case OPT_RATE_POLICY: { - if (!assign_string(&fire_every_str, - item_opt->arg, - "--fire-every")) { + policy = parse_rate_policy(item_opt->arg); + if (!policy) { goto error; } - break; } - default: abort(); } @@ -1910,56 +1955,6 @@ struct lttng_action *handle_action_snapshot_session(int *argc, } } - /* Any rate policy ? */ - if (fire_once_after_str && fire_every_str) { - ERR("--fire-once and --fire-every are mutually exclusive."); - goto error; - } - - if (fire_once_after_str) { - unsigned long long threshold; - - if (utils_parse_unsigned_long_long( - fire_once_after_str, &threshold) != 0) { - ERR("Failed to parse `%s` as an integer.", - fire_once_after_str); - goto error; - } - - if (threshold == 0) { - ERR("Once after N policy threshold cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_once_after_n_create(threshold); - if (!policy) { - ERR("Failed to create policy once after `%s`.", - fire_once_after_str); - goto error; - } - } - - if (fire_every_str) { - unsigned long long interval; - if (utils_parse_unsigned_long_long(fire_every_str, &interval) != - 0) { - ERR("Failed to parse `%s` as an integer.", - fire_every_str); - goto error; - } - if (interval == 0) { - ERR("Every N policy interval cannot be `0`."); - goto error; - } - - policy = lttng_rate_policy_every_n_create(interval); - if (!policy) { - ERR("Failed to create policy every `%s`.", - fire_every_str); - goto error; - } - } - action = lttng_action_snapshot_session_create(); if (!action) { ERR("Failed to allocate snapshot session action."); @@ -2126,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]; @@ -2172,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, }; @@ -2196,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; @@ -2266,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 @@ -2279,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 @@ -2295,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; } @@ -2332,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; } @@ -2342,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); @@ -2388,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; @@ -2402,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; }