X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fadd_trigger.cpp;h=54f41f28bd0344fd29c5ad69b5be7e024a8d42cd;hb=cd9adb8b829564212158943a0d279bb35322ab30;hp=939d510802eddf18420cb80e7d530e94a68cdcee;hpb=48a4000561343808724f7cb5fa8c131877489ccd;p=lttng-tools.git diff --git a/src/bin/lttng/commands/add_trigger.cpp b/src/bin/lttng/commands/add_trigger.cpp index 939d51080..54f41f28b 100644 --- a/src/bin/lttng/commands/add_trigger.cpp +++ b/src/bin/lttng/commands/add_trigger.cpp @@ -5,26 +5,29 @@ * */ +#include "../command.hpp" +#include "../loglevel.hpp" +#include "../uprobe.hpp" +#include "common/argpar-utils/argpar-utils.hpp" +#include "common/argpar/argpar.h" +#include "common/dynamic-array.hpp" +#include "common/mi-lttng.hpp" +#include "common/string-utils/string-utils.hpp" +#include "common/utils.hpp" + +#include + #include +#include #include #include - -#include "../command.h" -#include "../loglevel.h" -#include "../uprobe.h" - -#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 "common/dynamic-array.hpp" +#include "common/filter/filter-ast.hpp" +#include "common/filter/filter-ir.hpp" + +#include #include -#include "common/filter/filter-ast.h" -#include "common/filter/filter-ir.h" -#include "common/dynamic-array.h" #if (LTTNG_SYMBOL_NAME_LEN == 256) #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255" @@ -33,7 +36,7 @@ #ifdef LTTNG_EMBED_HELP static const char help_msg[] = #include -; + ; #endif enum { @@ -80,22 +83,20 @@ static const struct argpar_opt_descr event_rule_opt_descrs[] = { ARGPAR_OPT_DESCR_SENTINEL }; -static -bool has_syscall_prefix(const char *arg) +static bool has_syscall_prefix(const char *arg) { 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; + 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; + 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) { + 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) { + } else if (strncmp(arg, + kernel_syscall_type_opt_prefix, + kernel_syscall_type_opt_prefix_len) == 0) { matches = true; } else { matches = false; @@ -104,8 +105,7 @@ bool has_syscall_prefix(const char *arg) return matches; } -static -bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) +static bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) { bool ret; @@ -116,19 +116,15 @@ bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) 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) { + } 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) { + } 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) { + } 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) { + } 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; @@ -164,8 +160,7 @@ end: return ret; } -static -bool assign_string(char **dest, const char *src, const char *opt_name) +static bool assign_string(char **dest, const char *src, const char *opt_name) { bool ret; @@ -190,8 +185,9 @@ end: return ret; } -static bool parse_syscall_emission_site_from_type(const char *str, - enum lttng_event_rule_kernel_syscall_emission_site *type) +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:"; @@ -205,8 +201,7 @@ static bool parse_syscall_emission_site_from_type(const char *str, str = &str[kernel_prefix_len]; } - if (strcmp(str, "syscall") == 0 || - strcmp(str, "syscall:entry+exit") == 0) { + 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; @@ -232,9 +227,9 @@ error: * Return true if the string was successfully parsed as a log level string. */ static bool parse_log_level_string(const char *str, - enum lttng_event_rule_type event_rule_type, - int *log_level, - bool *log_level_only) + enum lttng_event_rule_type event_rule_type, + int *log_level, + bool *log_level_only) { bool ret; @@ -242,14 +237,12 @@ static bool parse_log_level_string(const char *str, case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: { enum lttng_loglevel log_level_min, log_level_max; - if (!loglevel_parse_range_string( - str, &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) { + if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_EMERG) { goto error; } @@ -260,14 +253,12 @@ static bool parse_log_level_string(const char *str, case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: { enum lttng_loglevel_log4j log_level_min, log_level_max; - if (!loglevel_log4j_parse_range_string( - str, &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) { + if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_LOG4J_FATAL) { goto error; } @@ -278,14 +269,12 @@ static bool parse_log_level_string(const char *str, case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: { enum lttng_loglevel_jul log_level_min, log_level_max; - if (!loglevel_jul_parse_range_string( - str, &log_level_min, &log_level_max)) { + if (!loglevel_jul_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_JUL_SEVERE) { + if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_JUL_SEVERE) { goto error; } @@ -296,15 +285,13 @@ static bool parse_log_level_string(const char *str, case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: { enum lttng_loglevel_python log_level_min, log_level_max; - if (!loglevel_python_parse_range_string( - str, &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) { + log_level_max != LTTNG_LOGLEVEL_PYTHON_CRITICAL) { goto error; } @@ -328,20 +315,18 @@ end: } static int parse_kernel_probe_opts(const char *source, - struct lttng_kernel_probe_location **location) + struct lttng_kernel_probe_location **location) { int ret = 0; int match; char s_hex[19]; char name[LTTNG_SYMBOL_NAME_LEN]; - char *symbol_name = NULL; + char *symbol_name = nullptr; uint64_t offset; /* Check for symbol+offset. */ - match = sscanf(source, - "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API - "[^'+']+%18s", - name, s_hex); + match = sscanf( + source, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "[^'+']+%18s", name, s_hex); if (match == 2) { if (*s_hex == '\0') { ERR("Kernel probe symbol offset is missing."); @@ -353,10 +338,9 @@ static int parse_kernel_probe_opts(const char *source, PERROR("Failed to copy kernel probe location symbol name."); goto error; } - offset = strtoul(s_hex, NULL, 0); + offset = strtoull(s_hex, nullptr, 0); - *location = lttng_kernel_probe_location_symbol_create( - symbol_name, offset); + *location = lttng_kernel_probe_location_symbol_create(symbol_name, offset); if (!*location) { ERR("Failed to create symbol kernel probe location."); goto error; @@ -367,10 +351,7 @@ static int parse_kernel_probe_opts(const char *source, /* Check for symbol. */ if (isalpha(name[0]) || name[0] == '_') { - match = sscanf(source, - "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API - "s", - name); + match = sscanf(source, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "s", name); if (match == 1) { symbol_name = strndup(name, LTTNG_SYMBOL_NAME_LEN); if (!symbol_name) { @@ -378,8 +359,7 @@ static int parse_kernel_probe_opts(const char *source, goto error; } - *location = lttng_kernel_probe_location_symbol_create( - symbol_name, 0); + *location = lttng_kernel_probe_location_symbol_create(symbol_name, 0); if (!*location) { ERR("Failed to create symbol kernel probe location."); goto error; @@ -399,7 +379,7 @@ static int parse_kernel_probe_opts(const char *source, goto error; } - address = strtoul(s_hex, NULL, 0); + address = strtoull(s_hex, nullptr, 0); *location = lttng_kernel_probe_location_address_create(address); if (!*location) { ERR("Failed to create symbol kernel probe location."); @@ -412,23 +392,20 @@ static int parse_kernel_probe_opts(const char *source, error: /* No match */ ret = -1; - *location = NULL; + *location = nullptr; end: free(symbol_name); return ret; } -static -struct lttng_event_expr *ir_op_load_expr_to_event_expr( - const struct ir_load_expression *load_expr, - const char *capture_str) +static struct lttng_event_expr * +ir_op_load_expr_to_event_expr(const struct ir_load_expression *load_expr, const char *capture_str) { - char *provider_name = NULL; - struct lttng_event_expr *event_expr = NULL; + char *provider_name = nullptr; + struct lttng_event_expr *event_expr = nullptr; const struct ir_load_expression_op *load_expr_op = load_expr->child; - const enum ir_load_expression_type load_expr_child_type = - load_expr_op->type; + const enum ir_load_expression_type load_expr_child_type = load_expr_op->type; switch (load_expr_child_type) { case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT: @@ -443,13 +420,14 @@ struct lttng_event_expr *ir_op_load_expr_to_event_expr( LTTNG_ASSERT(field_name); event_expr = load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ? - lttng_event_expr_event_payload_field_create(field_name) : - lttng_event_expr_channel_context_field_create(field_name); + lttng_event_expr_event_payload_field_create(field_name) : + lttng_event_expr_channel_context_field_create(field_name); if (!event_expr) { ERR("Failed to create %s event expression: field name = `%s`.", - load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ? - "payload field" : "channel context", - field_name); + load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ? + "payload field" : + "channel context", + field_name); goto error; } @@ -474,14 +452,14 @@ struct lttng_event_expr *ir_op_load_expr_to_event_expr( colon = strchr(field_name, ':'); if (!colon) { ERR("Invalid app-specific context field name: missing colon in `%s`.", - field_name); + field_name); goto error; } type_name = colon + 1; if (*type_name == '\0') { ERR("Invalid app-specific context field name: missing type name after colon in `%s`.", - field_name); + field_name); goto error; } @@ -491,19 +469,19 @@ struct lttng_event_expr *ir_op_load_expr_to_event_expr( goto error; } - event_expr = lttng_event_expr_app_specific_context_field_create( - provider_name, type_name); + event_expr = lttng_event_expr_app_specific_context_field_create(provider_name, + type_name); if (!event_expr) { ERR("Failed to create app-specific context field event expression: provider name = `%s`, type name = `%s`", - provider_name, type_name); + provider_name, + type_name); goto error; } break; } default: - ERR("%s: unexpected load expr type %d.", __func__, - load_expr_op->type); + ERR("%s: unexpected load expr type %d.", __func__, load_expr_op->type); abort(); } @@ -533,12 +511,13 @@ struct lttng_event_expr *ir_op_load_expr_to_event_expr( break; case IR_LOAD_EXPRESSION_GET_SYMBOL: ERR("While parsing expression `%s`: Capturing subfields is not supported.", - capture_str); + capture_str); goto error; default: - ERR("%s: unexpected load expression operator %s.", __func__, - ir_load_expression_type_str(load_expr_op->type)); + ERR("%s: unexpected load expression operator %s.", + __func__, + ir_load_expression_type_str(load_expr_op->type)); abort(); } @@ -546,7 +525,7 @@ struct lttng_event_expr *ir_op_load_expr_to_event_expr( error: lttng_event_expr_destroy(event_expr); - event_expr = NULL; + event_expr = nullptr; end: free(provider_name); @@ -554,35 +533,30 @@ end: return event_expr; } -static -struct lttng_event_expr *ir_op_load_to_event_expr( - const struct ir_op *ir, const char *capture_str) +static struct lttng_event_expr *ir_op_load_to_event_expr(const struct ir_op *ir, + const char *capture_str) { - struct lttng_event_expr *event_expr = NULL; + struct lttng_event_expr *event_expr = nullptr; LTTNG_ASSERT(ir->op == IR_OP_LOAD); switch (ir->data_type) { case IR_DATA_EXPRESSION: { - const struct ir_load_expression *ir_load_expr = - ir->u.load.u.expression; + const struct ir_load_expression *ir_load_expr = ir->u.load.u.expression; - event_expr = ir_op_load_expr_to_event_expr( - ir_load_expr, capture_str); + event_expr = ir_op_load_expr_to_event_expr(ir_load_expr, capture_str); break; } default: - ERR("%s: unexpected data type: %s.", __func__, - ir_data_type_str(ir->data_type)); + ERR("%s: unexpected data type: %s.", __func__, ir_data_type_str(ir->data_type)); abort(); } return event_expr; } -static -const char *ir_operator_type_human_str(enum ir_op_type op) +static const char *ir_operator_type_human_str(enum ir_op_type op) { const char *name; @@ -603,11 +577,10 @@ const char *ir_operator_type_human_str(enum ir_op_type op) return name; } -static -struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir, - const char *capture_str) +static struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir, + const char *capture_str) { - struct lttng_event_expr *event_expr = NULL; + struct lttng_event_expr *event_expr = nullptr; LTTNG_ASSERT(ir->op == IR_OP_ROOT); ir = ir->u.root.child; @@ -620,24 +593,23 @@ struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir, case IR_OP_UNARY: case IR_OP_LOGICAL: ERR("While parsing expression `%s`: %s operators are not allowed in capture expressions.", - capture_str, - ir_operator_type_human_str(ir->op)); + capture_str, + ir_operator_type_human_str(ir->op)); break; default: - ERR("%s: unexpected IR op type: %s.", __func__, - ir_op_type_str(ir->op)); + ERR("%s: unexpected IR op type: %s.", __func__, ir_op_type_str(ir->op)); abort(); } return event_expr; } -static -void destroy_event_expr(void *ptr) +static void destroy_event_expr(void *ptr) { lttng_event_expr_destroy((lttng_event_expr *) ptr); } +namespace { struct parse_event_rule_res { /* Owned by this. */ struct lttng_event_rule *er; @@ -645,114 +617,99 @@ struct parse_event_rule_res { /* Array of `struct lttng_event_expr *` */ struct lttng_dynamic_pointer_array capture_descriptors; }; +} /* namespace */ -static -struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) +static struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv, int argc_offset) { - enum lttng_event_rule_type event_rule_type = - LTTNG_EVENT_RULE_TYPE_UNKNOWN; - struct argpar_state *state; - struct argpar_item *item = NULL; - char *error = NULL; + enum lttng_event_rule_type event_rule_type = LTTNG_EVENT_RULE_TYPE_UNKNOWN; + struct argpar_iter *argpar_iter = nullptr; + const struct argpar_item *argpar_item = nullptr; int consumed_args = -1; - struct lttng_kernel_probe_location *kernel_probe_location = NULL; - struct lttng_userspace_probe_location *userspace_probe_location = NULL; - struct parse_event_rule_res res = { 0 }; - struct lttng_event_expr *event_expr = NULL; - struct filter_parser_ctx *parser_ctx = NULL; - struct lttng_log_level_rule *log_level_rule = NULL; + struct lttng_kernel_probe_location *kernel_probe_location = nullptr; + struct lttng_userspace_probe_location *userspace_probe_location = nullptr; + struct parse_event_rule_res res = {}; + struct lttng_event_expr *event_expr = nullptr; + struct filter_parser_ctx *parser_ctx = nullptr; + struct lttng_log_level_rule *log_level_rule = nullptr; /* Event rule type option */ - char *event_rule_type_str = NULL; + char *event_rule_type_str = nullptr; /* Tracepoint and syscall options. */ - char *name = NULL; + char *name = nullptr; /* Array of strings. */ struct lttng_dynamic_pointer_array exclude_names; /* For userspace / kernel probe and function. */ - char *location = NULL; - char *event_name = NULL; + char *location = nullptr; + char *event_name = nullptr; /* Filter. */ - char *filter = NULL; + char *filter = nullptr; /* Log level. */ - char *log_level_str = NULL; + char *log_level_str = nullptr; - lttng_dynamic_pointer_array_init(&res.capture_descriptors, - destroy_event_expr); + 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."); + argpar_iter = argpar_iter_create(*argc, *argv, event_rule_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; + enum parse_next_item_status status; - ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_state_parse_next(state, &item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); + status = parse_next_item( + argpar_iter, &argpar_item, argc_offset, *argv, false, nullptr, nullptr); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - /* Just stop parsing here. */ - break; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - LTTNG_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_TYPE: - if (!assign_event_rule_type(&event_rule_type, - item_opt->arg)) { + if (!assign_event_rule_type(&event_rule_type, arg)) { goto error; } /* Save the string for later use. */ - if (!assign_string(&event_rule_type_str, - item_opt->arg, - "--type/-t")) { + if (!assign_string(&event_rule_type_str, arg, "--type/-t")) { goto error; } break; case OPT_LOCATION: - if (!assign_string(&location, - item_opt->arg, - "--location/-L")) { + if (!assign_string(&location, arg, "--location/-L")) { goto error; } break; case OPT_EVENT_NAME: - if (!assign_string(&event_name, - item_opt->arg, - "--event-name/-E")) { + if (!assign_string(&event_name, arg, "--event-name/-E")) { goto error; } break; case OPT_FILTER: - if (!assign_string(&filter, item_opt->arg, - "--filter/-f")) { + if (!assign_string(&filter, arg, "--filter/-f")) { goto error; } break; case OPT_NAME: - if (!assign_string(&name, item_opt->arg, - "--name/-n")) { + if (!assign_string(&name, arg, "--name/-n")) { goto error; } @@ -761,9 +718,8 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) { int ret; - ret = lttng_dynamic_pointer_array_add_pointer( - &exclude_names, - strdup(item_opt->arg)); + ret = lttng_dynamic_pointer_array_add_pointer(&exclude_names, + strdup(arg)); if (ret != 0) { ERR("Failed to add pointer to dynamic pointer array."); goto error; @@ -772,8 +728,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) break; } case OPT_LOG_LEVEL: - if (!assign_string(&log_level_str, - item_opt->arg, "--log-level/-l")) { + if (!assign_string(&log_level_str, arg, "--log-level/-l")) { goto error; } @@ -781,19 +736,17 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) case OPT_CAPTURE: { int ret; - const char *capture_str = item_opt->arg; - ret = filter_parser_ctx_create_from_filter_expression( - capture_str, &parser_ctx); + ret = filter_parser_ctx_create_from_filter_expression(arg, + &parser_ctx); if (ret) { - ERR("Failed to parse capture expression `%s`.", - capture_str); + ERR("Failed to parse capture expression `%s`.", arg); goto error; } - event_expr = ir_op_root_to_event_expr( - parser_ctx->ir_root, - capture_str); + event_expr = ir_op_root_to_event_expr(parser_ctx->ir_root, arg); + filter_parser_ctx_free(parser_ctx); + parser_ctx = nullptr; if (!event_expr) { /* * ir_op_root_to_event_expr has printed @@ -803,8 +756,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } ret = lttng_dynamic_pointer_array_add_pointer( - &res.capture_descriptors, - event_expr); + &res.capture_descriptors, event_expr); if (ret) { goto error; } @@ -813,7 +765,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) * The ownership of event expression was * transferred to the dynamic array. */ - event_expr = NULL; + event_expr = nullptr; break; } @@ -821,12 +773,10 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) abort(); } } else { - const struct argpar_item_non_opt *item_non_opt = - (const struct argpar_item_non_opt *) - item; + const char *arg = argpar_item_non_opt_arg(argpar_item); /* Don't accept non-option arguments. */ - ERR("Unexpected argument '%s'", item_non_opt->arg); + ERR("Unexpected argument '%s'", arg); goto error; } } @@ -856,15 +806,13 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) default: if (name) { ERR("Can't use --name with %s event rules.", - lttng_event_rule_type_str( - event_rule_type)); + lttng_event_rule_type_str(event_rule_type)); goto error; } 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)); + lttng_event_rule_type_str(event_rule_type)); goto error; } } @@ -881,7 +829,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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)); + lttng_event_rule_type_str(event_rule_type)); goto error; } @@ -894,14 +842,13 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) default: if (location) { ERR("Can't use --location with %s event rules.", - lttng_event_rule_type_str(event_rule_type)); + 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)); + lttng_event_rule_type_str(event_rule_type)); goto error; } } @@ -909,7 +856,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) /* * Update *argc and *argv so our caller can keep parsing what follows. */ - consumed_args = argpar_state_get_ingested_orig_args(state); + consumed_args = argpar_iter_ingested_orig_args(argpar_iter); LTTNG_ASSERT(consumed_args >= 0); *argc -= consumed_args; *argv += consumed_args; @@ -930,7 +877,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) break; default: ERR("Filter expressions are not supported for %s event rules.", - lttng_event_rule_type_str(event_rule_type)); + lttng_event_rule_type_str(event_rule_type)); goto error; } } @@ -943,7 +890,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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.", - lttng_event_rule_type_str(event_rule_type)); + lttng_event_rule_type_str(event_rule_type)); goto error; } @@ -974,20 +921,20 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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); + 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); + log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create( + log_level); } - if (log_level_rule == NULL) { + if (log_level_rule == nullptr) { ERR("Failed to create log level rule object."); goto error; } @@ -995,7 +942,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } default: ERR("Log levels are not supported for %s event rules.", - lttng_event_rule_type_str(event_rule_type)); + lttng_event_rule_type_str(event_rule_type)); goto error; } } @@ -1013,21 +960,19 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } /* Set pattern. */ - event_rule_status = lttng_event_rule_user_tracepoint_set_name_pattern( - res.er, 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 user_tracepoint event rule's pattern to '%s'.", - 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_user_tracepoint_set_filter( - res.er, 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 user_tracepoint event rule's filter to '%s'.", - filter); + filter); goto error; } } @@ -1035,32 +980,27 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) /* Set exclusion list. */ if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) { int n; - int count = lttng_dynamic_pointer_array_get_count( - &exclude_names); + int count = lttng_dynamic_pointer_array_get_count(&exclude_names); for (n = 0; n < count; n++) { const char *exclude_name = - (const char *) lttng_dynamic_pointer_array_get_pointer( - &exclude_names, - n); + (const char *) 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) { + 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 user_tracepoint exclusion list element '%s'", - exclude_name); + exclude_name); goto error; } } } if (log_level_rule) { - event_rule_status = - lttng_event_rule_user_tracepoint_set_log_level_rule( - res.er, 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."); @@ -1081,21 +1021,20 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } /* Set pattern. */ - event_rule_status = lttng_event_rule_kernel_tracepoint_set_name_pattern( - res.er, name); + 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); + 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); + 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); + filter); goto error; } } @@ -1112,29 +1051,25 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } /* Set pattern. */ - event_rule_status = lttng_event_rule_jul_logging_set_name_pattern( - res.er, name); + 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); + 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); + 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); + filter); goto error; } } if (log_level_rule) { - event_rule_status = - lttng_event_rule_jul_logging_set_log_level_rule( - res.er, 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."); @@ -1154,29 +1089,26 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } /* Set pattern. */ - event_rule_status = lttng_event_rule_log4j_logging_set_name_pattern( - res.er, name); + 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); + 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); + 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); + filter); goto error; } } if (log_level_rule) { - event_rule_status = - lttng_event_rule_log4j_logging_set_log_level_rule( - res.er, log_level_rule); + event_rule_status = lttng_event_rule_log4j_logging_set_log_level_rule( + res.er, log_level_rule); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set log level on event fule."); @@ -1196,29 +1128,26 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } /* Set pattern. */ - event_rule_status = lttng_event_rule_python_logging_set_name_pattern( - res.er, name); + 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); + 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); + 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); + filter); goto error; } } if (log_level_rule) { - event_rule_status = - lttng_event_rule_python_logging_set_log_level_rule( - res.er, 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."); @@ -1232,8 +1161,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) int ret; enum lttng_event_rule_status event_rule_status; - ret = parse_kernel_probe_opts( - location, &kernel_probe_location); + ret = parse_kernel_probe_opts(location, &kernel_probe_location); if (ret) { ERR("Failed to parse kernel probe location."); goto error; @@ -1247,11 +1175,9 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } event_rule_status = - lttng_event_rule_kernel_kprobe_set_event_name( - res.er, event_name); + lttng_event_rule_kernel_kprobe_set_event_name(res.er, event_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set kprobe event rule's name to '%s'.", - event_name); + ERR("Failed to set kprobe event rule's name to '%s'.", event_name); goto error; } @@ -1262,8 +1188,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) int ret; enum lttng_event_rule_status event_rule_status; - ret = parse_userspace_probe_opts( - location, &userspace_probe_location); + ret = parse_userspace_probe_opts(location, &userspace_probe_location); if (ret) { ERR("Failed to parse user space probe location."); goto error; @@ -1276,11 +1201,10 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } event_rule_status = - lttng_event_rule_kernel_uprobe_set_event_name( - res.er, event_name); + lttng_event_rule_kernel_uprobe_set_event_name(res.er, event_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set user space probe event rule's name to '%s'.", - event_name); + event_name); goto error; } @@ -1291,8 +1215,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) enum lttng_event_rule_status event_rule_status; enum lttng_event_rule_kernel_syscall_emission_site emission_site; - if (!parse_syscall_emission_site_from_type( - event_rule_type_str, &emission_site)) { + 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; } @@ -1303,20 +1226,17 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern( - res.er, 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'.", - name); + ERR("Failed to set syscall event rule's pattern to '%s'.", name); goto error; } if (filter) { - event_rule_status = lttng_event_rule_kernel_syscall_set_filter( - res.er, 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'.", - filter); + ERR("Failed to set syscall event rule's filter to '%s'.", filter); goto error; } } @@ -1332,7 +1252,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) error: lttng_event_rule_destroy(res.er); - res.er = NULL; + res.er = nullptr; lttng_dynamic_pointer_array_reset(&res.capture_descriptors); end: @@ -1341,9 +1261,8 @@ end: } lttng_event_expr_destroy(event_expr); - argpar_item_destroy(item); - free(error); - argpar_state_destroy(state); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); free(filter); free(name); lttng_dynamic_pointer_array_reset(&exclude_names); @@ -1358,37 +1277,35 @@ end: return res; } -static -struct lttng_condition *handle_condition_event(int *argc, const char ***argv) +static struct lttng_condition * +handle_condition_event(int *argc, const char ***argv, int argc_offset) { struct parse_event_rule_res res; struct lttng_condition *c; size_t i; - res = parse_event_rule(argc, argv); + res = parse_event_rule(argc, argv, argc_offset); if (!res.er) { - c = NULL; + c = nullptr; goto error; } c = lttng_condition_event_rule_matches_create(res.er); lttng_event_rule_destroy(res.er); - res.er = NULL; + res.er = nullptr; if (!c) { goto error; } - for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors); - i++) { + 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_event_expr **) lttng_dynamic_array_get_element( - &res.capture_descriptors.array, i); + (lttng_event_expr **) lttng_dynamic_array_get_element( + &res.capture_descriptors.array, i); LTTNG_ASSERT(expr); LTTNG_ASSERT(*expr); - status = lttng_condition_event_rule_matches_append_capture_descriptor( - c, *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"); @@ -1398,14 +1315,14 @@ struct lttng_condition *handle_condition_event(int *argc, const char ***argv) } /* Ownership of event expression moved to `c` */ - *expr = NULL; + *expr = nullptr; } goto end; error: lttng_condition_destroy(c); - c = NULL; + c = nullptr; end: lttng_dynamic_pointer_array_reset(&res.capture_descriptors); @@ -1413,23 +1330,38 @@ end: return c; } +namespace { struct condition_descr { const char *name; - struct lttng_condition *(*handler) (int *argc, const char ***argv); + struct lttng_condition *(*handler)(int *argc, const char ***argv, int argc_offset); }; +} /* namespace */ -static const -struct condition_descr condition_descrs[] = { +static const struct condition_descr condition_descrs[] = { { "event-rule-matches", handle_condition_event }, }; -static -struct lttng_condition *parse_condition(const char *condition_name, int *argc, - const char ***argv) +static void print_valid_condition_names() +{ + unsigned int i; + + ERR("Valid condition names are:"); + + for (i = 0; i < ARRAY_SIZE(condition_descrs); ++i) { + ERR(" %s", condition_descrs[i].name); + } +} + +static struct lttng_condition *parse_condition(const char *condition_name, + int *argc, + const char ***argv, + int argc_offset, + int orig_arg_index, + const char *orig_arg) { int i; struct lttng_condition *cond; - const struct condition_descr *descr = NULL; + const struct condition_descr *descr = nullptr; for (i = 0; i < ARRAY_SIZE(condition_descrs); i++) { if (strcmp(condition_name, condition_descrs[i].name) == 0) { @@ -1439,11 +1371,15 @@ struct lttng_condition *parse_condition(const char *condition_name, int *argc, } if (!descr) { - ERR("Unknown condition name '%s'", condition_name); + ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown condition name '%s'", + orig_arg_index + 1, + orig_arg, + condition_name); + print_valid_condition_names(); goto error; } - cond = descr->handler(argc, argv); + cond = descr->handler(argc, argv, argc_offset); if (!cond) { /* The handler has already printed an error message. */ goto error; @@ -1451,7 +1387,7 @@ struct lttng_condition *parse_condition(const char *condition_name, int *argc, goto end; error: - cond = NULL; + cond = nullptr; end: return cond; } @@ -1461,17 +1397,17 @@ 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; + struct lttng_rate_policy *policy = nullptr; enum lttng_rate_policy_type policy_type; unsigned long long value; char *policy_type_str; char *policy_value_str; LTTNG_ASSERT(policy_str); - lttng_dynamic_pointer_array_init(&tokens, NULL); + lttng_dynamic_pointer_array_init(&tokens, nullptr); /* Rate policy fields are separated by ':'. */ - ret = strutils_split(policy_str, ':', 1, &tokens); + ret = strutils_split(policy_str, ':', true, &tokens); if (ret == 0) { num_token = lttng_dynamic_pointer_array_get_count(&tokens); } @@ -1500,8 +1436,7 @@ static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) /* 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); + ERR("Failed to parse rate policy value `%s` as an integer.", policy_value_str); goto end; } @@ -1521,7 +1456,7 @@ static struct lttng_rate_policy *parse_rate_policy(const char *policy_str) abort(); } - if (policy == NULL) { + if (policy == nullptr) { ERR("Failed to create rate policy `%s`.", policy_str); } @@ -1531,50 +1466,49 @@ end: } static const struct argpar_opt_descr notify_action_opt_descrs[] = { - { OPT_RATE_POLICY, '\0', "rate-policy", true }, - ARGPAR_OPT_DESCR_SENTINEL + { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL }; -static -struct lttng_action *handle_action_notify(int *argc, const char ***argv) +static struct lttng_action *handle_action_notify(int *argc, const char ***argv, int argc_offset) { - struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; - char *error = NULL; - struct lttng_rate_policy *policy = NULL; - - state = argpar_state_create(*argc, *argv, notify_action_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + struct lttng_action *action = nullptr; + struct argpar_iter *argpar_iter = nullptr; + const struct argpar_item *argpar_item = nullptr; + struct lttng_rate_policy *policy = nullptr; + + argpar_iter = argpar_iter_create(*argc, *argv, notify_action_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; - - 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) { + enum parse_next_item_status status; + + status = parse_next_item(argpar_iter, + &argpar_item, + argc_offset, + *argv, + false, + nullptr, + "While parsing `notify` action:"); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { + goto error; + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - LTTNG_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1584,23 +1518,15 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; - - LTTNG_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + const char *arg = argpar_item_non_opt_arg(argpar_item); - item_non_opt = (const struct argpar_item_non_opt *) item; - - switch (item_non_opt->non_opt_index) { - default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); - goto error; - } + ERR("Unexpected argument `%s`.", arg); + goto error; } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); action = lttng_action_notify_create(); if (!action) { @@ -1621,12 +1547,11 @@ struct lttng_action *handle_action_notify(int *argc, const char ***argv) error: lttng_action_destroy(action); - action = NULL; + action = nullptr; end: - free(error); lttng_rate_policy_destroy(policy); - argpar_state_destroy(state); - argpar_item_destroy(item); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } @@ -1635,63 +1560,64 @@ end: * optional rate policy. */ -static struct lttng_action *handle_action_simple_session_with_policy(int *argc, - const char ***argv, - struct lttng_action *(*create_action_cb)(void), - enum lttng_action_status (*set_session_name_cb)( - struct lttng_action *, const char *), - enum lttng_action_status (*set_rate_policy_cb)( - struct lttng_action *, - const struct lttng_rate_policy *), - const char *action_name) +static struct lttng_action *handle_action_simple_session_with_policy( + int *argc, + const char ***argv, + int argc_offset, + struct lttng_action *(*create_action_cb)(), + enum lttng_action_status (*set_session_name_cb)(struct lttng_action *, const char *), + enum lttng_action_status (*set_rate_policy_cb)(struct lttng_action *, + const struct lttng_rate_policy *), + const char *action_name) { - struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; - const char *session_name_arg = NULL; - char *error = NULL; + struct lttng_action *action = nullptr; + struct argpar_iter *argpar_iter = nullptr; + const struct argpar_item *argpar_item = nullptr; + const char *session_name_arg = nullptr; enum lttng_action_status action_status; - struct lttng_rate_policy *policy = NULL; + struct lttng_rate_policy *policy = nullptr; LTTNG_ASSERT(set_session_name_cb); LTTNG_ASSERT(set_rate_policy_cb); const struct argpar_opt_descr rate_policy_opt_descrs[] = { - { OPT_RATE_POLICY, '\0', "rate-policy", true }, - ARGPAR_OPT_DESCR_SENTINEL + { 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."); + argpar_iter = argpar_iter_create(*argc, *argv, rate_policy_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; - - 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) { + enum parse_next_item_status status; + + status = parse_next_item(argpar_iter, + &argpar_item, + argc_offset, + *argv, + false, + nullptr, + "While parsing `%s` action:", + action_name); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { + goto error; + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - LTTNG_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; + LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK); + + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1701,23 +1627,22 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; - item_non_opt = (const struct argpar_item_non_opt *) item; + const char *arg = argpar_item_non_opt_arg(argpar_item); + unsigned int idx = argpar_item_non_opt_non_opt_index(argpar_item); - switch (item_non_opt->non_opt_index) { + switch (idx) { case 0: - session_name_arg = item_non_opt->arg; + session_name_arg = arg; break; default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); + ERR("Unexpected argument `%s`.", arg); goto error; } } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); if (!session_name_arg) { ERR("Missing session name."); @@ -1733,7 +1658,8 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, action_status = set_session_name_cb(action, session_name_arg); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to set action %s session's session name to '%s'.", - action_name, session_name_arg); + action_name, + session_name_arg); goto error; } @@ -1749,40 +1675,46 @@ static struct lttng_action *handle_action_simple_session_with_policy(int *argc, error: lttng_action_destroy(action); - action = NULL; - argpar_item_destroy(item); + action = nullptr; + end: lttng_rate_policy_destroy(policy); - free(error); - argpar_state_destroy(state); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } -static -struct lttng_action *handle_action_start_session(int *argc, - const char ***argv) +static struct lttng_action * +handle_action_start_session(int *argc, const char ***argv, int argc_offset) { - return handle_action_simple_session_with_policy(argc, argv, - lttng_action_start_session_create, - lttng_action_start_session_set_session_name, - lttng_action_start_session_set_rate_policy, "start"); + return handle_action_simple_session_with_policy(argc, + argv, + argc_offset, + lttng_action_start_session_create, + lttng_action_start_session_set_session_name, + lttng_action_start_session_set_rate_policy, + "start"); } -static -struct lttng_action *handle_action_stop_session(int *argc, - const char ***argv) +static struct lttng_action * +handle_action_stop_session(int *argc, const char ***argv, int argc_offset) { - return handle_action_simple_session_with_policy(argc, argv, - lttng_action_stop_session_create, - lttng_action_stop_session_set_session_name, - lttng_action_stop_session_set_rate_policy, "stop"); + return handle_action_simple_session_with_policy(argc, + argv, + argc_offset, + lttng_action_stop_session_create, + lttng_action_stop_session_set_session_name, + lttng_action_stop_session_set_rate_policy, + "stop"); } -static -struct lttng_action *handle_action_rotate_session(int *argc, - const char ***argv) +static struct lttng_action * +handle_action_rotate_session(int *argc, const char ***argv, int argc_offset) { - return handle_action_simple_session_with_policy(argc, argv, + return handle_action_simple_session_with_policy( + argc, + argv, + argc_offset, lttng_action_rotate_session_create, lttng_action_rotate_session_set_session_name, lttng_action_rotate_session_set_rate_policy, @@ -1800,94 +1732,95 @@ static const struct argpar_opt_descr snapshot_action_opt_descrs[] = { ARGPAR_OPT_DESCR_SENTINEL }; -static -struct lttng_action *handle_action_snapshot_session(int *argc, - const char ***argv) +static struct lttng_action * +handle_action_snapshot_session(int *argc, const char ***argv, int argc_offset) { - struct lttng_action *action = NULL; - struct argpar_state *state = NULL; - struct argpar_item *item = NULL; - const char *session_name_arg = NULL; - char *snapshot_name_arg = NULL; - char *ctrl_url_arg = NULL; - char *data_url_arg = NULL; - char *max_size_arg = NULL; - char *url_arg = NULL; - char *path_arg = NULL; - char *error = NULL; + struct lttng_action *action = nullptr; + struct argpar_iter *argpar_iter = nullptr; + const struct argpar_item *argpar_item = nullptr; + const char *session_name_arg = nullptr; + char *snapshot_name_arg = nullptr; + char *ctrl_url_arg = nullptr; + char *data_url_arg = nullptr; + char *max_size_arg = nullptr; + char *url_arg = nullptr; + char *path_arg = nullptr; + char *error = nullptr; enum lttng_action_status action_status; - struct lttng_snapshot_output *snapshot_output = NULL; - struct lttng_rate_policy *policy = NULL; + struct lttng_snapshot_output *snapshot_output = nullptr; + struct lttng_rate_policy *policy = nullptr; int ret; unsigned int locations_specified = 0; - state = argpar_state_create(*argc, *argv, snapshot_action_opt_descrs); - if (!state) { - ERR("Failed to allocate an argpar state."); + argpar_iter = argpar_iter_create(*argc, *argv, snapshot_action_opt_descrs); + if (!argpar_iter) { + ERR("Failed to allocate an argpar iter."); goto error; } while (true) { - enum argpar_state_parse_next_status status; - - 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) { + enum parse_next_item_status status; + + status = parse_next_item(argpar_iter, + &argpar_item, + argc_offset, + *argv, + false, + nullptr, + "While parsing `snapshot` action:"); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR || + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { + goto error; + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - LTTNG_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK); - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_item_opt *item_opt = - (const struct argpar_item_opt *) item; + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item); + const char *arg = argpar_item_opt_arg(argpar_item); - switch (item_opt->descr->id) { + switch (descr->id) { case OPT_NAME: - if (!assign_string(&snapshot_name_arg, item_opt->arg, "--name/-n")) { + if (!assign_string(&snapshot_name_arg, arg, "--name/-n")) { goto error; } break; case OPT_MAX_SIZE: - if (!assign_string(&max_size_arg, item_opt->arg, "--max-size/-m")) { + if (!assign_string(&max_size_arg, arg, "--max-size/-m")) { goto error; } break; case OPT_CTRL_URL: - if (!assign_string(&ctrl_url_arg, item_opt->arg, "--ctrl-url")) { + if (!assign_string(&ctrl_url_arg, arg, "--ctrl-url")) { goto error; } break; case OPT_DATA_URL: - if (!assign_string(&data_url_arg, item_opt->arg, "--data-url")) { + if (!assign_string(&data_url_arg, arg, "--data-url")) { goto error; } break; case OPT_URL: - if (!assign_string(&url_arg, item_opt->arg, "--url")) { + if (!assign_string(&url_arg, arg, "--url")) { goto error; } break; case OPT_PATH: - if (!assign_string(&path_arg, item_opt->arg, "--path")) { + if (!assign_string(&path_arg, arg, "--path")) { goto error; } break; case OPT_RATE_POLICY: { - policy = parse_rate_policy(item_opt->arg); + policy = parse_rate_policy(arg); if (!policy) { goto error; } @@ -1897,26 +1830,22 @@ struct lttng_action *handle_action_snapshot_session(int *argc, abort(); } } else { - const struct argpar_item_non_opt *item_non_opt; - - LTTNG_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + const char *arg = argpar_item_non_opt_arg(argpar_item); + const unsigned int idx = argpar_item_non_opt_non_opt_index(argpar_item); - item_non_opt = (const struct argpar_item_non_opt *) item; - - switch (item_non_opt->non_opt_index) { + switch (idx) { case 0: - session_name_arg = item_non_opt->arg; + session_name_arg = arg; break; default: - ERR("Unexpected argument `%s`.", - item_non_opt->arg); + ERR("Unexpected argument `%s`.", arg); goto error; } } } - *argc -= argpar_state_get_ingested_orig_args(state); - *argv += argpar_state_get_ingested_orig_args(state); + *argc -= argpar_iter_ingested_orig_args(argpar_iter); + *argv += argpar_iter_ingested_orig_args(argpar_iter); if (!session_name_arg) { ERR("Missing session name."); @@ -1962,11 +1891,10 @@ struct lttng_action *handle_action_snapshot_session(int *argc, goto error; } - action_status = lttng_action_snapshot_session_set_session_name( - action, session_name_arg); + action_status = lttng_action_snapshot_session_set_session_name(action, session_name_arg); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to set action snapshot session's session name to '%s'.", - session_name_arg); + session_name_arg); goto error; } @@ -1976,8 +1904,7 @@ struct lttng_action *handle_action_snapshot_session(int *argc, goto error; } - ret = lttng_snapshot_output_set_name( - snapshot_name_arg, snapshot_output); + ret = lttng_snapshot_output_set_name(snapshot_name_arg, snapshot_output); if (ret != 0) { ERR("Failed to set name of snapshot output."); goto error; @@ -2001,7 +1928,7 @@ struct lttng_action *handle_action_snapshot_session(int *argc, ret = lttng_snapshot_output_set_size(max_size, snapshot_output); if (ret != 0) { ERR("Failed to set snapshot output's max size to %" PRIu64 " bytes.", - max_size); + max_size); goto error; } } @@ -2015,36 +1942,32 @@ struct lttng_action *handle_action_snapshot_session(int *argc, goto error; } - num_uris = uri_parse_str_urls(url_arg, NULL, &uris); + num_uris = uri_parse_str_urls(url_arg, nullptr, &uris); if (num_uris < 1) { ERR("Failed to parse '%s' as an URL.", url_arg); goto error; } if (uris[0].dtype == LTTNG_DST_PATH) { - ret = lttng_snapshot_output_set_local_path( - uris[0].dst.path, snapshot_output); + ret = lttng_snapshot_output_set_local_path(uris[0].dst.path, + snapshot_output); free(uris); if (ret != 0) { - ERR("Failed to assign '%s' as a local destination.", - url_arg); + ERR("Failed to assign '%s' as a local destination.", url_arg); goto error; } } else { - ret = lttng_snapshot_output_set_network_url( - url_arg, snapshot_output); + ret = lttng_snapshot_output_set_network_url(url_arg, snapshot_output); free(uris); if (ret != 0) { - ERR("Failed to assign '%s' as a network URL.", - url_arg); + ERR("Failed to assign '%s' as a network URL.", url_arg); goto error; } } } if (path_arg) { - ret = lttng_snapshot_output_set_local_path( - path_arg, snapshot_output); + ret = lttng_snapshot_output_set_local_path(path_arg, snapshot_output); if (ret != 0) { ERR("Failed to parse '%s' as a local path.", path_arg); goto error; @@ -2057,30 +1980,29 @@ struct lttng_action *handle_action_snapshot_session(int *argc, * data URLs. */ ret = lttng_snapshot_output_set_network_urls( - ctrl_url_arg, data_url_arg, snapshot_output); + ctrl_url_arg, data_url_arg, snapshot_output); if (ret != 0) { ERR("Failed to parse `%s` and `%s` as control and data URLs.", - ctrl_url_arg, data_url_arg); + ctrl_url_arg, + data_url_arg); goto error; } } if (snapshot_output) { - action_status = lttng_action_snapshot_session_set_output( - action, snapshot_output); + action_status = lttng_action_snapshot_session_set_output(action, snapshot_output); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to set snapshot session action's output."); goto error; } /* Ownership of `snapshot_output` has been transferred to the action. */ - snapshot_output = NULL; + snapshot_output = nullptr; } if (policy) { enum lttng_action_status status; - status = lttng_action_snapshot_session_set_rate_policy( - action, policy); + status = lttng_action_snapshot_session_set_rate_policy(action, policy); if (status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to set rate policy"); goto error; @@ -2091,7 +2013,7 @@ struct lttng_action *handle_action_snapshot_session(int *argc, error: lttng_action_destroy(action); - action = NULL; + action = nullptr; free(error); end: free(snapshot_name_arg); @@ -2102,18 +2024,19 @@ end: free(snapshot_output); free(max_size_arg); lttng_rate_policy_destroy(policy); - argpar_state_destroy(state); - argpar_item_destroy(item); + argpar_item_destroy(argpar_item); + argpar_iter_destroy(argpar_iter); return action; } +namespace { struct action_descr { const char *name; - struct lttng_action *(*handler) (int *argc, const char ***argv); + struct lttng_action *(*handler)(int *argc, const char ***argv, int argc_offset); }; +} /* namespace */ -static const -struct action_descr action_descrs[] = { +static const struct action_descr action_descrs[] = { { "notify", handle_action_notify }, { "start-session", handle_action_start_session }, { "stop-session", handle_action_stop_session }, @@ -2121,12 +2044,27 @@ struct action_descr action_descrs[] = { { "snapshot-session", handle_action_snapshot_session }, }; -static -struct lttng_action *parse_action(const char *action_name, int *argc, const char ***argv) +static void print_valid_action_names() +{ + unsigned int i; + + ERR("Valid action names are:"); + + for (i = 0; i < ARRAY_SIZE(condition_descrs); ++i) { + ERR(" %s", action_descrs[i].name); + } +} + +static struct lttng_action *parse_action(const char *action_name, + int *argc, + const char ***argv, + int argc_offset, + int orig_arg_index, + const char *orig_arg) { int i; struct lttng_action *action; - const struct action_descr *descr = NULL; + const struct action_descr *descr = nullptr; for (i = 0; i < ARRAY_SIZE(action_descrs); i++) { if (strcmp(action_name, action_descrs[i].name) == 0) { @@ -2136,11 +2074,15 @@ struct lttng_action *parse_action(const char *action_name, int *argc, const char } if (!descr) { - ERR("Unknown action name: %s", action_name); + ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown action name '%s'", + orig_arg_index + 1, + orig_arg, + action_name); + print_valid_action_names(); goto error; } - action = descr->handler(argc, argv); + action = descr->handler(argc, argv, argc_offset); if (!action) { /* The handler has already printed an error message. */ goto error; @@ -2148,13 +2090,12 @@ struct lttng_action *parse_action(const char *action_name, int *argc, const char goto end; error: - action = NULL; + action = nullptr; end: return action; } -static const -struct argpar_opt_descr add_trigger_options[] = { +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", true }, @@ -2164,8 +2105,7 @@ struct argpar_opt_descr add_trigger_options[] = { ARGPAR_OPT_DESCR_SENTINEL, }; -static -void lttng_actions_destructor(void *p) +static void lttng_actions_destructor(void *p) { struct lttng_action *action = (lttng_action *) p; @@ -2177,41 +2117,38 @@ int cmd_add_trigger(int argc, const char **argv) int ret; int my_argc = argc - 1; const char **my_argv = argv + 1; - struct lttng_condition *condition = NULL; + struct lttng_condition *condition = nullptr; struct lttng_dynamic_pointer_array actions; - struct argpar_state *argpar_state = NULL; - struct argpar_item *argpar_item = NULL; - struct lttng_action *action_list = NULL; - struct lttng_action *action = NULL; - struct lttng_trigger *trigger = NULL; - char *error = NULL; - char *name = NULL; + struct argpar_iter *argpar_iter = nullptr; + const struct argpar_item *argpar_item = nullptr; + const struct argpar_error *argpar_error = nullptr; + struct lttng_action *action_list = nullptr; + struct lttng_action *action = nullptr; + struct lttng_trigger *trigger = nullptr; + char *name = nullptr; int i; - char *owner_uid = NULL; + char *owner_uid = nullptr; enum lttng_error_code ret_code; - struct mi_writer *mi_writer = NULL; + struct mi_writer *mi_writer = nullptr; lttng_dynamic_pointer_array_init(&actions, lttng_actions_destructor); if (lttng_opt_mi) { - mi_writer = mi_lttng_writer_create( - fileno(stdout), 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); + 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); + ret = mi_lttng_writer_open_element(mi_writer, mi_lttng_element_command_output); if (ret) { ret = CMD_ERROR; goto error; @@ -2219,50 +2156,59 @@ int cmd_add_trigger(int argc, const char **argv) } while (true) { - enum argpar_state_parse_next_status status; - const struct argpar_item_opt *item_opt; + enum parse_next_item_status status; int ingested_args; + const struct argpar_opt_descr *descr; + const char *arg; + + argpar_iter_destroy(argpar_iter); + argpar_iter = argpar_iter_create(my_argc, my_argv, add_trigger_options); + if (!argpar_iter) { + ERR("Failed to create argpar iter."); + goto error; + } + + status = parse_next_item(argpar_iter, + &argpar_item, + argc - my_argc, + my_argv, + true, + &argpar_error, + nullptr); + if (status == PARSE_NEXT_ITEM_STATUS_ERROR) { + if (argpar_error_type(argpar_error) == ARGPAR_ERROR_TYPE_MISSING_OPT_ARG) { + int opt_id = argpar_error_opt_descr(argpar_error, nullptr)->id; + + if (opt_id == OPT_CONDITION) { + print_valid_condition_names(); + } else if (opt_id == OPT_ACTION) { + print_valid_action_names(); + } + } - argpar_state_destroy(argpar_state); - argpar_state = argpar_state_create(my_argc, my_argv, - add_trigger_options); - if (!argpar_state) { - ERR("Failed to create argpar state."); - goto error; - } - - ARGPAR_ITEM_DESTROY_AND_RESET(argpar_item); - status = argpar_state_parse_next(argpar_state, &argpar_item, &error); - if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) { - ERR("%s", error); goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { - ERR("%s", error); + } else if (status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; - } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) { + } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; } - LTTNG_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); + LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK); - if (argpar_item->type == ARGPAR_ITEM_TYPE_NON_OPT) { - const struct argpar_item_non_opt *item_non_opt = - (const struct argpar_item_non_opt *) - argpar_item; - - ERR("Unexpected argument `%s`.", item_non_opt->arg); + if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_NON_OPT) { + ERR("Unexpected argument `%s`.", argpar_item_non_opt_arg(argpar_item)); goto error; } - item_opt = (const struct argpar_item_opt *) argpar_item; - - ingested_args = argpar_state_get_ingested_orig_args( - argpar_state); + ingested_args = argpar_iter_ingested_orig_args(argpar_iter); my_argc -= ingested_args; my_argv += ingested_args; - switch (item_opt->descr->id) { + descr = argpar_item_opt_descr(argpar_item); + arg = argpar_item_opt_arg(argpar_item); + + switch (descr->id) { case OPT_HELP: SHOW_HELP(); ret = 0; @@ -2278,7 +2224,12 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - condition = parse_condition(item_opt->arg, &my_argc, &my_argv); + condition = parse_condition(arg, + &my_argc, + &my_argv, + argc - my_argc, + argc - my_argc - ingested_args, + my_argv[-ingested_args]); if (!condition) { /* * An error message was already printed by @@ -2291,7 +2242,12 @@ int cmd_add_trigger(int argc, const char **argv) } case OPT_ACTION: { - action = parse_action(item_opt->arg, &my_argc, &my_argv); + action = parse_action(arg, + &my_argc, + &my_argv, + argc - my_argc, + argc - my_argc - ingested_args, + my_argv[-ingested_args]); if (!action) { /* * An error message was already printed by @@ -2300,21 +2256,20 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - ret = lttng_dynamic_pointer_array_add_pointer( - &actions, action); + ret = lttng_dynamic_pointer_array_add_pointer(&actions, action); if (ret) { ERR("Failed to add pointer to pointer array."); goto error; } /* Ownership of the action was transferred to the list. */ - action = NULL; + action = nullptr; break; } case OPT_NAME: { - if (!assign_string(&name, item_opt->arg, "--name")) { + if (!assign_string(&name, arg, "--name")) { goto error; } @@ -2322,8 +2277,7 @@ int cmd_add_trigger(int argc, const char **argv) } case OPT_OWNER_UID: { - if (!assign_string(&owner_uid, item_opt->arg, - "--owner-uid")) { + if (!assign_string(&owner_uid, arg, "--owner-uid")) { goto error; } @@ -2364,7 +2318,7 @@ int cmd_add_trigger(int argc, const char **argv) * the action. We can destroy ours. */ lttng_action_destroy(action); - action = NULL; + action = nullptr; } trigger = lttng_trigger_create(condition, action_list); @@ -2398,21 +2352,19 @@ int cmd_add_trigger(int argc, const char **argv) } if (ret_code != LTTNG_OK) { - ERR("Failed to register trigger: %s.", - lttng_strerror(-ret_code)); + ERR("Failed to register trigger: %s.", lttng_strerror(-ret_code)); goto error; } if (lttng_opt_mi) { - ret_code = lttng_trigger_mi_serialize(trigger, mi_writer, NULL); + ret_code = lttng_trigger_mi_serialize(trigger, mi_writer, nullptr); 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); + lttng_trigger_get_name(trigger, &returned_trigger_name); if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { WARN("Failed to retrieve the added trigger's name."); @@ -2440,8 +2392,8 @@ end: goto cleanup; } - mi_ret = mi_lttng_writer_write_element_bool(mi_writer, - mi_lttng_element_command_success, ret ? 0 : 1); + 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; @@ -2456,14 +2408,14 @@ end: } cleanup: - argpar_state_destroy(argpar_state); + argpar_error_destroy(argpar_error); + argpar_iter_destroy(argpar_iter); argpar_item_destroy(argpar_item); lttng_dynamic_pointer_array_reset(&actions); lttng_condition_destroy(condition); lttng_action_destroy(action_list); lttng_action_destroy(action); lttng_trigger_destroy(trigger); - free(error); free(name); free(owner_uid); if (mi_writer && mi_lttng_writer_destroy(mi_writer)) {