X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=e69e72e076267be0b7b6290b9032cc11b941caa1;hp=af0c5fa348166b833c61331f19f2cc2dba69567d;hb=6808ef55e;hpb=242388e491e4219f967ee424d7bf02035a313e6f diff --git a/src/common/trigger.c b/src/common/trigger.c index af0c5fa34..e69e72e07 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -128,7 +129,7 @@ void lttng_trigger_destroy(struct lttng_trigger *trigger) LTTNG_HIDDEN ssize_t lttng_trigger_create_from_payload( struct lttng_payload_view *src_view, - struct lttng_trigger **trigger) + struct lttng_trigger **_trigger) { ssize_t ret, offset = 0, condition_size, action_size, name_size = 0; struct lttng_condition *condition = NULL; @@ -139,14 +140,24 @@ ssize_t lttng_trigger_create_from_payload( .uid = LTTNG_OPTIONAL_INIT_UNSET, .gid = LTTNG_OPTIONAL_INIT_UNSET, }; + struct lttng_trigger *trigger = NULL; + const struct lttng_payload_view trigger_comm_view = + lttng_payload_view_from_view( + src_view, 0, sizeof(*trigger_comm)); + + if (!src_view || !_trigger) { + ret = -1; + goto end; + } - if (!src_view || !trigger) { + if (!lttng_payload_view_is_valid(&trigger_comm_view)) { + /* Payload not large enough to contain the header. */ ret = -1; goto end; } /* lttng_trigger_comm header */ - trigger_comm = (typeof(trigger_comm)) src_view->buffer.data; + trigger_comm = (typeof(trigger_comm)) trigger_comm_view.buffer.data; /* Set the trigger's creds. */ if (trigger_comm->uid > (uint64_t) ((uid_t) -1)) { @@ -163,7 +174,13 @@ ssize_t lttng_trigger_create_from_payload( /* Name. */ const struct lttng_payload_view name_view = lttng_payload_view_from_view( - src_view, offset, trigger_comm->name_length); + src_view, offset, + trigger_comm->name_length); + + if (!lttng_payload_view_is_valid(&name_view)) { + ret = -1; + goto end; + } name = name_view.buffer.data; if (!lttng_buffer_view_contains_string(&name_view.buffer, name, @@ -213,13 +230,13 @@ ssize_t lttng_trigger_create_from_payload( goto error; } - *trigger = lttng_trigger_create(condition, action); - if (!*trigger) { + trigger = lttng_trigger_create(condition, action); + if (!trigger) { ret = -1; goto error; } - lttng_trigger_set_credentials(*trigger, &creds); + lttng_trigger_set_credentials(trigger, &creds); /* * The trigger object owns references to the action and condition @@ -233,7 +250,7 @@ ssize_t lttng_trigger_create_from_payload( if (name) { const enum lttng_trigger_status status = - lttng_trigger_set_name(*trigger, name); + lttng_trigger_set_name(trigger, name); if (status != LTTNG_TRIGGER_STATUS_OK) { ret = -1; @@ -244,9 +261,15 @@ ssize_t lttng_trigger_create_from_payload( ret = offset; error: - lttng_condition_destroy(condition); - lttng_action_destroy(action); + lttng_condition_put(condition); + lttng_action_put(action); end: + if (ret == 0) { + *_trigger = trigger; + } else { + lttng_trigger_put(trigger); + } + return ret; } @@ -255,7 +278,7 @@ end: * for the detailed format. */ LTTNG_HIDDEN -int lttng_trigger_serialize(struct lttng_trigger *trigger, +int lttng_trigger_serialize(const struct lttng_trigger *trigger, struct lttng_payload *payload) { int ret; @@ -395,6 +418,22 @@ end: return ret; } +LTTNG_HIDDEN +void lttng_trigger_set_tracer_token(struct lttng_trigger *trigger, + uint64_t token) +{ + assert(trigger); + LTTNG_OPTIONAL_SET(&trigger->tracer_token, token); +} + +LTTNG_HIDDEN +uint64_t lttng_trigger_get_tracer_token(const struct lttng_trigger *trigger) +{ + assert(trigger); + + return LTTNG_OPTIONAL_GET(trigger->tracer_token); +} + LTTNG_HIDDEN int lttng_trigger_generate_name(struct lttng_trigger *trigger, uint64_t unique_id) @@ -432,6 +471,210 @@ void lttng_trigger_put(struct lttng_trigger *trigger) urcu_ref_put(&trigger->ref , trigger_destroy_ref); } +static void delete_trigger_array_element(void *ptr) +{ + struct lttng_trigger *trigger = ptr; + + lttng_trigger_put(trigger); +} + +LTTNG_HIDDEN +struct lttng_triggers *lttng_triggers_create(void) +{ + struct lttng_triggers *triggers = NULL; + + triggers = zmalloc(sizeof(*triggers)); + if (!triggers) { + goto end; + } + + lttng_dynamic_pointer_array_init(&triggers->array, delete_trigger_array_element); + +end: + return triggers; +} + +LTTNG_HIDDEN +struct lttng_trigger *lttng_triggers_borrow_mutable_at_index( + const struct lttng_triggers *triggers, unsigned int index) +{ + struct lttng_trigger *trigger = NULL; + + assert(triggers); + if (index >= lttng_dynamic_pointer_array_get_count(&triggers->array)) { + goto end; + } + + trigger = (struct lttng_trigger *) + lttng_dynamic_pointer_array_get_pointer( + &triggers->array, index); +end: + return trigger; +} + +LTTNG_HIDDEN +int lttng_triggers_add( + struct lttng_triggers *triggers, struct lttng_trigger *trigger) +{ + int ret; + + assert(triggers); + assert(trigger); + + lttng_trigger_get(trigger); + + ret = lttng_dynamic_pointer_array_add_pointer(&triggers->array, trigger); + if (ret) { + lttng_trigger_put(trigger); + } + + return ret; +} + +const struct lttng_trigger *lttng_triggers_get_at_index( + const struct lttng_triggers *triggers, unsigned int index) +{ + return lttng_triggers_borrow_mutable_at_index(triggers, index); +} + +enum lttng_trigger_status lttng_triggers_get_count(const struct lttng_triggers *triggers, unsigned int *count) +{ + enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; + + if (!triggers || !count) { + status = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + *count = lttng_dynamic_pointer_array_get_count(&triggers->array); +end: + return status; +} + +void lttng_triggers_destroy(struct lttng_triggers *triggers) +{ + if (!triggers) { + return; + } + + lttng_dynamic_pointer_array_reset(&triggers->array); + free(triggers); +} + +int lttng_triggers_serialize(const struct lttng_triggers *triggers, + struct lttng_payload *payload) +{ + int ret; + unsigned int i, count; + size_t size_before_payload; + struct lttng_triggers_comm triggers_comm = {}; + struct lttng_triggers_comm *header; + enum lttng_trigger_status status; + const size_t header_offset = payload->buffer.size; + + status = lttng_triggers_get_count(triggers, &count); + if (status != LTTNG_TRIGGER_STATUS_OK) { + ret = LTTNG_ERR_INVALID; + goto end; + } + + triggers_comm.count = count; + + /* Placeholder header; updated at the end. */ + ret = lttng_dynamic_buffer_append(&payload->buffer, &triggers_comm, + sizeof(triggers_comm)); + if (ret) { + goto end; + } + + size_before_payload = payload->buffer.size; + + for (i = 0; i < count; i++) { + const struct lttng_trigger *trigger = + lttng_triggers_get_at_index(triggers, i); + + assert(trigger); + + ret = lttng_trigger_serialize(trigger, payload); + if (ret) { + goto end; + } + } + + /* Update payload size. */ + header = (struct lttng_triggers_comm *) ((char *) payload->buffer.data + header_offset); + header->length = payload->buffer.size - size_before_payload; +end: + return ret; +} + +LTTNG_HIDDEN +ssize_t lttng_triggers_create_from_payload( + struct lttng_payload_view *src_view, + struct lttng_triggers **triggers) +{ + ssize_t ret, offset = 0, triggers_size = 0; + unsigned int i; + const struct lttng_triggers_comm *triggers_comm; + struct lttng_triggers *local_triggers = NULL; + + if (!src_view || !triggers) { + ret = -1; + goto error; + } + + /* lttng_trigger_comms header */ + triggers_comm = (const struct lttng_triggers_comm *) src_view->buffer.data; + offset += sizeof(*triggers_comm); + + local_triggers = lttng_triggers_create(); + if (!local_triggers) { + ret = -1; + goto error; + } + + for (i = 0; i < triggers_comm->count; i++) { + struct lttng_trigger *trigger = NULL; + struct lttng_payload_view trigger_view = + lttng_payload_view_from_view(src_view, offset, -1); + ssize_t trigger_size; + + trigger_size = lttng_trigger_create_from_payload( + &trigger_view, &trigger); + if (trigger_size < 0) { + ret = trigger_size; + goto error; + } + + /* Transfer ownership of the trigger to the collection. */ + ret = lttng_triggers_add(local_triggers, trigger); + lttng_trigger_put(trigger); + if (ret < 0) { + ret = -1; + goto error; + } + + offset += trigger_size; + triggers_size += trigger_size; + } + + /* Unexpected size of inner-elements; the buffer is corrupted. */ + if ((ssize_t) triggers_comm->length != triggers_size) { + ret = -1; + goto error; + } + + /* Pass ownership to caller. */ + *triggers = local_triggers; + local_triggers = NULL; + + ret = offset; +error: + + lttng_triggers_destroy(local_triggers); + return ret; +} + LTTNG_HIDDEN const struct lttng_credentials *lttng_trigger_get_credentials( const struct lttng_trigger *trigger)