lttng-ctl: separate support of named/unnamed trigger registration

[lttng-tools.git] / src / common / trigger.c

diff --git a/src/common/trigger.c b/src/common/trigger.c
index ec96fc80b7d804249c8c4f1f395d4a693080fd1e..d740c80c77a377f8ff1a9a7141f6e7682e67cb62 100644 (file)
--- a/src/common/trigger.c
+++ b/src/common/trigger.c
@@ -16,8 +16,8 @@
 #include <lttng/action/action-internal.h>
 #include <lttng/condition/buffer-usage.h>
 #include <lttng/condition/condition-internal.h>
-#include <lttng/condition/on-event-internal.h>
-#include <lttng/condition/on-event.h>
+#include <lttng/condition/event-rule-matches-internal.h>
+#include <lttng/condition/event-rule-matches.h>
 #include <lttng/domain.h>
 #include <lttng/event-expr-internal.h>
 #include <lttng/event-rule/event-rule-internal.h>
@@ -346,7 +346,12 @@ LTTNG_HIDDEN
 bool lttng_trigger_is_equal(
                const struct lttng_trigger *a, const struct lttng_trigger *b)
 {
-       if (strcmp(a->name, b->name) != 0) {
+       if (!!a->name != !!b->name) {
+               /* Both must be either anonymous or named. */
+               return false;
+       }
+
+       if (a->name && strcmp(a->name, b->name) != 0) {
                return false;
        }
 
@@ -366,22 +371,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);
@@ -704,6 +711,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,
@@ -715,7 +723,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;
        }
@@ -771,9 +779,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);
@@ -811,12 +819,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);
 
@@ -828,7 +836,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;
@@ -850,11 +858,35 @@ 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(&copy_buffer);
 
-       ret = lttng_trigger_serialize(trigger, &copy_buffer);
+       ret = lttng_condition_serialize(trigger->condition, &copy_buffer);
+       if (ret < 0) {
+               goto end;
+       }
+
+       {
+               struct lttng_payload_view view =
+                               lttng_payload_view_from_payload(
+                                               &copy_buffer, 0, -1);
+
+               ret = lttng_condition_create_from_payload(
+                               &view, &condition_copy);
+               if (ret < 0) {
+                       goto end;
+               }
+       }
+
+       lttng_payload_clear(&copy_buffer);
+
+       ret = lttng_action_serialize(trigger->action, &copy_buffer);
        if (ret < 0) {
                goto end;
        }
@@ -863,15 +895,59 @@ struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger)
                struct lttng_payload_view view =
                                lttng_payload_view_from_payload(
                                                &copy_buffer, 0, -1);
-               ret = lttng_trigger_create_from_payload(
-                               &view, &copy);
+
+               ret = lttng_action_create_from_payload(
+                               &view, &action_copy);
                if (ret < 0) {
-                       copy = NULL;
                        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(&copy->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(&copy_buffer);
        return copy;
 }
@@ -884,7 +960,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: