+ trigger->creds = *creds;
+}
+
+enum lttng_trigger_status lttng_trigger_set_user_identity(
+ struct lttng_trigger *trigger, uid_t uid)
+{
+ enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK;
+ struct lttng_credentials creds = {
+ .uid = LTTNG_OPTIONAL_INIT_UNSET,
+ .gid = LTTNG_OPTIONAL_INIT_UNSET,
+ };
+
+ if (!trigger) {
+ ret = LTTNG_TRIGGER_STATUS_INVALID;
+ goto end;
+ }
+
+ if (geteuid() != 0) {
+ ret = LTTNG_TRIGGER_STATUS_EPERM;
+ goto end;
+ }
+
+ LTTNG_OPTIONAL_SET(&creds.uid, uid);
+
+ lttng_trigger_set_credentials(trigger, &creds);
+
+end:
+ return ret;
+}
+
+enum lttng_trigger_status lttng_trigger_get_user_identity(
+ 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;
+}
+
+LTTNG_HIDDEN
+uint64_t lttng_trigger_get_error_count(
+ const struct lttng_trigger *trigger)
+{
+ return LTTNG_OPTIONAL_GET(trigger->error_count);
+}
+
+LTTNG_HIDDEN
+void lttng_trigger_set_error_count(
+ struct lttng_trigger *trigger,
+ uint64_t error_count)
+{
+ LTTNG_OPTIONAL_SET(&trigger->error_count, error_count);
+}
+
+enum lttng_trigger_status lttng_trigger_set_firing_policy(
+ struct lttng_trigger *trigger,
+ enum lttng_trigger_firing_policy_type 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_type *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)
+{
+ assert(trigger);
+ bool ready_to_fire = false;
+
+ switch (trigger->firing_policy.type) {
+ case LTTNG_TRIGGER_FIRE_EVERY_N:
+ if (trigger->firing_policy.current_count < trigger->firing_policy.threshold) {
+ ready_to_fire = true;
+ }
+ break;
+ case LTTNG_TRIGGER_FIRE_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_FIRE_EVERY_N:
+ if (trigger->firing_policy.current_count == trigger->firing_policy.threshold) {
+ trigger->firing_policy.current_count = 0;
+ }
+ break;
+ case LTTNG_TRIGGER_FIRE_ONCE_AFTER_N:
+ /*
+ * TODO: deactivate the trigger condition on
+ * remove any work overhead on 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)
+{
+ 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);
+ c_type = lttng_condition_get_type(trigger->condition);
+ if (c_type == LTTNG_CONDITION_TYPE_UNKNOWN) {
+ assert(0);
+ }
+
+ switch (c_type) {
+ case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
+ case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
+ case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
+ type = LTTNG_DOMAIN_NONE;
+ break;
+ case LTTNG_CONDITION_TYPE_EVENT_RULE_HIT:
+ c_status = lttng_condition_event_rule_get_rule(
+ trigger->condition, &event_rule);
+ if (c_status != LTTNG_CONDITION_STATUS_OK) {
+ /* The condition object is invalid */
+ assert(0);
+ }
+
+ type = lttng_event_rule_get_domain_type(event_rule);
+ break;
+ case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
+ case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
+ c_status = lttng_condition_buffer_usage_get_domain_type(
+ trigger->condition, &type);
+ if (c_status != LTTNG_CONDITION_STATUS_OK) {
+ /* The condition object is invalid */
+ assert(0);
+ }
+ break;
+ default:
+ type = LTTNG_DOMAIN_NONE;
+ break;
+ }
+
+ return type;
+}
+
+LTTNG_HIDDEN
+struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger)
+{
+ int ret;
+ struct lttng_payload copy_buffer;
+ struct lttng_trigger *copy = NULL;
+
+ lttng_payload_init(©_buffer);
+
+ ret = lttng_trigger_serialize(trigger, ©_buffer);
+ if (ret < 0) {
+ goto end;
+ }
+
+ {
+ 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:
+ lttng_payload_reset(©_buffer);
+ return copy;
+}
+
+LTTNG_HIDDEN
+unsigned int lttng_trigger_get_capture_bytecode_count(
+ const struct lttng_trigger *trigger)
+{
+ unsigned int count = 0;
+ if (!trigger) {
+ goto end;
+ }
+
+ count = lttng_dynamic_pointer_array_get_count(
+ &trigger->capture_bytecode_set);
+
+end:
+ return count;
+}
+
+LTTNG_HIDDEN
+const struct lttng_bytecode *
+lttng_trigger_get_capture_bytecode_at_index(
+ const struct lttng_trigger *trigger, unsigned int index)
+{
+ struct lttng_condition_event_rule_capture_bytecode_element *element = NULL;
+ struct lttng_bytecode *bytecode = NULL;
+
+ element = lttng_dynamic_pointer_array_get_pointer(
+ &trigger->capture_bytecode_set, index);
+
+ if (element == NULL) {
+ goto end;
+ }
+ bytecode = element->bytecode;
+end:
+ return bytecode;