X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=8a88c6d91ffb84d1e50a293dbca334b1bb4d0552;hp=b79b9e0448c6e624e6e819dc3a1b9fe254dc8382;hb=bf8ac2eaec39ba99aaac4de946bbaf3dca4f5539;hpb=1ca78886afb53f45d5ee76dfb48f08dd9991e4e2 diff --git a/src/common/trigger.c b/src/common/trigger.c index b79b9e044..8a88c6d91 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -5,24 +5,26 @@ * */ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include #include -#include -#include -#include -#include #include +#include +#include #include -#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include LTTNG_HIDDEN bool lttng_trigger_validate(const struct lttng_trigger *trigger) @@ -62,15 +64,15 @@ struct lttng_trigger *lttng_trigger_create( urcu_ref_init(&trigger->ref); - trigger->firing_policy.type = LTTNG_TRIGGER_FIRING_POLICY_EVERY_N; - trigger->firing_policy.threshold = 1; - lttng_condition_get(condition); trigger->condition = condition; lttng_action_get(action); trigger->action = action; + pthread_mutex_init(&trigger->lock, NULL); + trigger->registered = false; + end: return trigger; } @@ -124,6 +126,8 @@ static void trigger_destroy_ref(struct urcu_ref *ref) lttng_action_put(action); lttng_condition_put(condition); + pthread_mutex_destroy(&trigger->lock); + free(trigger->name); free(trigger); } @@ -133,23 +137,6 @@ void lttng_trigger_destroy(struct lttng_trigger *trigger) lttng_trigger_put(trigger); } -static bool is_firing_policy_valid(enum lttng_trigger_firing_policy policy) -{ - bool valid = false; - - switch (policy) { - case LTTNG_TRIGGER_FIRING_POLICY_EVERY_N: - case LTTNG_TRIGGER_FIRING_POLICY_ONCE_AFTER_N: - valid = true; - break; - default: - valid = false; - break; - } - - return valid; -} - LTTNG_HIDDEN ssize_t lttng_trigger_create_from_payload( struct lttng_payload_view *src_view, @@ -160,8 +147,6 @@ ssize_t lttng_trigger_create_from_payload( struct lttng_action *action = NULL; const struct lttng_trigger_comm *trigger_comm; const char *name = NULL; - uint64_t firing_policy_threshold; - enum lttng_trigger_firing_policy firing_policy; struct lttng_credentials creds = { .uid = LTTNG_OPTIONAL_INIT_UNSET, .gid = LTTNG_OPTIONAL_INIT_UNSET, @@ -196,13 +181,6 @@ ssize_t lttng_trigger_create_from_payload( offset += sizeof(*trigger_comm); - firing_policy = trigger_comm->firing_policy_type; - if (!is_firing_policy_valid(firing_policy)) { - ret =-1; - goto end; - } - - firing_policy_threshold = trigger_comm->firing_policy_threshold; if (trigger_comm->name_length != 0) { /* Name. */ const struct lttng_payload_view name_view = @@ -291,19 +269,6 @@ ssize_t lttng_trigger_create_from_payload( } } - /* Set the policy. */ - { - const enum lttng_trigger_status status = - lttng_trigger_set_firing_policy(trigger, - firing_policy, - firing_policy_threshold); - - if (status != LTTNG_TRIGGER_STATUS_OK) { - ret = -1; - goto end; - } - } - ret = offset; error: @@ -345,8 +310,6 @@ int lttng_trigger_serialize(const struct lttng_trigger *trigger, } trigger_comm.name_length = size_name; - trigger_comm.firing_policy_type = (uint8_t) trigger->firing_policy.type; - trigger_comm.firing_policy_threshold = (uint64_t) trigger->firing_policy.threshold; header_offset = payload->buffer.size; ret = lttng_dynamic_buffer_append(&payload->buffer, &trigger_comm, @@ -385,15 +348,12 @@ LTTNG_HIDDEN bool lttng_trigger_is_equal( const struct lttng_trigger *a, const struct lttng_trigger *b) { - if (a->firing_policy.type != b->firing_policy.type) { + if (!!a->name != !!b->name) { + /* Both must be either anonymous or named. */ return false; } - if (a->firing_policy.threshold != b->firing_policy.threshold) { - return false; - } - - if (strcmp(a->name, b->name) != 0) { + if (a->name && strcmp(a->name, b->name) != 0) { return false; } @@ -413,22 +373,24 @@ bool lttng_trigger_is_equal( return true; } +LTTNG_HIDDEN enum lttng_trigger_status lttng_trigger_set_name(struct lttng_trigger *trigger, const char* name) { char *name_copy = NULL; enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; - if (!trigger || !name || - strlen(name) == 0) { + if (!trigger) { status = LTTNG_TRIGGER_STATUS_INVALID; goto end; } - name_copy = strdup(name); - if (!name_copy) { - status = LTTNG_TRIGGER_STATUS_ERROR; - goto end; + if (name) { + name_copy = strdup(name); + if (!name_copy) { + status = LTTNG_TRIGGER_STATUS_ERROR; + goto end; + } } free(trigger->name); @@ -751,6 +713,7 @@ enum lttng_trigger_status lttng_trigger_set_owner_uid( struct lttng_trigger *trigger, uid_t uid) { enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; + const uid_t euid = geteuid(); const struct lttng_credentials creds = { .uid = LTTNG_OPTIONAL_INIT_VALUE(uid), .gid = LTTNG_OPTIONAL_INIT_UNSET, @@ -762,7 +725,7 @@ enum lttng_trigger_status lttng_trigger_set_owner_uid( } /* Client-side validation only to report a clearer error. */ - if (geteuid() != 0) { + if (euid != 0 && euid != uid) { ret = LTTNG_TRIGGER_STATUS_PERMISSION_DENIED; goto end; } @@ -796,97 +759,6 @@ end: return ret; } -enum lttng_trigger_status lttng_trigger_set_firing_policy( - struct lttng_trigger *trigger, - enum lttng_trigger_firing_policy policy_type, - uint64_t threshold) -{ - enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; - assert(trigger); - - if (threshold < 1) { - ret = LTTNG_TRIGGER_STATUS_INVALID; - goto end; - } - - trigger->firing_policy.type = policy_type; - trigger->firing_policy.threshold = threshold; - -end: - return ret; -} - -enum lttng_trigger_status lttng_trigger_get_firing_policy( - const struct lttng_trigger *trigger, - enum lttng_trigger_firing_policy *policy_type, - uint64_t *threshold) -{ - enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; - - if (!trigger || !policy_type || !threshold) { - status = LTTNG_TRIGGER_STATUS_INVALID; - goto end; - } - - *policy_type = trigger->firing_policy.type; - *threshold = trigger->firing_policy.threshold; - -end: - return status; -} - -LTTNG_HIDDEN -bool lttng_trigger_should_fire(const struct lttng_trigger *trigger) -{ - bool ready_to_fire = false; - - assert(trigger); - - switch (trigger->firing_policy.type) { - case LTTNG_TRIGGER_FIRING_POLICY_EVERY_N: - if (trigger->firing_policy.current_count < trigger->firing_policy.threshold) { - ready_to_fire = true; - } - break; - case LTTNG_TRIGGER_FIRING_POLICY_ONCE_AFTER_N: - if (trigger->firing_policy.current_count < trigger->firing_policy.threshold) { - ready_to_fire = true; - } - break; - default: - abort(); - }; - - return ready_to_fire; -} - -LTTNG_HIDDEN -void lttng_trigger_fire(struct lttng_trigger *trigger) -{ - assert(trigger); - - trigger->firing_policy.current_count++; - - switch (trigger->firing_policy.type) { - case LTTNG_TRIGGER_FIRING_POLICY_EVERY_N: - if (trigger->firing_policy.current_count == trigger->firing_policy.threshold) { - trigger->firing_policy.current_count = 0; - } - - break; - case LTTNG_TRIGGER_FIRING_POLICY_ONCE_AFTER_N: - /* - * TODO: - * As an optimisation, deactivate the trigger condition and - * remove any checks in the traced application or kernel since - * the trigger will never fire again. - */ - break; - default: - abort(); - }; -} - LTTNG_HIDDEN enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction( const struct lttng_trigger *trigger) @@ -909,9 +781,9 @@ enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction( /* Apply to any domain. */ type = LTTNG_DOMAIN_NONE; break; - case LTTNG_CONDITION_TYPE_ON_EVENT: + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: /* Return the domain of the event rule. */ - c_status = lttng_condition_on_event_get_rule( + c_status = lttng_condition_event_rule_matches_get_rule( trigger->condition, &event_rule); assert(c_status == LTTNG_CONDITION_STATUS_OK); type = lttng_event_rule_get_domain_type(event_rule); @@ -949,12 +821,12 @@ enum lttng_error_code lttng_trigger_generate_bytecode( } switch (lttng_condition_get_type(condition)) { - case LTTNG_CONDITION_TYPE_ON_EVENT: + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: { struct lttng_event_rule *event_rule; const enum lttng_condition_status condition_status = - lttng_condition_on_event_borrow_rule_mutable( - condition, &event_rule); + lttng_condition_event_rule_matches_borrow_rule_mutable( + condition, &event_rule); assert(condition_status == LTTNG_CONDITION_STATUS_OK); @@ -966,7 +838,7 @@ enum lttng_error_code lttng_trigger_generate_bytecode( } /* Generate the capture bytecode. */ - ret = lttng_condition_on_event_generate_capture_descriptor_bytecode( + ret = lttng_condition_event_rule_matches_generate_capture_descriptor_bytecode( condition); if (ret != LTTNG_OK) { goto end; @@ -988,11 +860,16 @@ struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger) { int ret; struct lttng_payload copy_buffer; + struct lttng_condition *condition_copy = NULL; + struct lttng_action *action_copy = NULL; struct lttng_trigger *copy = NULL; + enum lttng_trigger_status trigger_status; + const char *trigger_name; + uid_t trigger_owner_uid; lttng_payload_init(©_buffer); - ret = lttng_trigger_serialize(trigger, ©_buffer); + ret = lttng_condition_serialize(trigger->condition, ©_buffer); if (ret < 0) { goto end; } @@ -1001,15 +878,78 @@ struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger) struct lttng_payload_view view = lttng_payload_view_from_payload( ©_buffer, 0, -1); - ret = lttng_trigger_create_from_payload( - &view, ©); + + ret = lttng_condition_create_from_payload( + &view, &condition_copy); if (ret < 0) { - copy = NULL; goto end; } } + lttng_payload_clear(©_buffer); + + ret = lttng_action_serialize(trigger->action, ©_buffer); + if (ret < 0) { + goto end; + } + + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + ©_buffer, 0, -1); + + ret = lttng_action_create_from_payload( + &view, &action_copy); + if (ret < 0) { + goto end; + } + } + + copy = lttng_trigger_create(condition_copy, action_copy); + if (!copy) { + ERR("Failed to allocate trigger during trigger copy"); + goto end; + } + + trigger_status = lttng_trigger_get_name(trigger, &trigger_name); + switch (trigger_status) { + case LTTNG_TRIGGER_STATUS_OK: + trigger_status = lttng_trigger_set_name(copy, trigger_name); + if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { + ERR("Failed to set name of new trigger during copy"); + goto error_cleanup_trigger; + } + break; + case LTTNG_TRIGGER_STATUS_UNSET: + break; + default: + ERR("Failed to get name of original trigger during copy"); + goto error_cleanup_trigger; + } + + trigger_status = lttng_trigger_get_owner_uid( + trigger, &trigger_owner_uid); + switch (trigger_status) { + case LTTNG_TRIGGER_STATUS_OK: + LTTNG_OPTIONAL_SET(©->creds.uid, trigger_owner_uid); + break; + case LTTNG_TRIGGER_STATUS_UNSET: + break; + default: + ERR("Failed to get owner uid of original trigger during copy"); + goto error_cleanup_trigger; + } + + copy->tracer_token = trigger->tracer_token; + copy->registered = trigger->registered; + goto end; + +error_cleanup_trigger: + lttng_trigger_destroy(copy); + copy = NULL; end: + lttng_condition_put(condition_copy); + lttng_action_put(action_copy); lttng_payload_reset(©_buffer); return copy; } @@ -1022,7 +962,7 @@ bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger) lttng_trigger_get_const_condition(trigger); switch (lttng_condition_get_type(condition)) { - case LTTNG_CONDITION_TYPE_ON_EVENT: + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: needs_tracer_notifier = true; goto end; case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE: @@ -1038,3 +978,243 @@ bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger) end: return needs_tracer_notifier; } + +LTTNG_HIDDEN +void lttng_trigger_set_as_registered(struct lttng_trigger *trigger) +{ + pthread_mutex_lock(&trigger->lock); + trigger->registered = true; + pthread_mutex_unlock(&trigger->lock); +} + +LTTNG_HIDDEN +void lttng_trigger_set_as_unregistered(struct lttng_trigger *trigger) +{ + pthread_mutex_lock(&trigger->lock); + trigger->registered = false; + pthread_mutex_unlock(&trigger->lock); +} + +/* + * The trigger must be locked before calling lttng_trigger_registered. + * The lock is necessary since a trigger can be unregistered at anytime. + * Manipulations requiring that the trigger be registered must always acquire + * the trigger lock for the duration of the manipulation using + * `lttng_trigger_lock` and `lttng_trigger_unlock`. + */ +LTTNG_HIDDEN +bool lttng_trigger_is_registered(struct lttng_trigger *trigger) +{ + ASSERT_LOCKED(trigger->lock); + return trigger->registered; +} + +LTTNG_HIDDEN +void lttng_trigger_lock(struct lttng_trigger *trigger) +{ + pthread_mutex_lock(&trigger->lock); +} + +LTTNG_HIDDEN +void lttng_trigger_unlock(struct lttng_trigger *trigger) +{ + pthread_mutex_unlock(&trigger->lock); +} + +LTTNG_HIDDEN +enum lttng_error_code lttng_trigger_mi_serialize(const struct lttng_trigger *trigger, + struct mi_writer *writer, + const struct mi_lttng_error_query_callbacks + *error_query_callbacks) +{ + int ret; + enum lttng_error_code ret_code; + enum lttng_trigger_status trigger_status; + const struct lttng_condition *condition = NULL; + const struct lttng_action *action = NULL; + struct lttng_dynamic_array action_path_indexes; + uid_t owner_uid; + + assert(trigger); + assert(writer); + + lttng_dynamic_array_init(&action_path_indexes, sizeof(uint64_t), NULL); + + /* Open trigger element. */ + ret = mi_lttng_writer_open_element(writer, mi_lttng_element_trigger); + if (ret) { + goto mi_error; + } + + trigger_status = lttng_trigger_get_owner_uid(trigger, &owner_uid); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + /* Name. */ + ret = mi_lttng_writer_write_element_string( + writer, config_element_name, trigger->name); + if (ret) { + goto mi_error; + } + + /* Owner uid. */ + ret = mi_lttng_writer_write_element_signed_int(writer, + mi_lttng_element_trigger_owner_uid, + (int64_t) owner_uid); + if (ret) { + goto mi_error; + } + + /* Condition. */ + condition = lttng_trigger_get_const_condition(trigger); + assert(condition); + ret_code = lttng_condition_mi_serialize( + trigger, condition, writer, error_query_callbacks); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* Action. */ + action = lttng_trigger_get_const_action(trigger); + assert(action); + ret_code = lttng_action_mi_serialize(trigger, action, writer, + error_query_callbacks, &action_path_indexes); + if (ret_code != LTTNG_OK) { + goto end; + } + + if (error_query_callbacks && error_query_callbacks->trigger_cb) { + struct lttng_error_query_results *results = NULL; + + ret_code = error_query_callbacks->trigger_cb(trigger, &results); + if (ret_code != LTTNG_OK) { + goto end; + } + + ret_code = lttng_error_query_results_mi_serialize( + results, writer); + lttng_error_query_results_destroy(results); + if (ret_code != LTTNG_OK) { + goto end; + } + } + + /* Close trigger element. */ + 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_dynamic_array_reset(&action_path_indexes); + return ret_code; +} + +/* Used by qsort, which expects the semantics of strcmp(). */ +static int compare_triggers_by_name(const void *a, const void *b) +{ + const struct lttng_trigger *trigger_a = + *((const struct lttng_trigger **) a); + const struct lttng_trigger *trigger_b = + *((const struct lttng_trigger **) b); + const char *name_a, *name_b; + enum lttng_trigger_status trigger_status; + + /* Anonymous triggers are not reachable here. */ + trigger_status = lttng_trigger_get_name(trigger_a, &name_a); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + trigger_status = lttng_trigger_get_name(trigger_b, &name_b); + assert(trigger_status == LTTNG_TRIGGER_STATUS_OK); + + return strcmp(name_a, name_b); +} + +LTTNG_HIDDEN +enum lttng_error_code lttng_triggers_mi_serialize(const struct lttng_triggers *triggers, + struct mi_writer *writer, + const struct mi_lttng_error_query_callbacks + *error_query_callbacks) +{ + int ret; + enum lttng_error_code ret_code; + enum lttng_trigger_status status; + unsigned int count, i; + struct lttng_dynamic_pointer_array sorted_triggers; + + assert(triggers); + assert(writer); + + /* + * Sort trigger by name to ensure an order at the MI level and ignore + * any anonymous trigger present. + */ + lttng_dynamic_pointer_array_init(&sorted_triggers, NULL); + + status = lttng_triggers_get_count(triggers, &count); + assert(status == LTTNG_TRIGGER_STATUS_OK); + + for (i = 0; i < count; i++) { + int add_ret; + const char *unused_name; + const struct lttng_trigger *trigger = + lttng_triggers_get_at_index(triggers, i); + + status = lttng_trigger_get_name(trigger, &unused_name); + switch (status) { + case LTTNG_TRIGGER_STATUS_OK: + break; + case LTTNG_TRIGGER_STATUS_UNSET: + /* Don't list anonymous triggers. */ + continue; + default: + abort(); + } + + add_ret = lttng_dynamic_pointer_array_add_pointer( + &sorted_triggers, (void *) trigger); + + if (add_ret) { + ERR("Failed to lttng_trigger to sorting array."); + ret_code = LTTNG_ERR_NOMEM; + goto error; + } + } + + qsort(sorted_triggers.array.buffer.data, count, + sizeof(struct lttng_trigger *), + compare_triggers_by_name); + + /* Open triggers element. */ + ret = mi_lttng_writer_open_element(writer, mi_lttng_element_triggers); + if (ret) { + ret_code = LTTNG_ERR_MI_IO_FAIL; + goto error; + } + + for (i = 0; i < lttng_dynamic_pointer_array_get_count(&sorted_triggers); i++) { + const struct lttng_trigger *trigger = + (const struct lttng_trigger *) + lttng_dynamic_pointer_array_get_pointer( + &sorted_triggers, i); + + lttng_trigger_mi_serialize(trigger, writer, error_query_callbacks); + } + + /* Close triggers element. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret_code = LTTNG_ERR_MI_IO_FAIL; + goto error; + } + + ret_code = LTTNG_OK; + +error: + lttng_dynamic_pointer_array_reset(&sorted_triggers); + return ret_code; +}