Cleanup: enforce const-correctness in notification thread

[lttng-tools.git] / src / common / buffer-usage.c

diff --git a/src/common/buffer-usage.c b/src/common/buffer-usage.c
index 49696a33f8e7883e9688df10807bada844778568..e19a875c9b96ccd1e3f3d395f03787dc03d8b32e 100644 (file)
--- a/src/common/buffer-usage.c
+++ b/src/common/buffer-usage.c
@@ -88,6 +88,10 @@ bool lttng_condition_buffer_usage_validate(
                ERR("Invalid buffer condition: a threshold must be set.");
                goto end;
        }
+       if (!usage->domain.set) {
+               ERR("Invalid buffer usage condition: a domain must be set.");
+               goto end;
+       }
 
        valid = true;
 end:
@@ -95,12 +99,14 @@ end:
 }
 
 static
-ssize_t lttng_condition_buffer_usage_serialize(
-               const struct lttng_condition *condition, char *buf)
+int lttng_condition_buffer_usage_serialize(
+               const struct lttng_condition *condition,
+               struct lttng_dynamic_buffer *buf)
 {
+       int ret;
        struct lttng_condition_buffer_usage *usage;
-       ssize_t ret, size;
        size_t session_name_len, channel_name_len;
+       struct lttng_condition_buffer_usage_comm usage_comm;
 
        if (!condition || !IS_USAGE_CONDITION(condition)) {
                ret = -1;
@@ -110,7 +116,7 @@ ssize_t lttng_condition_buffer_usage_serialize(
        DBG("Serializing buffer usage condition");
        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;
        if (session_name_len > LTTNG_NAME_MAX ||
@@ -118,37 +124,41 @@ ssize_t lttng_condition_buffer_usage_serialize(
                ret = -1;
                goto end;
        }
-       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 = usage->threshold_bytes.value;
-               } else {
-                       uint64_t val = double_to_fixed(
-                                       usage->threshold_ratio.value);
-
-                       if (val > UINT32_MAX) {
-                               /* overflow. */
-                               ret = -1;
-                               goto end;
-                       }
-                       usage_comm.threshold = val;
+
+       usage_comm.threshold_set_in_bytes = !!usage->threshold_bytes.set;
+       usage_comm.session_name_len = session_name_len;
+       usage_comm.channel_name_len = channel_name_len;
+       usage_comm.domain_type = (int8_t) usage->domain.type;
+
+       if (usage->threshold_bytes.set) {
+               usage_comm.threshold = usage->threshold_bytes.value;
+       } else {
+               uint64_t val = double_to_fixed(
+                               usage->threshold_ratio.value);
+
+               if (val > UINT32_MAX) {
+                       /* overflow. */
+                       ret = -1;
+                       goto end;
                }
+               usage_comm.threshold = val;
+       }
 
-               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;
+       ret = lttng_dynamic_buffer_append(buf, &usage_comm,
+                       sizeof(usage_comm));
+       if (ret) {
+               goto end;
+       }
+       ret = lttng_dynamic_buffer_append(buf, usage->session_name,
+                       session_name_len);
+       if (ret) {
+               goto end;
+       }
+       ret = lttng_dynamic_buffer_append(buf, usage->channel_name,
+                       channel_name_len);
+       if (ret) {
+               goto end;
        }
-       ret = size;
 end:
        return ret;
 }
@@ -188,36 +198,24 @@ bool lttng_condition_buffer_usage_is_equal(const struct lttng_condition *_a,
                }
        }
 
-       if ((a->session_name && !b->session_name) ||
-                       (!a->session_name && b->session_name)) {
+       /* Condition is not valid if this is not true. */
+       assert(a->session_name);
+       assert(b->session_name);
+       if (strcmp(a->session_name, b->session_name)) {
                goto end;
        }
 
-       if (a->channel_name && b->channel_name) {
-               if (strcmp(a->channel_name, b->channel_name)) {
-                       goto end;
-               }
-       }       if ((a->channel_name && !b->channel_name) ||
-                       (!a->channel_name && b->channel_name)) {
+       assert(a->channel_name);
+       assert(b->channel_name);
+       if (strcmp(a->channel_name, b->channel_name)) {
                goto end;
        }
 
-       if (a->channel_name && b->channel_name) {
-               if (strcmp(a->channel_name, b->channel_name)) {
-                       goto end;
-               }
-       }
-
-       if ((a->domain.set && !b->domain.set) ||
-                       (!a->domain.set && b->domain.set)) {
+       assert(a->domain.set);
+       assert(b->domain.set);
+       if (a->domain.type != b->domain.type) {
                goto end;
        }
-
-       if (a->domain.set && b->domain.set) {
-               if (a->domain.type != b->domain.type) {
-                       goto end;
-               }
-       }
        is_equal = true;
 end:
        return is_equal;
@@ -231,7 +229,7 @@ struct lttng_condition *lttng_condition_buffer_usage_create(
 
        condition = zmalloc(sizeof(struct lttng_condition_buffer_usage));
        if (!condition) {
-               goto end;
+               return NULL;
        }
 
        lttng_condition_init(&condition->parent, type);
@@ -239,7 +237,6 @@ struct lttng_condition *lttng_condition_buffer_usage_create(
        condition->parent.serialize = lttng_condition_buffer_usage_serialize;
        condition->parent.equal = lttng_condition_buffer_usage_is_equal;
        condition->parent.destroy = lttng_condition_buffer_usage_destroy;
-end:
        return &condition->parent;
 }
 
@@ -741,25 +738,19 @@ end:
 }
 
 static
-ssize_t lttng_evaluation_buffer_usage_serialize(
-               struct lttng_evaluation *evaluation, char *buf)
+int lttng_evaluation_buffer_usage_serialize(
+               const struct lttng_evaluation *evaluation,
+               struct lttng_dynamic_buffer *buf)
 {
-       ssize_t ret;
        struct lttng_evaluation_buffer_usage *usage;
+       struct lttng_evaluation_buffer_usage_comm comm;
 
        usage = container_of(evaluation, struct lttng_evaluation_buffer_usage,
                        parent);
-       if (buf) {
-               struct lttng_evaluation_buffer_usage_comm comm = {
-                       .buffer_use = usage->buffer_use,
-                       .buffer_capacity = usage->buffer_capacity,
-               };
+       comm.buffer_use = usage->buffer_use;
+       comm.buffer_capacity = usage->buffer_capacity;
 
-               memcpy(buf, &comm, sizeof(comm));
-       }
-
-       ret = sizeof(struct lttng_evaluation_buffer_usage_comm);
-       return ret;
+       return lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
 }
 
 static