Fix: memory and fd leaks in error counter

[lttng-ust.git] / liblttng-ust / lttng-context.c

diff --git a/liblttng-ust/lttng-context.c b/liblttng-ust/lttng-context.c
index bb6a9c9dc9b6cf1df9240f35f5e615901239f7d1..fde3607dc512172ff1f7406d36fbfd4aef2cf1ed 100644 (file)
--- a/liblttng-ust/lttng-context.c
+++ b/liblttng-ust/lttng-context.c
@@ -24,12 +24,15 @@
 #include <lttng/ust-events.h>
 #include <lttng/ust-tracer.h>
 #include <lttng/ust-context-provider.h>
-#include <urcu-pointer.h>
+#include <lttng/urcu/pointer.h>
 #include <usterr-signal-safe.h>
 #include <helper.h>
 #include <stddef.h>
 #include <string.h>
 #include <assert.h>
+#include "tracepoint-internal.h"
+
+#include "context-internal.h"
 
 /*
  * The filter implementation requires that two consecutive "get" for the
@@ -155,8 +158,8 @@ int lttng_context_add_rcu(struct lttng_ctx **ctx_p,
        }
        *nf = *f;
        lttng_context_update(new_ctx);
-       rcu_assign_pointer(*ctx_p, new_ctx);
-       synchronize_trace();
+       lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
+       lttng_ust_synchronize_trace();
        if (old_ctx) {
                free(old_ctx->fields);
                free(old_ctx);
@@ -180,13 +183,13 @@ void lttng_context_update(struct lttng_ctx *ctx)
                type = &ctx->fields[i].event_field.type;
                switch (type->atype) {
                case atype_integer:
-                       field_align = type->u.basic.integer.alignment;
+                       field_align = type->u.integer.alignment;
                        break;
                case atype_array:
                {
                        struct lttng_basic_type *btype;
 
-                       btype = &type->u.array.elem_type;
+                       btype = &type->u.legacy.array.elem_type;
                        switch (btype->atype) {
                        case atype_integer:
                                field_align = btype->u.basic.integer.alignment;
@@ -195,18 +198,44 @@ void lttng_context_update(struct lttng_ctx *ctx)
                                break;
 
                        case atype_array:
+                       case atype_array_nestable:
                        case atype_sequence:
+                       case atype_sequence_nestable:
                        default:
                                WARN_ON_ONCE(1);
                                break;
                        }
                        break;
                }
+               case atype_array_nestable:
+               {
+                       const struct lttng_type *nested_type;
+
+                       nested_type = type->u.array_nestable.elem_type;
+                       switch (nested_type->atype) {
+                       case atype_integer:
+                               field_align = nested_type->u.integer.alignment;
+                               break;
+                       case atype_string:
+                               break;
+
+                       case atype_array:
+                       case atype_array_nestable:
+                       case atype_sequence:
+                       case atype_sequence_nestable:
+                       default:
+                               WARN_ON_ONCE(1);
+                               break;
+                       }
+                       field_align = max_t(size_t, field_align,
+                                       type->u.array_nestable.alignment);
+                       break;
+               }
                case atype_sequence:
                {
                        struct lttng_basic_type *btype;
 
-                       btype = &type->u.sequence.length_type;
+                       btype = &type->u.legacy.sequence.length_type;
                        switch (btype->atype) {
                        case atype_integer:
                                field_align = btype->u.basic.integer.alignment;
@@ -214,13 +243,15 @@ void lttng_context_update(struct lttng_ctx *ctx)
 
                        case atype_string:
                        case atype_array:
+                       case atype_array_nestable:
                        case atype_sequence:
+                       case atype_sequence_nestable:
                        default:
                                WARN_ON_ONCE(1);
                                break;
                        }
 
-                       btype = &type->u.sequence.elem_type;
+                       btype = &type->u.legacy.sequence.elem_type;
                        switch (btype->atype) {
                        case atype_integer:
                                field_align = max_t(size_t,
@@ -232,18 +263,46 @@ void lttng_context_update(struct lttng_ctx *ctx)
                                break;
 
                        case atype_array:
+                       case atype_array_nestable:
                        case atype_sequence:
+                       case atype_sequence_nestable:
                        default:
                                WARN_ON_ONCE(1);
                                break;
                        }
                        break;
                }
+               case atype_sequence_nestable:
+               {
+                       const struct lttng_type *nested_type;
+
+                       nested_type = type->u.sequence_nestable.elem_type;
+                       switch (nested_type->atype) {
+                       case atype_integer:
+                               field_align = nested_type->u.integer.alignment;
+                               break;
+
+                       case atype_string:
+                               break;
+
+                       case atype_array:
+                       case atype_array_nestable:
+                       case atype_sequence:
+                       case atype_sequence_nestable:
+                       default:
+                               WARN_ON_ONCE(1);
+                               break;
+                       }
+                       field_align = max_t(size_t, field_align,
+                                       type->u.sequence_nestable.alignment);
+                       break;
+               }
                case atype_string:
                        break;
                case atype_dynamic:
                        break;
                case atype_enum:
+               case atype_enum_nestable:
                default:
                        WARN_ON_ONCE(1);
                        break;
@@ -333,8 +392,8 @@ int lttng_ust_context_set_provider_rcu(struct lttng_ctx **_ctx,
                new_fields[i].get_value = get_value;
        }
        new_ctx->fields = new_fields;
-       rcu_assign_pointer(*_ctx, new_ctx);
-       synchronize_trace();
+       lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
+       lttng_ust_synchronize_trace();
        free(ctx->fields);
        free(ctx);
        return 0;
@@ -344,7 +403,7 @@ field_error:
        return ret;
 }
 
-int lttng_session_context_init(struct lttng_ctx **ctx)
+int lttng_context_init_all(struct lttng_ctx **ctx)
 {
        int ret;
 
@@ -398,6 +457,11 @@ int lttng_session_context_init(struct lttng_ctx **ctx)
                WARN("Cannot add context lttng_add_pid_ns_to_ctx");
                goto error;
        }
+       ret = lttng_add_time_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_time_ns_to_ctx");
+               goto error;
+       }
        ret = lttng_add_user_ns_to_ctx(ctx);
        if (ret) {
                WARN("Cannot add context lttng_add_user_ns_to_ctx");
@@ -456,3 +520,8 @@ void lttng_context_init(void)
 void lttng_context_exit(void)
 {
 }
+
+int lttng_session_context_init(struct lttng_ctx **ctx)
+{
+       return 0;
+}