X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=34d4208076a22eec5d9e6d003ec880e887f08d40;hb=8dbb86b8a981917165030d3a7fbbc2cb932888ed;hp=8c43fdbd8aaa8aa7f7ad1fda253ea8701c7f751c;hpb=5c504c41e4d470012cb98c849aa82086d1ba1bde;p=lttng-tools.git diff --git a/src/common/trigger.c b/src/common/trigger.c index 8c43fdbd8..34d420807 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -5,20 +5,27 @@ * */ -#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(struct lttng_trigger *trigger) +bool lttng_trigger_validate(const struct lttng_trigger *trigger) { bool valid; @@ -55,15 +62,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; } @@ -79,14 +86,12 @@ struct lttng_condition *lttng_trigger_get_condition( return trigger ? trigger->condition : NULL; } -LTTNG_HIDDEN const struct lttng_condition *lttng_trigger_get_const_condition( const struct lttng_trigger *trigger) { - return trigger->condition; + return trigger ? trigger->condition : NULL; } - /* * Note: the lack of reference counting 'get' on the action object is normal. * This API was exposed as such in 2.11. The client is not expected to call @@ -98,11 +103,10 @@ struct lttng_action *lttng_trigger_get_action( return trigger ? trigger->action : NULL; } -LTTNG_HIDDEN const struct lttng_action *lttng_trigger_get_const_action( const struct lttng_trigger *trigger) { - return trigger->action; + return trigger ? trigger->action : NULL; } static void trigger_destroy_ref(struct urcu_ref *ref) @@ -120,6 +124,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); } @@ -129,23 +135,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, @@ -156,8 +145,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, @@ -192,13 +179,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 = @@ -287,19 +267,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: @@ -341,8 +308,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, @@ -381,17 +346,10 @@ 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) { - return false; - } - - if (a->firing_policy.threshold != b->firing_policy.threshold) { + if (strcmp(a->name, b->name) != 0) { return false; } - /* - * Name is not taken into account since it is cosmetic only. - */ if (!lttng_condition_is_equal(a->condition, b->condition)) { return false; } @@ -746,6 +704,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, @@ -757,7 +716,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; } @@ -791,93 +750,196 @@ 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) +LTTNG_HIDDEN +enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction( + const struct lttng_trigger *trigger) { - enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; + enum lttng_domain_type type = LTTNG_DOMAIN_NONE; + const struct lttng_event_rule *event_rule; + enum lttng_condition_status c_status; + enum lttng_condition_type c_type; + assert(trigger); + assert(trigger->condition); - if (threshold < 1) { - ret = LTTNG_TRIGGER_STATUS_INVALID; + c_type = lttng_condition_get_type(trigger->condition); + assert (c_type != LTTNG_CONDITION_TYPE_UNKNOWN); + + switch (c_type) { + case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE: + case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING: + case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED: + /* Apply to any domain. */ + type = LTTNG_DOMAIN_NONE; + break; + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: + /* Return the domain of the event 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); + break; + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH: + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW: + /* Return the domain of the channel being monitored. */ + c_status = lttng_condition_buffer_usage_get_domain_type( + trigger->condition, &type); + assert(c_status == LTTNG_CONDITION_STATUS_OK); + break; + default: + abort(); + } + + return type; +} + +/* + * Generate bytecode related to the trigger. + * On success LTTNG_OK. On error, returns lttng_error code. + */ +LTTNG_HIDDEN +enum lttng_error_code lttng_trigger_generate_bytecode( + struct lttng_trigger *trigger, + const struct lttng_credentials *creds) +{ + enum lttng_error_code ret; + struct lttng_condition *condition = NULL; + + condition = lttng_trigger_get_condition(trigger); + if (!condition) { + ret = LTTNG_ERR_INVALID_TRIGGER; goto end; } - trigger->firing_policy.type = policy_type; - trigger->firing_policy.threshold = threshold; + switch (lttng_condition_get_type(condition)) { + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: + { + struct lttng_event_rule *event_rule; + const enum lttng_condition_status condition_status = + lttng_condition_event_rule_matches_borrow_rule_mutable( + condition, &event_rule); + assert(condition_status == LTTNG_CONDITION_STATUS_OK); + + /* Generate the filter bytecode. */ + ret = lttng_event_rule_generate_filter_bytecode( + event_rule, creds); + if (ret != LTTNG_OK) { + goto end; + } + + /* Generate the capture bytecode. */ + ret = lttng_condition_event_rule_matches_generate_capture_descriptor_bytecode( + condition); + if (ret != LTTNG_OK) { + goto end; + } + + ret = LTTNG_OK; + break; + } + default: + ret = LTTNG_OK; + break; + } 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) +LTTNG_HIDDEN +struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger) { - enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; + int ret; + struct lttng_payload copy_buffer; + struct lttng_trigger *copy = NULL; - if (!trigger || !policy_type || !threshold) { - status = LTTNG_TRIGGER_STATUS_INVALID; + lttng_payload_init(©_buffer); + + ret = lttng_trigger_serialize(trigger, ©_buffer); + if (ret < 0) { goto end; } - *policy_type = trigger->firing_policy.type; - *threshold = trigger->firing_policy.threshold; + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + ©_buffer, 0, -1); + ret = lttng_trigger_create_from_payload( + &view, ©); + if (ret < 0) { + copy = NULL; + goto end; + } + } end: - return status; + lttng_payload_reset(©_buffer); + return copy; } LTTNG_HIDDEN -bool lttng_trigger_should_fire(const struct lttng_trigger *trigger) +bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger) { - bool ready_to_fire = false; + bool needs_tracer_notifier = false; + const struct lttng_condition *condition = + lttng_trigger_get_const_condition(trigger); - 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; + switch (lttng_condition_get_type(condition)) { + case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES: + needs_tracer_notifier = true; + goto end; + case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE: + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH: + case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW: + case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING: + case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED: + goto end; + case LTTNG_CONDITION_TYPE_UNKNOWN: default: abort(); - }; + } +end: + return needs_tracer_notifier; +} - return ready_to_fire; +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_fire(struct lttng_trigger *trigger) +void lttng_trigger_set_as_unregistered(struct lttng_trigger *trigger) { - assert(trigger); + pthread_mutex_lock(&trigger->lock); + trigger->registered = false; + pthread_mutex_unlock(&trigger->lock); +} - trigger->firing_policy.current_count++; +/* + * 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; +} - 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; - } +LTTNG_HIDDEN +void lttng_trigger_lock(struct lttng_trigger *trigger) +{ + pthread_mutex_lock(&trigger->lock); +} - 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 +void lttng_trigger_unlock(struct lttng_trigger *trigger) +{ + pthread_mutex_unlock(&trigger->lock); }