X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fadd_trigger.c;h=27a666c5da97dba8c8ab900d336ef7229f5f0184;hp=d88fa0cf921c143b443ac76b0bb531a225ecaf44;hb=7f4d5b07cf7be895b38b69073389a4fcc318ec29;hpb=d602bd6a8ee25d5ca662dde4edb3db3cabf264e1 diff --git a/src/bin/lttng/commands/add_trigger.c b/src/bin/lttng/commands/add_trigger.c index d88fa0cf9..27a666c5d 100644 --- a/src/bin/lttng/commands/add_trigger.c +++ b/src/bin/lttng/commands/add_trigger.c @@ -541,6 +541,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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; /* Was the -a/--all flag provided? */ bool all_events = false; @@ -627,7 +628,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) /* Event rule types */ case OPT_FUNCTION: if (!assign_event_rule_type(&event_rule_type, - LTTNG_EVENT_RULE_TYPE_KRETPROBE)) { + LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION)) { goto error; } @@ -818,7 +819,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) /* Validate event rule type against domain. */ switch (event_rule_type) { case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: - case LTTNG_EVENT_RULE_TYPE_KRETPROBE: + 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) { @@ -938,15 +939,20 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } if (loglevel_only) { - event_rule_status = lttng_event_rule_tracepoint_set_log_level( - res.er, - loglevel); + log_level_rule = lttng_log_level_rule_exactly_create(loglevel); } else { - event_rule_status = lttng_event_rule_tracepoint_set_log_level_range_lower_bound( - res.er, - loglevel); + log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(loglevel); + } + + if (log_level_rule == NULL) { + ERR("Failed to create log level rule object."); + goto error; } + event_rule_status = + lttng_event_rule_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; @@ -960,11 +966,6 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) int ret; enum lttng_event_rule_status event_rule_status; - res.er = lttng_event_rule_kernel_probe_create(); - if (!res.er) { - ERR("Failed to create kprobe event rule."); - goto error; - } ret = parse_kernel_probe_opts(source, &kernel_probe_location); if (ret) { @@ -972,16 +973,16 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - event_rule_status = lttng_event_rule_kernel_probe_set_name(res.er, tracepoint_name); - if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set kprobe event rule's name to '%s'.", tracepoint_name); + assert(kernel_probe_location); + res.er = lttng_event_rule_kernel_probe_create(kernel_probe_location); + if (!res.er) { + ERR("Failed to create kprobe event rule."); goto error; } - assert(kernel_probe_location); - event_rule_status = lttng_event_rule_kernel_probe_set_location(res.er, kernel_probe_location); + event_rule_status = lttng_event_rule_kernel_probe_set_event_name(res.er, tracepoint_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set kprobe event rule's location."); + ERR("Failed to set kprobe event rule's name to '%s'.", tracepoint_name); goto error; } @@ -999,20 +1000,13 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - res.er = lttng_event_rule_userspace_probe_create(); + res.er = lttng_event_rule_userspace_probe_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_location( - res.er, userspace_probe_location); - if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { - ERR("Failed to set user space probe event rule's location."); - goto error; - } - - event_rule_status = lttng_event_rule_userspace_probe_set_name( + event_rule_status = lttng_event_rule_userspace_probe_set_event_name( res.er, tracepoint_name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set user space probe event rule's name to '%s'.", @@ -1080,6 +1074,7 @@ end: strutils_free_null_terminated_array_of_strings(exclusion_list); 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; } @@ -1340,38 +1335,209 @@ error: end: return cond; } +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 }, + ARGPAR_OPT_DESCR_SENTINEL +}; static struct lttng_action *handle_action_notify(int *argc, const char ***argv) { - return lttng_action_notify_create(); -} + struct lttng_action *action = NULL; + 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; -static const struct argpar_opt_descr no_opt_descrs[] = { - ARGPAR_OPT_DESCR_SENTINEL -}; + state = argpar_state_create(*argc, *argv, notify_action_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) { + 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: + { + if (!assign_string(&fire_every_str, + item_opt->arg, + "--fire-every")) { + goto error; + } + + break; + } + + 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) { + 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 (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"); + goto error; + } + + if (policy) { + enum lttng_action_status status; + status = lttng_action_notify_set_rate_policy(action, policy); + if (status != LTTNG_ACTION_STATUS_OK) { + ERR("Failed to set rate policy"); + goto error; + } + } + + goto end; + +error: + lttng_action_destroy(action); + action = NULL; + free(error); +end: + free(fire_once_after_str); + free(fire_every_str); + lttng_rate_policy_destroy(policy); + argpar_state_destroy(state); + argpar_item_destroy(item); + return action; +} /* - * Generic handler for a kind of action that takes a session name as its sole - * argument. + * Generic handler for a kind of action that takes a session name and an + * optional rate policy. */ -static -struct lttng_action *handle_action_simple_session( - int *argc, const char ***argv, +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_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 *fire_once_after_str = NULL; + char *fire_every_str = NULL; char *error = NULL; enum lttng_action_status action_status; - - state = argpar_state_create(*argc, *argv, no_opt_descrs); + struct lttng_rate_policy *policy = NULL; + + assert(set_session_name_cb); + 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 }, + ARGPAR_OPT_DESCR_SENTINEL + }; + + state = argpar_state_create(*argc, *argv, rate_policy_opt_descrs); if (!state) { ERR("Failed to allocate an argpar state."); goto error; @@ -1379,14 +1545,14 @@ struct lttng_action *handle_action_simple_session( while (true) { enum argpar_state_parse_next_status status; - const struct argpar_item_non_opt *item_non_opt; 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) { + } 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) { @@ -1394,17 +1560,48 @@ struct lttng_action *handle_action_simple_session( } assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK); - assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + if (item->type == ARGPAR_ITEM_TYPE_OPT) { + const struct argpar_item_opt *item_opt = + (const struct argpar_item_opt *) item; - item_non_opt = (const struct argpar_item_non_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; + } - switch (item_non_opt->non_opt_index) { - case 0: - session_name_arg = item_non_opt->arg; - break; - default: - ERR("Unexpected argument `%s`.", item_non_opt->arg); - goto error; + break; + } + case OPT_FIRE_EVERY: + { + if (!assign_string(&fire_every_str, + item_opt->arg, + "--fire-every")) { + goto error; + } + + break; + } + + default: + abort(); + } + } else { + const struct argpar_item_non_opt *item_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; + default: + ERR("Unexpected argument `%s`.", + item_non_opt->arg); + goto error; + } } } @@ -1416,6 +1613,55 @@ struct lttng_action *handle_action_simple_session( 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); @@ -1429,6 +1675,14 @@ struct lttng_action *handle_action_simple_session( goto error; } + if (policy) { + action_status = set_rate_policy_cb(action, policy); + if (action_status != LTTNG_ACTION_STATUS_OK) { + ERR("Failed to set rate policy"); + goto error; + } + } + goto end; error: @@ -1436,6 +1690,7 @@ error: action = NULL; argpar_item_destroy(item); end: + lttng_rate_policy_destroy(policy); free(error); argpar_state_destroy(state); return action; @@ -1445,29 +1700,30 @@ static struct lttng_action *handle_action_start_session(int *argc, const char ***argv) { - return handle_action_simple_session(argc, argv, - lttng_action_start_session_create, - lttng_action_start_session_set_session_name, - "start"); + 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"); } static struct lttng_action *handle_action_stop_session(int *argc, const char ***argv) { - return handle_action_simple_session(argc, argv, - lttng_action_stop_session_create, - lttng_action_stop_session_set_session_name, - "stop"); + 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"); } static struct lttng_action *handle_action_rotate_session(int *argc, const char ***argv) { - return handle_action_simple_session(argc, argv, + return handle_action_simple_session_with_policy(argc, argv, lttng_action_rotate_session_create, lttng_action_rotate_session_set_session_name, + lttng_action_rotate_session_set_rate_policy, "rotate"); } @@ -1478,6 +1734,8 @@ 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 }, ARGPAR_OPT_DESCR_SENTINEL }; @@ -1496,8 +1754,11 @@ 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; int ret; unsigned int locations_specified = 0; @@ -1565,6 +1826,27 @@ 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: + { + if (!assign_string(&fire_every_str, + item_opt->arg, + "--fire-every")) { + goto error; + } + + break; + } + default: abort(); } @@ -1628,6 +1910,56 @@ 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."); @@ -1749,6 +2081,16 @@ struct lttng_action *handle_action_snapshot_session(int *argc, snapshot_output = NULL; } + if (policy) { + enum lttng_action_status status; + status = lttng_action_snapshot_session_set_rate_policy( + action, policy); + if (status != LTTNG_ACTION_STATUS_OK) { + ERR("Failed to set rate policy"); + goto error; + } + } + goto end; error: @@ -1763,6 +2105,7 @@ end: free(data_url_arg); free(snapshot_output); free(max_size_arg); + lttng_rate_policy_destroy(policy); argpar_state_destroy(state); argpar_item_destroy(item); return action; @@ -1832,8 +2175,6 @@ struct argpar_opt_descr add_trigger_options[] = { { OPT_CONDITION, '\0', "condition", false }, { OPT_ACTION, '\0', "action", false }, { OPT_ID, '\0', "id", true }, - { OPT_FIRE_ONCE_AFTER, '\0', "fire-once-after", true }, - { OPT_FIRE_EVERY, '\0', "fire-every", true }, { OPT_USER_ID, '\0', "user-id", true }, ARGPAR_OPT_DESCR_SENTINEL, }; @@ -1861,8 +2202,6 @@ int cmd_add_trigger(int argc, const char **argv) char *error = NULL; char *id = NULL; int i; - char *fire_once_after_str = NULL; - char *fire_every_str = NULL; char *user_id = NULL; lttng_dynamic_pointer_array_init(&actions, lttng_actions_destructor); @@ -1969,24 +2308,6 @@ int cmd_add_trigger(int argc, const char **argv) 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: - { - if (!assign_string(&fire_every_str, item_opt->arg, - "--fire-every")) { - goto error; - } - - break; - } case OPT_USER_ID: { if (!assign_string(&user_id, item_opt->arg, @@ -2011,11 +2332,6 @@ int cmd_add_trigger(int argc, const char **argv) goto error; } - if (fire_every_str && fire_once_after_str) { - ERR("Can't specify both --fire-once-after and --fire-every."); - goto error; - } - action_group = lttng_action_group_create(); if (!action_group) { goto error; @@ -2054,41 +2370,6 @@ int cmd_add_trigger(int argc, const char **argv) } } - if (fire_once_after_str) { - unsigned long long threshold; - enum lttng_trigger_status trigger_status; - - 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; - } - - trigger_status = lttng_trigger_set_firing_policy(trigger, - LTTNG_TRIGGER_FIRING_POLICY_ONCE_AFTER_N, - threshold); - if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { - ERR("Failed to set trigger's policy to `fire once after N`."); - goto error; - } - } - - if (fire_every_str) { - unsigned long long threshold; - enum lttng_trigger_status trigger_status; - - if (utils_parse_unsigned_long_long(fire_every_str, &threshold) != 0) { - ERR("Failed to parse `%s` as an integer.", fire_every_str); - goto error; - } - - trigger_status = lttng_trigger_set_firing_policy(trigger, - LTTNG_TRIGGER_FIRING_POLICY_EVERY_N, threshold); - if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { - ERR("Failed to set trigger's policy to `fire every N`."); - goto error; - } - } - if (user_id) { enum lttng_trigger_status trigger_status; char *end; @@ -2130,8 +2411,6 @@ end: lttng_trigger_destroy(trigger); free(error); free(id); - free(fire_once_after_str); - free(fire_every_str); free(user_id); return ret; }