Cleanup: namespace string encoding

[lttng-modules.git] / src / lttng-bytecode.c

diff --git a/src/lttng-bytecode.c b/src/lttng-bytecode.c
index 86ffe94985147aec879dc9e9151d95ade9af83b7..3e9b3e53745e07fadd5fdfa8845d0523f74091d1 100644 (file)
--- a/src/lttng-bytecode.c
+++ b/src/lttng-bytecode.c
@@ -196,28 +196,28 @@ int apply_field_reloc(const struct lttng_event_desc *event_desc,
                        break;
                }
                /* compute field offset */
-               switch (fields[i].type.atype) {
-               case atype_integer:
-               case atype_enum_nestable:
+               switch (fields[i].type.type) {
+               case lttng_kernel_type_integer:
+               case lttng_kernel_type_enum_nestable:
                        field_offset += sizeof(int64_t);
                        break;
-               case atype_array_nestable:
+               case lttng_kernel_type_array_nestable:
                        if (!lttng_is_bytewise_integer(fields[i].type.u.array_nestable.elem_type))
                                return -EINVAL;
                        field_offset += sizeof(unsigned long);
                        field_offset += sizeof(void *);
                        break;
-               case atype_sequence_nestable:
+               case lttng_kernel_type_sequence_nestable:
                        if (!lttng_is_bytewise_integer(fields[i].type.u.sequence_nestable.elem_type))
                                return -EINVAL;
                        field_offset += sizeof(unsigned long);
                        field_offset += sizeof(void *);
                        break;
-               case atype_string:
+               case lttng_kernel_type_string:
                        field_offset += sizeof(void *);
                        break;
-               case atype_struct_nestable:     /* Unsupported. */
-               case atype_variant_nestable:    /* Unsupported. */
+               case lttng_kernel_type_struct_nestable: /* Unsupported. */
+               case lttng_kernel_type_variant_nestable:        /* Unsupported. */
                default:
                        return -EINVAL;
                }
@@ -238,26 +238,43 @@ int apply_field_reloc(const struct lttng_event_desc *event_desc,
                struct field_ref *field_ref;
 
                field_ref = (struct field_ref *) op->data;
-               switch (field->type.atype) {
-               case atype_integer:
-               case atype_enum_nestable:
+               switch (field->type.type) {
+               case lttng_kernel_type_integer:
+               case lttng_kernel_type_enum_nestable:
                        op->op = BYTECODE_OP_LOAD_FIELD_REF_S64;
                        break;
-               case atype_array_nestable:
-               case atype_sequence_nestable:
+               case lttng_kernel_type_array_nestable:
+               {
+                       const struct lttng_type *elem_type = field->type.u.array_nestable.elem_type;
+
+                       if (!lttng_is_bytewise_integer(elem_type) || elem_type->u.integer.encoding == lttng_kernel_string_encoding_none)
+                               return -EINVAL;
                        if (field->user)
                                op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE;
                        else
                                op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
                        break;
-               case atype_string:
+               }
+               case lttng_kernel_type_sequence_nestable:
+               {
+                       const struct lttng_type *elem_type = field->type.u.sequence_nestable.elem_type;
+
+                       if (!lttng_is_bytewise_integer(elem_type) || elem_type->u.integer.encoding == lttng_kernel_string_encoding_none)
+                               return -EINVAL;
+                       if (field->user)
+                               op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE;
+                       else
+                               op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
+                       break;
+               }
+               case lttng_kernel_type_string:
                        if (field->user)
                                op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_STRING;
                        else
                                op->op = BYTECODE_OP_LOAD_FIELD_REF_STRING;
                        break;
-               case atype_struct_nestable:     /* Unsupported. */
-               case atype_variant_nestable:    /* Unsupported. */
+               case lttng_kernel_type_struct_nestable: /* Unsupported. */
+               case lttng_kernel_type_variant_nestable:        /* Unsupported. */
                default:
                        return -EINVAL;
                }
@@ -303,30 +320,38 @@ int apply_context_reloc(struct bytecode_runtime *runtime,
                struct field_ref *field_ref;
 
                field_ref = (struct field_ref *) op->data;
-               switch (ctx_field->event_field.type.atype) {
-               case atype_integer:
-               case atype_enum_nestable:
+               switch (ctx_field->event_field.type.type) {
+               case lttng_kernel_type_integer:
+               case lttng_kernel_type_enum_nestable:
                        op->op = BYTECODE_OP_GET_CONTEXT_REF_S64;
                        break;
                        /* Sequence and array supported as string */
-               case atype_string:
+               case lttng_kernel_type_string:
                        BUG_ON(ctx_field->event_field.user);
                        op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
                        break;
-               case atype_array_nestable:
-                       if (!lttng_is_bytewise_integer(ctx_field->event_field.type.u.array_nestable.elem_type))
+               case lttng_kernel_type_array_nestable:
+               {
+                       const struct lttng_type *elem_type = ctx_field->event_field.type.u.array_nestable.elem_type;
+
+                       if (!lttng_is_bytewise_integer(elem_type) || elem_type->u.integer.encoding == lttng_kernel_string_encoding_none)
                                return -EINVAL;
                        BUG_ON(ctx_field->event_field.user);
                        op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
                        break;
-               case atype_sequence_nestable:
-                       if (!lttng_is_bytewise_integer(ctx_field->event_field.type.u.sequence_nestable.elem_type))
+               }
+               case lttng_kernel_type_sequence_nestable:
+               {
+                       const struct lttng_type *elem_type = ctx_field->event_field.type.u.sequence_nestable.elem_type;
+
+                       if (!lttng_is_bytewise_integer(elem_type) || elem_type->u.integer.encoding == lttng_kernel_string_encoding_none)
                                return -EINVAL;
                        BUG_ON(ctx_field->event_field.user);
                        op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
                        break;
-               case atype_struct_nestable:     /* Unsupported. */
-               case atype_variant_nestable:    /* Unsupported. */
+               }
+               case lttng_kernel_type_struct_nestable: /* Unsupported. */
+               case lttng_kernel_type_variant_nestable:        /* Unsupported. */
                default:
                        return -EINVAL;
                }
@@ -398,6 +423,7 @@ static
 int link_bytecode(const struct lttng_event_desc *event_desc,
                struct lttng_ctx *ctx,
                struct lttng_bytecode_node *bytecode,
+               struct list_head *bytecode_runtime_head,
                struct list_head *insert_loc)
 {
        int ret, offset, next_offset;
@@ -407,7 +433,7 @@ int link_bytecode(const struct lttng_event_desc *event_desc,
        if (!bytecode)
                return 0;
        /* Bytecode already linked */
-       if (bytecode_is_linked(bytecode, insert_loc))
+       if (bytecode_is_linked(bytecode, bytecode_runtime_head))
                return 0;
 
        dbg_printk("Linking...\n");
@@ -566,7 +592,7 @@ void lttng_enabler_link_bytecode(const struct lttng_event_desc *event_desc,
                insert_loc = instance_bytecode_head;
        add_within:
                dbg_printk("linking bytecode\n");
-               ret = link_bytecode(event_desc, ctx, enabler_bc, insert_loc);
+               ret = link_bytecode(event_desc, ctx, enabler_bc, instance_bytecode_head, insert_loc);
                if (ret) {
                        dbg_printk("[lttng filter] warning: cannot link event bytecode\n");
                }