tracepoint: Refactor representation of nested types

[lttng-ust.git] / liblttng-ust / lttng-filter-specialize.c

diff --git a/liblttng-ust/lttng-filter-specialize.c b/liblttng-ust/lttng-filter-specialize.c
index 39730f8cd954a0428ff419fe1d9114a70caf7a33..ef45904fff9a84b080e4198e5c143cb112a34a41 100644 (file)
--- a/liblttng-ust/lttng-filter-specialize.c
+++ b/liblttng-ust/lttng-filter-specialize.c
@@ -259,14 +259,31 @@ static int specialize_get_index(struct bytecode_runtime *runtime,
                switch (stack_top->load.object_type) {
                case OBJECT_TYPE_ARRAY:
                {
+                       const struct lttng_integer_type *integer_type;
                        const struct lttng_event_field *field;
                        uint32_t elem_len, num_elems;
                        int signedness;
 
                        field = stack_top->load.field;
-                       elem_len = field->type.u.array.elem_type.u.basic.integer.size;
-                       signedness = field->type.u.array.elem_type.u.basic.integer.signedness;
-                       num_elems = field->type.u.array.length;
+                       switch (field->type.atype) {
+                       case atype_array:
+                               integer_type = &field->type.u.legacy.array.elem_type.u.basic.integer;
+                               num_elems = field->type.u.legacy.array.length;
+                               break;
+                       case atype_array_nestable:
+                               if (field->type.u.array_nestable.elem_type->atype != atype_integer) {
+                                       ret = -EINVAL;
+                                       goto end;
+                               }
+                               integer_type = &field->type.u.array_nestable.elem_type->u.integer;
+                               num_elems = field->type.u.array_nestable.length;
+                               break;
+                       default:
+                               ret = -EINVAL;
+                               goto end;
+                       }
+                       elem_len = integer_type->size;
+                       signedness = integer_type->signedness;
                        if (index >= num_elems) {
                                ret = -EINVAL;
                                goto end;
@@ -279,20 +296,36 @@ static int specialize_get_index(struct bytecode_runtime *runtime,
                        gid.array_len = num_elems * (elem_len / CHAR_BIT);
                        gid.elem.type = stack_top->load.object_type;
                        gid.elem.len = elem_len;
-                       if (field->type.u.array.elem_type.u.basic.integer.reverse_byte_order)
+                       if (integer_type->reverse_byte_order)
                                gid.elem.rev_bo = true;
                        stack_top->load.rev_bo = gid.elem.rev_bo;
                        break;
                }
                case OBJECT_TYPE_SEQUENCE:
                {
+                       const struct lttng_integer_type *integer_type;
                        const struct lttng_event_field *field;
                        uint32_t elem_len;
                        int signedness;
 
                        field = stack_top->load.field;
-                       elem_len = field->type.u.sequence.elem_type.u.basic.integer.size;
-                       signedness = field->type.u.sequence.elem_type.u.basic.integer.signedness;
+                       switch (field->type.atype) {
+                       case atype_sequence:
+                               integer_type = &field->type.u.legacy.sequence.elem_type.u.basic.integer;
+                               break;
+                       case atype_sequence_nestable:
+                               if (field->type.u.sequence_nestable.elem_type->atype != atype_integer) {
+                                       ret = -EINVAL;
+                                       goto end;
+                               }
+                               integer_type = &field->type.u.sequence_nestable.elem_type->u.integer;
+                               break;
+                       default:
+                               ret = -EINVAL;
+                               goto end;
+                       }
+                       elem_len = integer_type->size;
+                       signedness = integer_type->signedness;
                        ret = specialize_get_index_object_type(&stack_top->load.object_type,
                                        signedness, elem_len);
                        if (ret)
@@ -300,7 +333,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime,
                        gid.offset = index * (elem_len / CHAR_BIT);
                        gid.elem.type = stack_top->load.object_type;
                        gid.elem.len = elem_len;
-                       if (field->type.u.sequence.elem_type.u.basic.integer.reverse_byte_order)
+                       if (integer_type->reverse_byte_order)
                                gid.elem.rev_bo = true;
                        stack_top->load.rev_bo = gid.elem.rev_bo;
                        break;
@@ -367,17 +400,22 @@ static int specialize_load_object(const struct lttng_event_field *field,
         */
        switch (field->type.atype) {
        case atype_integer:
-               if (field->type.u.basic.integer.signedness)
+               if (field->type.u.integer.signedness)
                        load->object_type = OBJECT_TYPE_S64;
                else
                        load->object_type = OBJECT_TYPE_U64;
                load->rev_bo = false;
                break;
        case atype_enum:
+       case atype_enum_nestable:
        {
-               const struct lttng_integer_type *itype =
-                       &field->type.u.basic.enumeration.container_type;
+               const struct lttng_integer_type *itype;
 
+               if (field->type.atype == atype_enum) {
+                       itype = &field->type.u.legacy.basic.enumeration.container_type;
+               } else {
+                       itype = &field->type.u.enum_nestable.container_type->u.integer;
+               }
                if (itype->signedness)
                        load->object_type = OBJECT_TYPE_S64;
                else
@@ -386,14 +424,30 @@ static int specialize_load_object(const struct lttng_event_field *field,
                break;
        }
        case atype_array:
-               if (field->type.u.array.elem_type.atype != atype_integer) {
+               if (field->type.u.legacy.array.elem_type.atype != atype_integer) {
+                       ERR("Array nesting only supports integer types.");
+                       return -EINVAL;
+               }
+               if (is_context) {
+                       load->object_type = OBJECT_TYPE_STRING;
+               } else {
+                       if (field->type.u.legacy.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+                               load->object_type = OBJECT_TYPE_ARRAY;
+                               load->field = field;
+                       } else {
+                               load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
+                       }
+               }
+               break;
+       case atype_array_nestable:
+               if (field->type.u.array_nestable.elem_type->atype != atype_integer) {
                        ERR("Array nesting only supports integer types.");
                        return -EINVAL;
                }
                if (is_context) {
                        load->object_type = OBJECT_TYPE_STRING;
                } else {
-                       if (field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+                       if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
                                load->object_type = OBJECT_TYPE_ARRAY;
                                load->field = field;
                        } else {
@@ -402,14 +456,30 @@ static int specialize_load_object(const struct lttng_event_field *field,
                }
                break;
        case atype_sequence:
-               if (field->type.u.sequence.elem_type.atype != atype_integer) {
+               if (field->type.u.legacy.sequence.elem_type.atype != atype_integer) {
+                       ERR("Sequence nesting only supports integer types.");
+                       return -EINVAL;
+               }
+               if (is_context) {
+                       load->object_type = OBJECT_TYPE_STRING;
+               } else {
+                       if (field->type.u.legacy.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+                               load->object_type = OBJECT_TYPE_SEQUENCE;
+                               load->field = field;
+                       } else {
+                               load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
+                       }
+               }
+               break;
+       case atype_sequence_nestable:
+               if (field->type.u.sequence_nestable.elem_type->atype != atype_integer) {
                        ERR("Sequence nesting only supports integer types.");
                        return -EINVAL;
                }
                if (is_context) {
                        load->object_type = OBJECT_TYPE_STRING;
                } else {
-                       if (field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+                       if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
                                load->object_type = OBJECT_TYPE_SEQUENCE;
                                load->field = field;
                        } else {
@@ -417,6 +487,7 @@ static int specialize_load_object(const struct lttng_event_field *field,
                        }
                }
                break;
+
        case atype_string:
                load->object_type = OBJECT_TYPE_STRING;
                break;
@@ -549,6 +620,9 @@ static int specialize_event_payload_lookup(struct lttng_event *event,
        name = runtime->p.bc->bc.data + runtime->p.bc->bc.reloc_offset + offset;
        for (i = 0; i < nr_fields; i++) {
                field = &desc->fields[i];
+               if (field->u.ext.nofilter) {
+                       continue;
+               }
                if (!strcmp(field->name, name)) {
                        found = true;
                        break;
@@ -557,10 +631,13 @@ static int specialize_event_payload_lookup(struct lttng_event *event,
                switch (field->type.atype) {
                case atype_integer:
                case atype_enum:
+               case atype_enum_nestable:
                        field_offset += sizeof(int64_t);
                        break;
                case atype_array:
+               case atype_array_nestable:
                case atype_sequence:
+               case atype_sequence_nestable:
                        field_offset += sizeof(unsigned long);
                        field_offset += sizeof(void *);
                        break;