X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=e6849fccfa52789a022de29b4344f2ead73fbffd;hp=5ff478a46f220c7815dd0f4db48343d7577e7690;hb=85c06c443aa9b896639681ec6a536e4b80a2bd02;hpb=9e620ea7b016fc3fd4e08b5d094ffa40b36b50f6 diff --git a/src/common/trigger.c b/src/common/trigger.c index 5ff478a46..e6849fccf 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -8,9 +8,11 @@ #include #include #include +#include #include #include #include +#include #include LTTNG_HIDDEN @@ -23,6 +25,11 @@ bool lttng_trigger_validate(struct lttng_trigger *trigger) goto end; } + if (!trigger->creds.uid.is_set) { + valid = false; + goto end; + } + valid = lttng_condition_validate(trigger->condition) && lttng_action_validate(trigger->action); end: @@ -44,12 +51,23 @@ struct lttng_trigger *lttng_trigger_create( goto end; } + urcu_ref_init(&trigger->ref); + + lttng_condition_get(condition); trigger->condition = condition; + + lttng_action_get(action); trigger->action = action; + end: return trigger; } +/* + * Note: the lack of reference counting 'get' on the condition object is normal. + * This API was exposed as such in 2.11. The client is not expected to call + * lttng_condition_destroy on the returned object. + */ struct lttng_condition *lttng_trigger_get_condition( struct lttng_trigger *trigger) { @@ -63,6 +81,12 @@ const struct lttng_condition *lttng_trigger_get_const_condition( return trigger->condition; } + +/* + * 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 + * lttng_action_destroy on the returned object. + */ struct lttng_action *lttng_trigger_get_action( struct lttng_trigger *trigger) { @@ -76,15 +100,29 @@ const struct lttng_action *lttng_trigger_get_const_action( return trigger->action; } -void lttng_trigger_destroy(struct lttng_trigger *trigger) +static void trigger_destroy_ref(struct urcu_ref *ref) { - if (!trigger) { - return; - } + struct lttng_trigger *trigger = + container_of(ref, struct lttng_trigger, ref); + struct lttng_action *action = lttng_trigger_get_action(trigger); + struct lttng_condition *condition = + lttng_trigger_get_condition(trigger); + + assert(action); + assert(condition); + + /* Release ownership. */ + lttng_action_put(action); + lttng_condition_put(condition); free(trigger); } +void lttng_trigger_destroy(struct lttng_trigger *trigger) +{ + lttng_trigger_put(trigger); +} + LTTNG_HIDDEN ssize_t lttng_trigger_create_from_payload( struct lttng_payload_view *src_view, @@ -94,6 +132,10 @@ ssize_t lttng_trigger_create_from_payload( struct lttng_condition *condition = NULL; struct lttng_action *action = NULL; const struct lttng_trigger_comm *trigger_comm; + struct lttng_credentials creds = { + .uid = LTTNG_OPTIONAL_INIT_UNSET, + .gid = LTTNG_OPTIONAL_INIT_UNSET, + }; if (!src_view || !trigger) { ret = -1; @@ -102,6 +144,16 @@ ssize_t lttng_trigger_create_from_payload( /* lttng_trigger_comm header */ trigger_comm = (typeof(trigger_comm)) src_view->buffer.data; + + /* Set the trigger's creds. */ + if (trigger_comm->uid > (uint64_t) ((uid_t) -1)) { + /* UID out of range for this platform. */ + ret = -1; + goto end; + } + + LTTNG_OPTIONAL_SET(&creds.uid, trigger_comm->uid); + offset += sizeof(*trigger_comm); { /* struct lttng_condition */ @@ -146,12 +198,24 @@ ssize_t lttng_trigger_create_from_payload( goto error; } + lttng_trigger_set_credentials(*trigger, &creds); + + /* + * The trigger object owns references to the action and condition + * objects. + */ + lttng_condition_put(condition); + condition = NULL; + + lttng_action_put(action); + action = NULL; + ret = offset; -end: - return ret; + error: lttng_condition_destroy(condition); lttng_action_destroy(action); +end: return ret; } @@ -167,6 +231,12 @@ int lttng_trigger_serialize(struct lttng_trigger *trigger, size_t header_offset, size_before_payload; struct lttng_trigger_comm trigger_comm = {}; struct lttng_trigger_comm *header; + const struct lttng_credentials *creds = NULL; + + creds = lttng_trigger_get_credentials(trigger); + assert(creds); + + trigger_comm.uid = LTTNG_OPTIONAL_GET(creds->uid); header_offset = payload->buffer.size; ret = lttng_dynamic_buffer_append(&payload->buffer, &trigger_comm, @@ -192,3 +262,106 @@ int lttng_trigger_serialize(struct lttng_trigger *trigger, end: return ret; } + +LTTNG_HIDDEN +bool lttng_trigger_is_equal( + const struct lttng_trigger *a, const struct lttng_trigger *b) +{ + /* + * Name is not taken into account since it is cosmetic only. + */ + if (!lttng_condition_is_equal(a->condition, b->condition)) { + return false; + } + + if (!lttng_action_is_equal(a->action, b->action)) { + return false; + } + + if (!lttng_credentials_is_equal(lttng_trigger_get_credentials(a), + lttng_trigger_get_credentials(b))) { + return false; + } + + return true; +} + +LTTNG_HIDDEN +void lttng_trigger_get(struct lttng_trigger *trigger) +{ + urcu_ref_get(&trigger->ref); +} + +LTTNG_HIDDEN +void lttng_trigger_put(struct lttng_trigger *trigger) +{ + if (!trigger) { + return; + } + + urcu_ref_put(&trigger->ref , trigger_destroy_ref); +} + +LTTNG_HIDDEN +const struct lttng_credentials *lttng_trigger_get_credentials( + const struct lttng_trigger *trigger) +{ + return &trigger->creds; +} + +LTTNG_HIDDEN +void lttng_trigger_set_credentials(struct lttng_trigger *trigger, + const struct lttng_credentials *creds) +{ + assert(creds); + trigger->creds = *creds; +} + +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 struct lttng_credentials creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(uid), + .gid = LTTNG_OPTIONAL_INIT_UNSET, + }; + + if (!trigger) { + ret = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + /* Client-side validation only to report a clearer error. */ + if (geteuid() != 0) { + ret = LTTNG_TRIGGER_STATUS_PERMISSION_DENIED; + goto end; + } + + lttng_trigger_set_credentials(trigger, &creds); + +end: + return ret; +} + +enum lttng_trigger_status lttng_trigger_get_owner_uid( + const struct lttng_trigger *trigger, uid_t *uid) +{ + enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; + const struct lttng_credentials *creds = NULL; + + if (!trigger || !uid ) { + ret = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + if (!trigger->creds.uid.is_set ) { + ret = LTTNG_TRIGGER_STATUS_UNSET; + goto end; + } + + creds = lttng_trigger_get_credentials(trigger); + *uid = lttng_credentials_get_uid(creds); + +end: + return ret; +}