Implement lttng_condition_event_rule_get_capture_bytecode_at_index

[lttng-tools.git] / src / common / conditions / event-rule.c

diff --git a/src/common/conditions/event-rule.c b/src/common/conditions/event-rule.c
index a08b3eb419a7e897d2e7118ea519274798eb40ec..dcc31ef8622ccdc823d5f85e2ed382d55666fc12 100644 (file)
--- a/src/common/conditions/event-rule.c
+++ b/src/common/conditions/event-rule.c
@@ -7,14 +7,16 @@
 
 #include <assert.h>
 #include <common/error.h>
+#include <common/event-expr-to-bytecode.h>
 #include <common/macros.h>
 #include <inttypes.h>
 #include <lttng/condition/condition-internal.h>
+#include <lttng/event-rule/event-rule-internal.h>
 #include <lttng/condition/event-rule-internal.h>
 #include <lttng/condition/event-rule.h>
 #include <lttng/event-expr-internal.h>
 #include <lttng/event-expr.h>
-#include <lttng/event-rule/event-rule-internal.h>
+#include <lttng/lttng-error.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <vendor/msgpack/msgpack.h>
@@ -192,6 +194,39 @@ end:
        return ret;
 }
 
+static
+struct lttng_capture_descriptor *
+lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+               const struct lttng_condition *condition, unsigned int index)
+{
+       const struct lttng_condition_event_rule *event_rule_cond =
+                       container_of(condition,
+                               const struct lttng_condition_event_rule,
+                               parent);
+       struct lttng_capture_descriptor *desc = NULL;
+       unsigned int count;
+       enum lttng_condition_status status;
+
+       if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+               goto end;
+       }
+
+       status = lttng_condition_event_rule_get_capture_descriptor_count(
+                       condition, &count);
+       if (status != LTTNG_CONDITION_STATUS_OK) {
+               goto end;
+       }
+
+       if (index >= count) {
+               goto end;
+       }
+
+       desc = lttng_dynamic_pointer_array_get_pointer(
+                       &event_rule_cond->capture_descriptors, index);
+end:
+       return desc;
+}
+
 static int lttng_condition_event_rule_serialize(
                const struct lttng_condition *condition,
                struct lttng_payload *payload)
@@ -233,13 +268,13 @@ static int lttng_condition_event_rule_serialize(
        }
 
        for (i = 0; i < capture_descr_count; i++) {
-               const struct lttng_event_expr *expr =
-                               lttng_condition_event_rule_get_capture_descriptor_at_index(
+               const struct lttng_capture_descriptor *desc =
+                               lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
                                                condition, i);
 
                DBG("Serializing event rule condition's capture descriptor %" PRIu32,
                                i);
-               ret = serialize_event_expr(expr, payload);
+               ret = serialize_event_expr(desc->event_expression, payload);
                if (ret) {
                        goto end;
                }
@@ -586,9 +621,9 @@ ssize_t lttng_condition_event_rule_create_from_payload(
 
        /* Capture descriptors. */
        for (i = 0; i < capture_descr_count; i++) {
+               enum lttng_condition_status status;
                struct lttng_event_expr *expr = event_expr_from_payload(
                                view, &offset);
-               enum lttng_condition_status status;
 
                if (!expr) {
                        goto error;
@@ -724,30 +759,14 @@ const struct lttng_event_expr *
 lttng_condition_event_rule_get_capture_descriptor_at_index(
                const struct lttng_condition *condition, unsigned int index)
 {
-       const struct lttng_condition_event_rule *event_rule_cond =
-                       container_of(condition,
-                               const struct lttng_condition_event_rule,
-                               parent);
        const struct lttng_event_expr *expr = NULL;
-       struct lttng_capture_descriptor *desc = NULL;
-       unsigned int count;
-       enum lttng_condition_status status;
-
-       if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
-               goto end;
-       }
+       const struct lttng_capture_descriptor *desc = NULL;
 
-       status = lttng_condition_event_rule_get_capture_descriptor_count(condition, &count);
-       if (status != LTTNG_CONDITION_STATUS_OK) {
-               goto end;
-       }
-
-       if (index >= count) {
+       desc = lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+                       condition, index);
+       if (desc == NULL) {
                goto end;
        }
-
-       desc = lttng_dynamic_pointer_array_get_pointer(
-                       &event_rule_cond->capture_descriptors, index);
        expr = desc->event_expression;
 
 end:
@@ -905,3 +924,90 @@ enum lttng_evaluation_status lttng_evaluation_event_rule_get_trigger_name(
 end:
        return status;
 }
+
+LTTNG_HIDDEN
+enum lttng_error_code
+lttng_condition_event_rule_generate_capture_descriptor_bytecode(
+               struct lttng_condition *condition)
+{
+       enum lttng_error_code ret;
+       enum lttng_condition_status status;
+       unsigned int capture_count, i;
+
+       if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+               ret = LTTNG_ERR_FATAL;
+               goto end;
+       }
+
+       status = lttng_condition_event_rule_get_capture_descriptor_count(
+                       condition, &capture_count);
+       if (status != LTTNG_CONDITION_STATUS_OK) {
+               ret = LTTNG_ERR_FATAL;
+               goto end;
+       }
+
+       for (i = 0; i < capture_count; i++) {
+               struct lttng_capture_descriptor *local_capture_desc =
+                               lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+                                               condition, i);
+
+               if (local_capture_desc == NULL) {
+                       ret = LTTNG_ERR_FATAL;
+                       goto end;
+               }
+
+               /* Generate the bytecode. */
+               status = lttng_event_expr_to_bytecode(
+                               local_capture_desc->event_expression,
+                               &local_capture_desc->bytecode);
+               if (status < 0 || local_capture_desc->bytecode == NULL) {
+                       ret = LTTNG_ERR_INVALID_CAPTURE_EXPRESSION;
+                       goto end;
+               }
+       }
+
+       /* Everything went better than expected */
+       ret = LTTNG_OK;
+
+end:
+       return ret;
+}
+
+LTTNG_HIDDEN
+const struct lttng_bytecode *
+lttng_condition_event_rule_get_capture_bytecode_at_index(
+               const struct lttng_condition *condition, unsigned int index)
+{
+       const struct lttng_condition_event_rule *event_rule_cond =
+                       container_of(condition,
+                               const struct lttng_condition_event_rule,
+                               parent);
+       struct lttng_capture_descriptor *desc = NULL;
+       struct lttng_bytecode *bytecode = NULL;
+       unsigned int count;
+       enum lttng_condition_status status;
+
+       if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+               goto end;
+       }
+
+       status = lttng_condition_event_rule_get_capture_descriptor_count(
+                       condition, &count);
+       if (status != LTTNG_CONDITION_STATUS_OK) {
+               goto end;
+       }
+
+       if (index >= count) {
+               goto end;
+       }
+
+       desc = lttng_dynamic_pointer_array_get_pointer(
+                       &event_rule_cond->capture_descriptors, index);
+       if (desc == NULL) {
+               goto end;
+       }
+
+       bytecode = desc->bytecode;
+end:
+       return bytecode;
+}