Add serialization of trigger, condition and action classes

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/include/lttng/action/action-internal.h b/include/lttng/action/action-internal.h
index 9a06bc8d862c341c3382111ee6a49c8691d7fc61..57a804d14fb45503816ec6c4014cb8cda0c196d8 100644 (file)
--- a/include/lttng/action/action-internal.h
+++ b/include/lttng/action/action-internal.h
@@ -24,14 +24,24 @@
 
 typedef bool (*action_validate_cb)(struct lttng_action *action);
 typedef void (*action_destroy_cb)(struct lttng_action *action);
+typedef ssize_t (*action_serialize_cb)(struct lttng_action *action, char *buf);
 
 struct lttng_action {
        enum lttng_action_type type;
        action_validate_cb validate;
+       action_serialize_cb serialize;
        action_destroy_cb destroy;
 };
 
+struct lttng_action_comm {
+       /* enum lttng_action_type */
+       int8_t action_type;
+} LTTNG_PACKED;
+
 LTTNG_HIDDEN
 bool lttng_action_validate(struct lttng_action *action);
 
+LTTNG_HIDDEN
+ssize_t lttng_action_serialize(struct lttng_action *action, char *buf);
+
 #endif /* LTTNG_ACTION_INTERNAL_H */

diff --git a/include/lttng/condition/buffer-usage-internal.h b/include/lttng/condition/buffer-usage-internal.h
index c3f473cc2d1ccda8b4b915788d3ce2ff75554f6d..b8cb50cccb8ee16d32cf188c9444fd79f08bc43a 100644 (file)
--- a/include/lttng/condition/buffer-usage-internal.h
+++ b/include/lttng/condition/buffer-usage-internal.h
@@ -42,6 +42,21 @@ struct lttng_condition_buffer_usage {
        } domain;
 };
 
+struct lttng_condition_buffer_usage_comm {
+       uint8_t threshold_set_in_bytes;
+       union {
+               double percent;
+               uint64_t bytes;
+       } threshold;
+       /* Both lengths include the trailing \0. */
+       uint32_t session_name_len;
+       uint32_t channel_name_len;
+       /* enum lttng_domain_type */
+       int8_t domain_type;
+       /* session and channel names. */
+       char names[];
+} LTTNG_PACKED;
+
 struct lttng_evaluation_buffer_usage {
        struct lttng_evaluation parent;
        uint64_t buffer_use;

diff --git a/include/lttng/condition/condition-internal.h b/include/lttng/condition/condition-internal.h
index a0a7c779378a3a873b17eda2445e9ca76fb1945e..62df6c1e812d49949f4fda6a3efc25eb5bb7ca10 100644 (file)
--- a/include/lttng/condition/condition-internal.h
+++ b/include/lttng/condition/condition-internal.h
@@ -24,14 +24,24 @@
 
 typedef void (*condition_destroy_cb)(struct lttng_condition *condition);
 typedef bool (*condition_validate_cb)(struct lttng_condition *condition);
+typedef ssize_t (*condition_serialize_cb)(struct lttng_condition *condition,
+               char *buf);
 
 struct lttng_condition {
        enum lttng_condition_type type;
        condition_validate_cb validate;
+       condition_serialize_cb serialize;
        condition_destroy_cb destroy;
 };
 
+struct lttng_condition_comm {
+       int8_t condition_type;
+};
+
 LTTNG_HIDDEN
 bool lttng_condition_validate(struct lttng_condition *condition);
 
+LTTNG_HIDDEN
+ssize_t lttng_condition_serialize(struct lttng_condition *action, char *buf);
+
 #endif /* LTTNG_CONDITION_INTERNAL_H */

diff --git a/src/lib/lttng-ctl/action.c b/src/lib/lttng-ctl/action.c
index cfad63372b623668eaeaee783a8bd62ca4a8b5ef..a97a3463f5500ea4fd0f444b7ba44491aa219c57 100644 (file)
--- a/src/lib/lttng-ctl/action.c
+++ b/src/lib/lttng-ctl/action.c
@@ -53,3 +53,31 @@ bool lttng_action_validate(struct lttng_action *action)
 end:
        return valid;
 }
+
+LTTNG_HIDDEN
+ssize_t lttng_action_serialize(struct lttng_action *action, char *buf)
+{
+       ssize_t ret, action_size;
+       struct lttng_action_comm action_comm;
+
+       if (!action) {
+               ret = -1;
+               goto end;
+       }
+
+       action_comm.action_type = (int8_t) action->type;
+       ret = sizeof(struct lttng_action_comm);
+       if (buf) {
+               memcpy(buf, &action_comm, ret);
+               buf += ret;
+       }
+
+       action_size = action->serialize(action, buf);
+       if (action_size < 0) {
+               ret = action_size;
+               goto end;
+       }
+       ret += action_size;
+end:
+       return ret;
+}

diff --git a/src/lib/lttng-ctl/buffer-usage.c b/src/lib/lttng-ctl/buffer-usage.c
index b6e4c8cd86ebfba1fd095d570aeee8988cc65c52..233aa8ed157cd64534315e1a3d42d76e23dbd7c2 100644 (file)
--- a/src/lib/lttng-ctl/buffer-usage.c
+++ b/src/lib/lttng-ctl/buffer-usage.c
@@ -78,6 +78,52 @@ end:
        return valid;
 }
 
+static
+ssize_t lttng_condition_buffer_usage_serialize(struct lttng_condition *condition,
+               char *buf)
+{
+       struct lttng_condition_buffer_usage *usage;
+       ssize_t size;
+       size_t session_name_len, channel_name_len;
+
+       if (!condition || !is_usage_condition(condition)) {
+               size = -1;
+               goto end;
+       }
+
+       usage = container_of(condition, struct lttng_condition_buffer_usage,
+                       parent);
+       size = sizeof(struct lttng_condition_buffer_usage_comm);
+       session_name_len = strlen(usage->session_name) + 1;
+       channel_name_len = strlen(usage->channel_name) + 1;
+       size += session_name_len + channel_name_len;
+       if (buf) {
+               struct lttng_condition_buffer_usage_comm usage_comm = {
+                       .threshold_set_in_bytes = usage->threshold_bytes.set ? 1 : 0,
+                       .session_name_len = session_name_len,
+                       .channel_name_len = channel_name_len,
+                       .domain_type = (int8_t) usage->domain.type,
+               };
+
+               if (usage->threshold_bytes.set) {
+                       usage_comm.threshold.bytes =
+                                       usage->threshold_bytes.value;
+               } else {
+                       usage_comm.threshold.percent =
+                                       usage->threshold_percent.value;
+               }
+
+               memcpy(buf, &usage_comm, sizeof(usage_comm));
+               buf += sizeof(usage_comm);
+               memcpy(buf, usage->session_name, session_name_len);
+               buf += session_name_len;
+               memcpy(buf, usage->channel_name, channel_name_len);
+               buf += channel_name_len;
+       }
+end:
+       return size;
+}
+
 static
 struct lttng_condition *lttng_condition_buffer_usage_create(
                enum lttng_condition_type type)
@@ -91,6 +137,7 @@ struct lttng_condition *lttng_condition_buffer_usage_create(
 
        condition->parent.type = type;
        condition->parent.validate = lttng_condition_buffer_usage_validate;
+       condition->parent.serialize = lttng_condition_buffer_usage_serialize;
        condition->parent.destroy = lttng_condition_buffer_usage_destroy;
 end:
        return &condition->parent;

diff --git a/src/lib/lttng-ctl/condition.c b/src/lib/lttng-ctl/condition.c
index 76f416d429eb590343fcfe94bff44e1e884c6722..b3091576a6011baf649d3b45e22913d9f1cc6c31 100644 (file)
--- a/src/lib/lttng-ctl/condition.c
+++ b/src/lib/lttng-ctl/condition.c
@@ -56,3 +56,31 @@ bool lttng_condition_validate(struct lttng_condition *condition)
 end:
        return valid;
 }
+
+LTTNG_HIDDEN
+ssize_t lttng_condition_serialize(struct lttng_condition *condition, char *buf)
+{
+       ssize_t ret, condition_size;
+       struct lttng_condition_comm condition_comm;
+
+       if (!condition) {
+               ret = -1;
+               goto end;
+       }
+
+       condition_comm.condition_type = (int8_t) condition->type;
+       ret = sizeof(struct lttng_condition_comm);
+       if (buf) {
+               memcpy(buf, &condition_comm, ret);
+               buf += ret;
+       }
+
+       condition_size = condition->serialize(condition, buf);
+       if (condition_size < 0) {
+               ret = condition_size;
+               goto end;
+       }
+       ret += condition_size;
+end:
+       return ret;
+}

diff --git a/src/lib/lttng-ctl/notify.c b/src/lib/lttng-ctl/notify.c
index 5011cdbcef464998c10ced25911c99805d0b4bcf..956c0ecfff4a347ef092d725d8d9032d8538b5dd 100644 (file)
--- a/src/lib/lttng-ctl/notify.c
+++ b/src/lib/lttng-ctl/notify.c
@@ -26,6 +26,12 @@ void lttng_action_notify_destroy(struct lttng_action *action)
        free(action);
 }
 
+static
+ssize_t lttng_action_notify_serialize(struct lttng_action *action, char *buf)
+{
+       return 0;
+}
+
 struct lttng_action *lttng_action_notify_create(void)
 {
        struct lttng_action_notify *notify;
@@ -36,6 +42,7 @@ struct lttng_action *lttng_action_notify_create(void)
        }
 
        notify->parent.type = LTTNG_ACTION_TYPE_NOTIFY;
+       notify->parent.serialize = lttng_action_notify_serialize;
        notify->parent.destroy = lttng_action_notify_destroy;
 end:
        return &notify->parent;

diff --git a/src/lib/lttng-ctl/trigger.c b/src/lib/lttng-ctl/trigger.c
index cbcd807d7f6198d96eff5b2621dd5f576e595a06..b2b51b86541143fdf944ba49b624f24f78086065 100644 (file)
--- a/src/lib/lttng-ctl/trigger.c
+++ b/src/lib/lttng-ctl/trigger.c
@@ -16,8 +16,8 @@
  */
 
 #include <lttng/trigger/trigger-internal.h>
-#include <lttng/condition/condition.h>
-#include <lttng/action/action.h>
+#include <lttng/condition/condition-internal.h>
+#include <lttng/action/action-internal.h>
 #include <assert.h>
 
 struct lttng_trigger *lttng_trigger_create(
@@ -51,3 +51,28 @@ void lttng_trigger_destroy(struct lttng_trigger *trigger)
        lttng_action_destroy(trigger->action);
        free(trigger);
 }
+
+ssize_t lttng_trigger_serialize(struct lttng_trigger *trigger, char *buf)
+{
+       ssize_t action_size, condition_size, ret;
+
+       if (!trigger) {
+               ret = -1;
+               goto end;
+       }
+
+       condition_size = lttng_condition_serialize(trigger->condition, buf);
+       if (condition_size < 0) {
+               ret = -1;
+               goto end;
+       }
+
+       action_size = lttng_action_serialize(trigger->action, buf);
+       if (action_size < 0) {
+               ret = -1;
+               goto end;
+       }
+       ret = action_size + condition_size;
+end:
+       return ret;
+}