bytecode: initialize all contexts on event notifier group creation

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

diff --git a/liblttng-ust/lttng-context.c b/liblttng-ust/lttng-context.c
index 33a4cdd1d41477e54fad06fc13c22d1b4e543b2f..c457d3e1c71943f45c02c660dc5e8af6aca30f32 100644 (file)
--- a/liblttng-ust/lttng-context.c
+++ b/liblttng-ust/lttng-context.c
@@ -20,16 +20,19 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-
+#define _LGPL_SOURCE
 #include <lttng/ust-events.h>
 #include <lttng/ust-tracer.h>
 #include <lttng/ust-context-provider.h>
 #include <urcu-pointer.h>
 #include <usterr-signal-safe.h>
 #include <helper.h>
+#include <stddef.h>
 #include <string.h>
 #include <assert.h>
 
+#include "context-internal.h"
+
 /*
  * The filter implementation requires that two consecutive "get" for the
  * same context performed by the same thread return the same result.
@@ -179,13 +182,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;
@@ -194,18 +197,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;
@@ -213,13 +242,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,
@@ -231,18 +262,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;
@@ -343,7 +402,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;
 
@@ -372,6 +431,76 @@ int lttng_session_context_init(struct lttng_ctx **ctx)
                WARN("Cannot add context lttng_add_cpu_id_to_ctx");
                goto error;
        }
+       ret = lttng_add_cgroup_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_cgroup_ns_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_ipc_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_ipc_ns_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_mnt_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_mnt_ns_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_net_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_net_ns_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_pid_ns_to_ctx(ctx);
+       if (ret) {
+               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");
+               goto error;
+       }
+       ret = lttng_add_uts_ns_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_uts_ns_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_vuid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_vuid_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_veuid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_veuid_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_vsuid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_vsuid_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_vgid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_vgid_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_vegid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_vegid_to_ctx");
+               goto error;
+       }
+       ret = lttng_add_vsgid_to_ctx(ctx);
+       if (ret) {
+               WARN("Cannot add context lttng_add_vsgid_to_ctx");
+               goto error;
+       }
        lttng_context_update(*ctx);
        return 0;
 
@@ -390,3 +519,8 @@ void lttng_context_init(void)
 void lttng_context_exit(void)
 {
 }
+
+int lttng_session_context_init(struct lttng_ctx **ctx)
+{
+       return 0;
+}