projects / lttng-tools.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix: syscall event rule: emission sites not compared in is_equal
[lttng-tools.git] / src / common / event-field-value.cpp
diff --git a/src/common/event-field-value.cpp b/src/common/event-field-value.cpp
index 816017a2da77fe1e316fdf0f347c1bcfa0512df4..a52f192684093bf7ab996313e0546a27a346594d 100644 (file)
--- a/src/common/event-field-value.cpp
+++ b/src/common/event-field-value.cpp
@@ -10,20 +10,20 @@
  */
 
 #define _LGPL_SOURCE
-#include <stddef.h>
-#include <stdbool.h>
-
 #include <common/error.hpp>
 #include <common/macros.hpp>
+
 #include <lttng/event-field-value-internal.hpp>
 
-static
-struct lttng_event_field_value *create_empty_field_val(
-               enum lttng_event_field_value_type type, size_t size)
+#include <stdbool.h>
+#include <stddef.h>
+
+static struct lttng_event_field_value *
+create_empty_field_val(enum lttng_event_field_value_type type, size_t size)
 {
        struct lttng_event_field_value *field_val;
 
-       field_val = (lttng_event_field_value *) zmalloc(size);
+       field_val = zmalloc<lttng_event_field_value>(size);
        if (!field_val) {
                goto end;
        }
@@ -34,15 +34,14 @@ end:
        return field_val;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_uint_create(
-               uint64_t val)
+struct lttng_event_field_value *lttng_event_field_value_uint_create(uint64_t val)
 {
        struct lttng_event_field_value_uint *field_val;
 
-       field_val = container_of(create_empty_field_val(
-                       LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT,
-                       sizeof(*field_val)),
-                       struct lttng_event_field_value_uint, parent);
+       field_val = lttng::utils::container_of(
+               create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT,
+                                      sizeof(*field_val)),
+               &lttng_event_field_value_uint::parent);
        if (!field_val) {
                goto error;
        }
@@ -57,15 +56,13 @@ end:
        return &field_val->parent;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_int_create(
-               int64_t val)
+struct lttng_event_field_value *lttng_event_field_value_int_create(int64_t val)
 {
        struct lttng_event_field_value_int *field_val;
 
-       field_val = container_of(create_empty_field_val(
-                       LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT,
-                       sizeof(*field_val)),
-                       struct lttng_event_field_value_int, parent);
+       field_val = lttng::utils::container_of(
+               create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT, sizeof(*field_val)),
+               &lttng_event_field_value_int::parent);
        if (!field_val) {
                goto error;
        }
@@ -80,14 +77,13 @@ end:
        return &field_val->parent;
 }
 
-static
-struct lttng_event_field_value_enum *create_enum_field_val(
-               enum lttng_event_field_value_type type, size_t size)
+static struct lttng_event_field_value_enum *
+create_enum_field_val(enum lttng_event_field_value_type type, size_t size)
 {
        struct lttng_event_field_value_enum *field_val;
 
-       field_val = container_of(create_empty_field_val(type, size),
-                       struct lttng_event_field_value_enum, parent);
+       field_val = lttng::utils::container_of(create_empty_field_val(type, size),
+                                              &lttng_event_field_value_enum::parent);
        if (!field_val) {
                goto error;
        }
@@ -102,15 +98,14 @@ end:
        return field_val;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_enum_uint_create(
-               uint64_t val)
+struct lttng_event_field_value *lttng_event_field_value_enum_uint_create(uint64_t val)
 {
        struct lttng_event_field_value_enum_uint *field_val;
 
-       field_val = container_of(create_enum_field_val(
-                       LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM,
-                       sizeof(*field_val)),
-                       struct lttng_event_field_value_enum_uint, parent);
+       field_val = lttng::utils::container_of(
+               create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM,
+                                     sizeof(*field_val)),
+               &lttng_event_field_value_enum_uint::parent);
        if (!field_val) {
                goto error;
        }
@@ -125,15 +120,13 @@ end:
        return &field_val->parent.parent;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_enum_int_create(
-               int64_t val)
+struct lttng_event_field_value *lttng_event_field_value_enum_int_create(int64_t val)
 {
        struct lttng_event_field_value_enum_int *field_val;
 
-       field_val = container_of(create_enum_field_val(
-                       LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM,
-                       sizeof(*field_val)),
-                       struct lttng_event_field_value_enum_int, parent);
+       field_val = lttng::utils::container_of(
+               create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM, sizeof(*field_val)),
+               &lttng_event_field_value_enum_int::parent);
        if (!field_val) {
                goto error;
        }
@@ -150,11 +143,9 @@ end:
 
 struct lttng_event_field_value *lttng_event_field_value_real_create(double val)
 {
-       struct lttng_event_field_value_real *field_val = container_of(
-                       create_empty_field_val(
-                               LTTNG_EVENT_FIELD_VALUE_TYPE_REAL,
-                               sizeof(*field_val)),
-                       struct lttng_event_field_value_real, parent);
+       struct lttng_event_field_value_real *field_val = lttng::utils::container_of(
+               create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_REAL, sizeof(*field_val)),
+               &lttng_event_field_value_real::parent);
 
        if (!field_val) {
                goto error;
@@ -170,21 +161,27 @@ end:
        return &field_val->parent;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_string_create_with_size(
-               const char *val, size_t size)
+struct lttng_event_field_value *lttng_event_field_value_string_create_with_size(const char *val,
+                                                                               size_t size)
 {
-       struct lttng_event_field_value_string *field_val = container_of(
-                       create_empty_field_val(
-                               LTTNG_EVENT_FIELD_VALUE_TYPE_STRING,
-                               sizeof(*field_val)),
-                       struct lttng_event_field_value_string, parent);
+       struct lttng_event_field_value_string *field_val = lttng::utils::container_of(
+               create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_STRING, sizeof(*field_val)),
+               &lttng_event_field_value_string::parent);
 
        if (!field_val) {
                goto error;
        }
 
-       LTTNG_ASSERT(val);
-       field_val->val = strndup(val, size);
+       if (size) {
+               LTTNG_ASSERT(val);
+               field_val->val = strndup(val, size);
+       } else {
+               /*
+                * User code do not expect a NULL string pointer. Populate with
+                * an empty string when length is 0.
+                */
+               field_val->val = strdup("");
+       }
        if (!field_val->val) {
                goto error;
        }
@@ -198,27 +195,22 @@ end:
        return &field_val->parent;
 }
 
-struct lttng_event_field_value *lttng_event_field_value_string_create(
-               const char *val)
+struct lttng_event_field_value *lttng_event_field_value_string_create(const char *val)
 {
        LTTNG_ASSERT(val);
-       return lttng_event_field_value_string_create_with_size(val,
-                       strlen(val));
+       return lttng_event_field_value_string_create_with_size(val, strlen(val));
 }
 
-static
-void destroy_field_val(void *field_val)
+static void destroy_field_val(void *field_val)
 {
        lttng_event_field_value_destroy((lttng_event_field_value *) field_val);
 }
 
-struct lttng_event_field_value *lttng_event_field_value_array_create(void)
+struct lttng_event_field_value *lttng_event_field_value_array_create()
 {
-       struct lttng_event_field_value_array *field_val = container_of(
-                       create_empty_field_val(
-                               LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY,
-                               sizeof(*field_val)),
-                       struct lttng_event_field_value_array, parent);
+       struct lttng_event_field_value_array *field_val = lttng::utils::container_of(
+               create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY, sizeof(*field_val)),
+               &lttng_event_field_value_array::parent);
 
        if (!field_val) {
                goto error;
@@ -244,28 +236,24 @@ void lttng_event_field_value_destroy(struct lttng_event_field_value *field_val)
        case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
        case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
        {
-               struct lttng_event_field_value_enum *enum_field_val =
-                               container_of(field_val,
-                                       struct lttng_event_field_value_enum, parent);
+               struct lttng_event_field_value_enum *enum_field_val = lttng::utils::container_of(
+                       field_val, &lttng_event_field_value_enum::parent);
 
                lttng_dynamic_pointer_array_reset(&enum_field_val->labels);
                break;
        }
        case LTTNG_EVENT_FIELD_VALUE_TYPE_STRING:
        {
-               struct lttng_event_field_value_string *str_field_val =
-                               container_of(field_val,
-                                       struct lttng_event_field_value_string, parent);
+               struct lttng_event_field_value_string *str_field_val = lttng::utils::container_of(
+                       field_val, &lttng_event_field_value_string::parent);
 
                free(str_field_val->val);
                break;
        }
        case LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY:
        {
-               struct lttng_event_field_value_array *array_field_expr =
-                               container_of(field_val,
-                                       struct lttng_event_field_value_array,
-                                       parent);
+               struct lttng_event_field_value_array *array_field_expr = lttng::utils::container_of(
+                       field_val, &lttng_event_field_value_array::parent);
 
                lttng_dynamic_pointer_array_reset(&array_field_expr->elems);
                break;
@@ -280,9 +268,9 @@ end:
        return;
 }
 
-int lttng_event_field_value_enum_append_label_with_size(
-               struct lttng_event_field_value *field_val,
-               const char *label, size_t size)
+int lttng_event_field_value_enum_append_label_with_size(struct lttng_event_field_value *field_val,
+                                                       const char *label,
+                                                       size_t size)
 {
        int ret;
        char *new_label;
@@ -296,11 +284,11 @@ int lttng_event_field_value_enum_append_label_with_size(
        }
 
        ret = lttng_dynamic_pointer_array_add_pointer(
-                       &container_of(field_val,
-                               struct lttng_event_field_value_enum, parent)->labels,
-                       new_label);
+               &lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
+                        ->labels,
+               new_label);
        if (ret == 0) {
-               new_label = NULL;
+               new_label = nullptr;
        }
 
 end:
@@ -308,39 +296,35 @@ end:
        return ret;
 }
 
-int lttng_event_field_value_enum_append_label(
-               struct lttng_event_field_value *field_val,
-               const char *label)
+int lttng_event_field_value_enum_append_label(struct lttng_event_field_value *field_val,
+                                             const char *label)
 {
        LTTNG_ASSERT(label);
-       return lttng_event_field_value_enum_append_label_with_size(field_val,
-                       label, strlen(label));
+       return lttng_event_field_value_enum_append_label_with_size(field_val, label, strlen(label));
 }
 
-int lttng_event_field_value_array_append(
-               struct lttng_event_field_value *array_field_val,
-               struct lttng_event_field_value *field_val)
+int lttng_event_field_value_array_append(struct lttng_event_field_value *array_field_val,
+                                        struct lttng_event_field_value *field_val)
 {
        LTTNG_ASSERT(array_field_val);
        LTTNG_ASSERT(field_val);
        return lttng_dynamic_pointer_array_add_pointer(
-                       &container_of(array_field_val,
-                               struct lttng_event_field_value_array, parent)->elems,
-                       field_val);
+               &lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
+                        ->elems,
+               field_val);
 }
 
-int lttng_event_field_value_array_append_unavailable(
-               struct lttng_event_field_value *array_field_val)
+int lttng_event_field_value_array_append_unavailable(struct lttng_event_field_value *array_field_val)
 {
        LTTNG_ASSERT(array_field_val);
        return lttng_dynamic_pointer_array_add_pointer(
-                       &container_of(array_field_val,
-                               struct lttng_event_field_value_array, parent)->elems,
-                       NULL);
+               &lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
+                        ->elems,
+               nullptr);
 }
 
-enum lttng_event_field_value_type lttng_event_field_value_get_type(
-               const struct lttng_event_field_value *field_val)
+enum lttng_event_field_value_type
+lttng_event_field_value_get_type(const struct lttng_event_field_value *field_val)
 {
        enum lttng_event_field_value_type type;
 
@@ -356,8 +340,8 @@ end:
 }
 
 enum lttng_event_field_value_status
-lttng_event_field_value_unsigned_int_get_value(
-               const struct lttng_event_field_value *field_val, uint64_t *val)
+lttng_event_field_value_unsigned_int_get_value(const struct lttng_event_field_value *field_val,
+                                              uint64_t *val)
 {
        enum lttng_event_field_value_status status;
 
@@ -368,21 +352,17 @@ lttng_event_field_value_unsigned_int_get_value(
 
        switch (field_val->type) {
        case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT:
-               *val = container_of(field_val,
-                               const struct lttng_event_field_value_uint,
-                               parent)->val;
+               *val = lttng::utils::container_of(field_val, &lttng_event_field_value_uint::parent)
+                              ->val;
                break;
        case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
        {
-               const struct lttng_event_field_value_enum *field_val_enum = container_of(
-                               field_val,
-                               const struct lttng_event_field_value_enum,
-                               parent);
-               const struct lttng_event_field_value_enum_uint
-                               *field_val_enum_uint = container_of(
-                                               field_val_enum,
-                                               const struct lttng_event_field_value_enum_uint,
-                                               parent);
+               const struct lttng_event_field_value_enum *field_val_enum =
+                       lttng::utils::container_of(field_val,
+                                                  &lttng_event_field_value_enum::parent);
+               const struct lttng_event_field_value_enum_uint *field_val_enum_uint =
+                       lttng::utils::container_of(field_val_enum,
+                                                  &lttng_event_field_value_enum_uint::parent);
                *val = field_val_enum_uint->val;
                break;
        }
@@ -398,8 +378,8 @@ end:
 }
 
 enum lttng_event_field_value_status
-lttng_event_field_value_signed_int_get_value(
-               const struct lttng_event_field_value *field_val, int64_t *val)
+lttng_event_field_value_signed_int_get_value(const struct lttng_event_field_value *field_val,
+                                            int64_t *val)
 {
        enum lttng_event_field_value_status status;
 
@@ -410,21 +390,17 @@ lttng_event_field_value_signed_int_get_value(
 
        switch (field_val->type) {
        case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT:
-               *val = container_of(field_val,
-                               const struct lttng_event_field_value_int,
-                               parent)->val;
+               *val = lttng::utils::container_of(field_val, &lttng_event_field_value_int::parent)
+                              ->val;
                break;
        case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
        {
-               const struct lttng_event_field_value_enum *field_val_enum = container_of(
-                               field_val,
-                               const struct lttng_event_field_value_enum,
-                               parent);
-               const struct lttng_event_field_value_enum_int
-                               *field_val_enum_uint = container_of(
-                                               field_val_enum,
-                                               const struct lttng_event_field_value_enum_int,
-                                               parent);
+               const struct lttng_event_field_value_enum *field_val_enum =
+                       lttng::utils::container_of(field_val,
+                                                  &lttng_event_field_value_enum::parent);
+               const struct lttng_event_field_value_enum_int *field_val_enum_uint =
+                       lttng::utils::container_of(field_val_enum,
+                                                  &lttng_event_field_value_enum_int::parent);
                *val = field_val_enum_uint->val;
                break;
        }
@@ -440,36 +416,31 @@ end:
 }
 
 enum lttng_event_field_value_status
-lttng_event_field_value_real_get_value(
-               const struct lttng_event_field_value *field_val, double *val)
+lttng_event_field_value_real_get_value(const struct lttng_event_field_value *field_val, double *val)
 {
        enum lttng_event_field_value_status status;
 
-       if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_REAL ||
-                       !val) {
+       if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_REAL || !val) {
                status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
                goto end;
        }
 
-       *val = container_of(field_val,
-                       const struct lttng_event_field_value_real, parent)->val;
+       *val = lttng::utils::container_of(field_val, &lttng_event_field_value_real::parent)->val;
        status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
 
 end:
        return status;
 }
 
-static
-bool is_enum_field_val(const struct lttng_event_field_value *field_val)
+static bool is_enum_field_val(const struct lttng_event_field_value *field_val)
 {
        return field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM ||
                field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM;
 }
 
 enum lttng_event_field_value_status
-lttng_event_field_value_enum_get_label_count(
-               const struct lttng_event_field_value *field_val,
-               unsigned int *count)
+lttng_event_field_value_enum_get_label_count(const struct lttng_event_field_value *field_val,
+                                            unsigned int *count)
 {
        enum lttng_event_field_value_status status;
 
@@ -479,45 +450,44 @@ lttng_event_field_value_enum_get_label_count(
        }
 
        *count = (unsigned int) lttng_dynamic_pointer_array_get_count(
-                       &container_of(field_val,
-                               const struct lttng_event_field_value_enum,
-                               parent)->labels);
+               &lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
+                        ->labels);
        status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
 
 end:
        return status;
 }
 
-const char *lttng_event_field_value_enum_get_label_at_index(
-               const struct lttng_event_field_value *field_val,
-               unsigned int index)
+const char *
+lttng_event_field_value_enum_get_label_at_index(const struct lttng_event_field_value *field_val,
+                                               unsigned int index)
 {
        const char *ret;
        const struct lttng_event_field_value_enum *enum_field_val;
 
        if (!field_val || !is_enum_field_val(field_val)) {
-               ret = NULL;
+               ret = nullptr;
                goto end;
        }
 
-       enum_field_val = container_of(field_val,
-                       const struct lttng_event_field_value_enum, parent);
+       enum_field_val =
+               lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent);
 
        if (index >= lttng_dynamic_pointer_array_get_count(&enum_field_val->labels)) {
-               ret = NULL;
+               ret = nullptr;
                goto end;
        }
 
        ret = (const char *) lttng_dynamic_pointer_array_get_pointer(&enum_field_val->labels,
-                       index);
+                                                                    index);
 
 end:
        return ret;
 }
 
-enum lttng_event_field_value_status lttng_event_field_value_string_get_value(
-               const struct lttng_event_field_value *field_val,
-               const char **value)
+enum lttng_event_field_value_status
+lttng_event_field_value_string_get_value(const struct lttng_event_field_value *field_val,
+                                        const char **value)
 {
        enum lttng_event_field_value_status status;
 
@@ -526,53 +496,50 @@ enum lttng_event_field_value_status lttng_event_field_value_string_get_value(
                goto end;
        }
 
-       *value = container_of(field_val,
-                       const struct lttng_event_field_value_string, parent)->val;
+       *value =
+               lttng::utils::container_of(field_val, &lttng_event_field_value_string::parent)->val;
        status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
 
 end:
        return status;
 }
 
-enum lttng_event_field_value_status lttng_event_field_value_array_get_length(
-               const struct lttng_event_field_value *field_val,
-               unsigned int *length)
+enum lttng_event_field_value_status
+lttng_event_field_value_array_get_length(const struct lttng_event_field_value *field_val,
+                                        unsigned int *length)
 {
        enum lttng_event_field_value_status status;
 
-       if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY ||
-                       !length) {
+       if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY || !length) {
                status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
                goto end;
        }
 
        *length = (unsigned int) lttng_dynamic_pointer_array_get_count(
-                       &container_of(field_val,
-                               const struct lttng_event_field_value_array,
-                               parent)->elems);
+               &lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent)
+                        ->elems);
        status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
 
 end:
        return status;
 }
 
-enum lttng_event_field_value_status
-lttng_event_field_value_array_get_element_at_index(
-               const struct lttng_event_field_value *field_val,
-               unsigned int index,
-               const struct lttng_event_field_value **elem_field_val)
+enum lttng_event_field_value_status lttng_event_field_value_array_get_element_at_index(
+       const struct lttng_event_field_value *field_val,
+       unsigned int index,
+       const struct lttng_event_field_value **elem_field_val)
 {
        enum lttng_event_field_value_status status;
        const struct lttng_event_field_value_array *array_field_val;
 
        if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY ||
-                       !elem_field_val) {
+           !elem_field_val) {
                status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
                goto end;
        }
 
-       array_field_val = container_of(field_val,
-                       const struct lttng_event_field_value_array, parent);
+       array_field_val =
+               lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent);
 
        if (index >= lttng_dynamic_pointer_array_get_count(&array_field_val->elems)) {
                status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
@@ -580,7 +547,7 @@ lttng_event_field_value_array_get_element_at_index(
        }
 
        *elem_field_val = (lttng_event_field_value *) lttng_dynamic_pointer_array_get_pointer(
-                       &array_field_val->elems, index);
+               &array_field_val->elems, index);
        if (*elem_field_val) {
                status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
        } else {
LTTng 2.0 tools and control repository
This page took 0.030483 seconds and 4 git commands to generate.