X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Factions%2Faction.c;h=4dabfff303e547bc973c389e5d7baae38954a792;hb=6a751b953a43c566b74818ec6325db0978e16c66;hp=95a0c0f4d20a19eb743b60d392c65934a82d656f;hpb=3e6e0df2f8f9f23d252c2508b6d741916dfcc4b3;p=lttng-tools.git diff --git a/src/common/actions/action.c b/src/common/actions/action.c index 95a0c0f4d..4dabfff30 100644 --- a/src/common/actions/action.c +++ b/src/common/actions/action.c @@ -7,13 +7,16 @@ #include #include +#include #include -#include +#include #include +#include #include #include #include #include +#include LTTNG_HIDDEN const char *lttng_action_type_string(enum lttng_action_type action_type) @@ -21,8 +24,8 @@ const char *lttng_action_type_string(enum lttng_action_type action_type) switch (action_type) { case LTTNG_ACTION_TYPE_UNKNOWN: return "UNKNOWN"; - case LTTNG_ACTION_TYPE_GROUP: - return "GROUP"; + case LTTNG_ACTION_TYPE_LIST: + return "LIST"; case LTTNG_ACTION_TYPE_NOTIFY: return "NOTIFY"; case LTTNG_ACTION_TYPE_ROTATE_SESSION: @@ -44,13 +47,15 @@ enum lttng_action_type lttng_action_get_type(const struct lttng_action *action) } LTTNG_HIDDEN -void lttng_action_init( - struct lttng_action *action, +void lttng_action_init(struct lttng_action *action, enum lttng_action_type type, action_validate_cb validate, action_serialize_cb serialize, action_equal_cb equal, - action_destroy_cb destroy) + action_destroy_cb destroy, + action_get_rate_policy_cb get_rate_policy, + action_add_error_query_results_cb add_error_query_results, + action_mi_serialize_cb mi) { urcu_ref_init(&action->ref); action->type = type; @@ -58,6 +63,13 @@ void lttng_action_init( action->serialize = serialize; action->equal = equal; action->destroy = destroy; + action->get_rate_policy = get_rate_policy; + action->add_error_query_results = add_error_query_results; + action->mi_serialize = mi; + + action->execution_request_counter = 0; + action->execution_counter = 0; + action->execution_failure_counter = 0; } static @@ -182,8 +194,8 @@ ssize_t lttng_action_create_from_payload(struct lttng_payload_view *view, create_from_payload_cb = lttng_action_stop_session_create_from_payload; break; - case LTTNG_ACTION_TYPE_GROUP: - create_from_payload_cb = lttng_action_group_create_from_payload; + case LTTNG_ACTION_TYPE_LIST: + create_from_payload_cb = lttng_action_list_create_from_payload; break; default: ERR("Failed to create action from payload, unhandled action type: action-type=%u (%s)", @@ -243,3 +255,178 @@ bool lttng_action_is_equal(const struct lttng_action *a, end: return is_equal; } + +LTTNG_HIDDEN +void lttng_action_increase_execution_request_count(struct lttng_action *action) +{ + action->execution_request_counter++; +} + +LTTNG_HIDDEN +void lttng_action_increase_execution_count(struct lttng_action *action) +{ + action->execution_counter++; +} + +LTTNG_HIDDEN +void lttng_action_increase_execution_failure_count(struct lttng_action *action) +{ + uatomic_inc(&action->execution_failure_counter); +} + +LTTNG_HIDDEN +bool lttng_action_should_execute(const struct lttng_action *action) +{ + const struct lttng_rate_policy *policy = NULL; + bool execute = false; + + if (action->get_rate_policy == NULL) { + execute = true; + goto end; + } + + policy = action->get_rate_policy(action); + if (policy == NULL) { + execute = true; + goto end; + } + + execute = lttng_rate_policy_should_execute( + policy, action->execution_request_counter); +end: + return execute; +} + +LTTNG_HIDDEN +enum lttng_action_status lttng_action_add_error_query_results( + const struct lttng_action *action, + struct lttng_error_query_results *results) +{ + return action->add_error_query_results(action, results); +} + +LTTNG_HIDDEN +enum lttng_action_status lttng_action_generic_add_error_query_results( + const struct lttng_action *action, + struct lttng_error_query_results *results) +{ + enum lttng_action_status action_status; + struct lttng_error_query_result *error_counter = NULL; + const uint64_t execution_failure_counter = + uatomic_read(&action->execution_failure_counter); + + error_counter = lttng_error_query_result_counter_create( + "total execution failures", + "Aggregated count of errors encountered when executing the action", + execution_failure_counter); + if (!error_counter) { + action_status = LTTNG_ACTION_STATUS_ERROR; + goto end; + } + + if (lttng_error_query_results_add_result( + results, error_counter)) { + action_status = LTTNG_ACTION_STATUS_ERROR; + goto end; + } + + /* Ownership transferred to the results. */ + error_counter = NULL; + action_status = LTTNG_ACTION_STATUS_OK; +end: + lttng_error_query_result_destroy(error_counter); + return action_status; +} + +LTTNG_HIDDEN +enum lttng_error_code lttng_action_mi_serialize(const struct lttng_trigger *trigger, + const struct lttng_action *action, + struct mi_writer *writer, + const struct mi_lttng_error_query_callbacks + *error_query_callbacks, + struct lttng_dynamic_array *action_path_indexes) +{ + int ret; + enum lttng_error_code ret_code; + struct lttng_action_path *action_path = NULL; + struct lttng_error_query_results *error_query_results = NULL; + + assert(action); + assert(writer); + + /* Open action. */ + ret = mi_lttng_writer_open_element(writer, mi_lttng_element_action); + if (ret) { + goto mi_error; + } + + if (action->type == LTTNG_ACTION_TYPE_LIST) { + /* + * Recursion is safe since action lists can't be nested for + * the moment. + */ + ret_code = lttng_action_list_mi_serialize(trigger, action, writer, + error_query_callbacks, action_path_indexes); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* Nothing else to do. */ + goto close_action_element; + } + + assert(action->mi_serialize); + ret_code = action->mi_serialize(action, writer); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* Error query for the action. */ + if (error_query_callbacks && error_query_callbacks->action_cb) { + const uint64_t *action_path_indexes_raw_pointer = NULL; + const size_t action_path_indexes_size = + lttng_dynamic_array_get_count( + action_path_indexes); + + if (action_path_indexes_size != 0) { + action_path_indexes_raw_pointer = + (const uint64_t *) action_path_indexes + ->buffer.data; + } + + action_path = lttng_action_path_create( + action_path_indexes_raw_pointer, + action_path_indexes_size); + assert(action_path); + + ret_code = error_query_callbacks->action_cb( + trigger, action_path, &error_query_results); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* Serialize the error query results. */ + ret_code = lttng_error_query_results_mi_serialize( + error_query_results, writer); + if (ret_code != LTTNG_OK) { + goto end; + } + } + +close_action_element: + /* Close action. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto mi_error; + } + + ret_code = LTTNG_OK; + goto end; + +mi_error: + ret_code = LTTNG_ERR_MI_IO_FAIL; +end: + lttng_action_path_destroy(action_path); + lttng_error_query_results_destroy(error_query_results); + return ret_code; +}