Fix: bytecode: Validate register type for instructions expecting unknown type

[lttng-modules.git] / src / lttng-filter-interpreter.c

diff --git a/src/lttng-filter-interpreter.c b/src/lttng-filter-interpreter.c
index 6c1c2f279e021391589cf28e1ae41976bc21cb80..4aefb04ed50a43ed10b895091c5001c7cb59e4b5 100644 (file)
--- a/src/lttng-filter-interpreter.c
+++ b/src/lttng-filter-interpreter.c
@@ -8,7 +8,7 @@
  */
 
 #include <wrapper/uaccess.h>
-#include <wrapper/frame.h>
+#include <wrapper/objtool.h>
 #include <wrapper/types.h>
 #include <linux/swab.h>
 
@@ -81,16 +81,14 @@ static
 int stack_star_glob_match(struct estack *stack, int top, const char *cmp_type)
 {
        bool has_user = false;
-       mm_segment_t old_fs;
        int result;
        struct estack_entry *pattern_reg;
        struct estack_entry *candidate_reg;
 
+       /* Disable the page fault handler when reading from userspace. */
        if (estack_bx(stack, top)->u.s.user
                        || estack_ax(stack, top)->u.s.user) {
                has_user = true;
-               old_fs = get_fs();
-               set_fs(KERNEL_DS);
                pagefault_disable();
        }
 
@@ -106,10 +104,8 @@ int stack_star_glob_match(struct estack *stack, int top, const char *cmp_type)
        /* Perform the match operation. */
        result = !strutils_star_glob_match_char_cb(get_char_at_cb,
                pattern_reg, get_char_at_cb, candidate_reg);
-       if (has_user) {
+       if (has_user)
                pagefault_enable();
-               set_fs(old_fs);
-       }
 
        return result;
 }
@@ -119,13 +115,10 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type)
 {
        size_t offset_bx = 0, offset_ax = 0;
        int diff, has_user = 0;
-       mm_segment_t old_fs;
 
        if (estack_bx(stack, top)->u.s.user
                        || estack_ax(stack, top)->u.s.user) {
                has_user = 1;
-               old_fs = get_fs();
-               set_fs(KERNEL_DS);
                pagefault_disable();
        }
 
@@ -210,10 +203,9 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type)
                offset_bx++;
                offset_ax++;
        }
-       if (has_user) {
+       if (has_user)
                pagefault_enable();
-               set_fs(old_fs);
-       }
+
        return diff;
 }
 
@@ -234,7 +226,7 @@ uint64_t lttng_filter_false(void *filter_data,
        start_pc = &bytecode->data[0];                                  \
        for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;    \
                        pc = next_pc) {                                 \
-               dbg_printk("Executing op %s (%u)\n",                    \
+               dbg_printk("LTTng: Executing op %s (%u)\n",             \
                        lttng_filter_print_op((unsigned int) *(filter_opcode_t *) pc), \
                        (unsigned int) *(filter_opcode_t *) pc);        \
                switch (*(filter_opcode_t *) pc)        {
@@ -270,6 +262,8 @@ LABEL_##name
 
 #endif
 
+#define IS_INTEGER_REGISTER(reg_type) (reg_type == REG_S64)
+
 static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
                struct load_ptr *ptr,
                uint32_t idx)
@@ -317,11 +311,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
        }
        case atype_array_nestable:
                if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) {
-                       printk(KERN_WARNING "Array nesting only supports integer types.\n");
+                       printk(KERN_WARNING "LTTng: filter: Array nesting only supports integer types.\n");
                        return -EINVAL;
                }
                if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
-                       printk(KERN_WARNING "Only string arrays are supported for contexts.\n");
+                       printk(KERN_WARNING "LTTng: filter: Only string arrays are supported for contexts.\n");
                        return -EINVAL;
                }
                ptr->object_type = OBJECT_TYPE_STRING;
@@ -330,11 +324,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
                break;
        case atype_sequence_nestable:
                if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) {
-                       printk(KERN_WARNING "Sequence nesting only supports integer types.\n");
+                       printk(KERN_WARNING "LTTng: filter: Sequence nesting only supports integer types.\n");
                        return -EINVAL;
                }
                if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
-                       printk(KERN_WARNING "Only string sequences are supported for contexts.\n");
+                       printk(KERN_WARNING "LTTng: filter: Only string sequences are supported for contexts.\n");
                        return -EINVAL;
                }
                ptr->object_type = OBJECT_TYPE_STRING;
@@ -347,13 +341,13 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
                ptr->ptr = v.str;
                break;
        case atype_struct_nestable:
-               printk(KERN_WARNING "Structure type cannot be loaded.\n");
+               printk(KERN_WARNING "LTTng: filter: Structure type cannot be loaded.\n");
                return -EINVAL;
        case atype_variant_nestable:
-               printk(KERN_WARNING "Variant type cannot be loaded.\n");
+               printk(KERN_WARNING "LTTng: filter: Variant type cannot be loaded.\n");
                return -EINVAL;
        default:
-               printk(KERN_WARNING "Unknown type: %d", (int) field->type.atype);
+               printk(KERN_WARNING "LTTng: filter: Unknown type: %d", (int) field->type.atype);
                return -EINVAL;
        }
        return 0;
@@ -412,12 +406,12 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
                        break;
                }
                case OBJECT_TYPE_STRUCT:
-                       printk(KERN_WARNING "Nested structures are not supported yet.\n");
+                       printk(KERN_WARNING "LTTng: filter: Nested structures are not supported yet.\n");
                        ret = -EINVAL;
                        goto end;
                case OBJECT_TYPE_VARIANT:
                default:
-                       printk(KERN_WARNING "Unexpected get index type %d",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected get index type %d",
                                (int) stack_top->u.ptr.object_type);
                        ret = -EINVAL;
                        goto end;
@@ -469,6 +463,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
        case OBJECT_TYPE_S8:
                dbg_printk("op load field s8\n");
                stack_top->u.v = *(int8_t *) stack_top->u.ptr.ptr;
+               stack_top->type = REG_S64;
                break;
        case OBJECT_TYPE_S16:
        {
@@ -479,6 +474,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab16s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_S32:
@@ -490,6 +486,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab32s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_S64:
@@ -501,11 +498,13 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab64s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_U8:
                dbg_printk("op load field u8\n");
                stack_top->u.v = *(uint8_t *) stack_top->u.ptr.ptr;
+               stack_top->type = REG_S64;
                break;
        case OBJECT_TYPE_U16:
        {
@@ -516,6 +515,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab16s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_U32:
@@ -527,6 +527,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab32s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_U64:
@@ -538,6 +539,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                if (stack_top->u.ptr.rev_bo)
                        __swab64s(&tmp);
                stack_top->u.v = tmp;
+               stack_top->type = REG_S64;
                break;
        }
        case OBJECT_TYPE_STRING:
@@ -555,6 +557,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                stack_top->u.s.seq_len = LTTNG_SIZE_MAX;
                stack_top->u.s.literal_type =
                        ESTACK_STRING_LITERAL_TYPE_NONE;
+               stack_top->type = REG_STRING;
                break;
        }
        case OBJECT_TYPE_STRING_SEQUENCE:
@@ -572,6 +575,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
                }
                stack_top->u.s.literal_type =
                        ESTACK_STRING_LITERAL_TYPE_NONE;
+               stack_top->type = REG_STRING;
                break;
        }
        case OBJECT_TYPE_DYNAMIC:
@@ -588,7 +592,7 @@ static int dynamic_load_field(struct estack_entry *stack_top)
        case OBJECT_TYPE_ARRAY:
        case OBJECT_TYPE_STRUCT:
        case OBJECT_TYPE_VARIANT:
-               printk(KERN_WARNING "Sequences, arrays, struct and variant cannot be loaded (nested types).\n");
+               printk(KERN_WARNING "LTTng: filter: Sequences, arrays, struct and variant cannot be loaded (nested types).\n");
                ret = -EINVAL;
                goto end;
        }
@@ -614,6 +618,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
        struct estack _stack;
        struct estack *stack = &_stack;
        register int64_t ax = 0, bx = 0;
+       register enum entry_type ax_t = REG_TYPE_UNKNOWN, bx_t = REG_TYPE_UNKNOWN;
        register int top = FILTER_STACK_EMPTY;
 #ifndef INTERPRETER_USE_SWITCH
        static void *dispatch[NR_FILTER_OPS] = {
@@ -764,7 +769,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 #ifdef INTERPRETER_USE_SWITCH
                default:
 #endif /* INTERPRETER_USE_SWITCH */
-                       printk(KERN_WARNING "unknown bytecode op %u\n",
+                       printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n",
                                (unsigned int) *(filter_opcode_t *) pc);
                        ret = -EINVAL;
                        goto end;
@@ -772,7 +777,18 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_RETURN):
                OP(FILTER_OP_RETURN_S64):
                        /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
-                       retval = !!estack_ax_v;
+                       switch (estack_ax_t) {
+                       case REG_S64:
+                               retval = !!estack_ax_v;
+                               break;
+                       case REG_DOUBLE:
+                       case REG_STRING:
+                       case REG_PTR:
+                       case REG_STAR_GLOB_STRING:
+                       case REG_TYPE_UNKNOWN:
+                               ret = -EINVAL;
+                               goto end;
+                       }
                        ret = 0;
                        goto end;
 
@@ -782,7 +798,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_MOD):
                OP(FILTER_OP_PLUS):
                OP(FILTER_OP_MINUS):
-                       printk(KERN_WARNING "unsupported bytecode op %u\n",
+                       printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n",
                                (unsigned int) *(filter_opcode_t *) pc);
                        ret = -EINVAL;
                        goto end;
@@ -793,7 +809,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_LT):
                OP(FILTER_OP_GE):
                OP(FILTER_OP_LE):
-                       printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n",
+                       printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n",
                                (unsigned int) *(filter_opcode_t *) pc);
                        ret = -EINVAL;
                        goto end;
@@ -803,8 +819,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, "==") == 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -813,8 +830,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, "!=") != 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -823,8 +841,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, ">") > 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -833,8 +852,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, "<") < 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -843,8 +863,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, ">=") >= 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -853,8 +874,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_strcmp(stack, top, "<=") <= 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -864,8 +886,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_star_glob_match(stack, top, "==") == 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -874,8 +897,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (stack_star_glob_match(stack, top, "!=") != 0);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -885,8 +909,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v == estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -895,8 +920,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v != estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -905,8 +931,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v > estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -915,8 +942,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v < estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -925,8 +953,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v >= estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -935,8 +964,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        int res;
 
                        res = (estack_bx_v <= estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -973,14 +1003,20 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        int64_t res;
 
+                       if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+                               ret = -EINVAL;
+                               goto end;
+                       }
+
                        /* Catch undefined behavior. */
                        if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
                                ret = -EINVAL;
                                goto end;
                        }
                        res = ((uint64_t) estack_bx_v >> (uint32_t) estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -988,14 +1024,20 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        int64_t res;
 
+                       if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+                               ret = -EINVAL;
+                               goto end;
+                       }
+
                        /* Catch undefined behavior. */
                        if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
                                ret = -EINVAL;
                                goto end;
                        }
                        res = ((uint64_t) estack_bx_v << (uint32_t) estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -1003,9 +1045,15 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        int64_t res;
 
+                       if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+                               ret = -EINVAL;
+                               goto end;
+                       }
+
                        res = ((uint64_t) estack_bx_v & (uint64_t) estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -1013,9 +1061,15 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        int64_t res;
 
+                       if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+                               ret = -EINVAL;
+                               goto end;
+                       }
+
                        res = ((uint64_t) estack_bx_v | (uint64_t) estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -1023,9 +1077,15 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        int64_t res;
 
+                       if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+                               ret = -EINVAL;
+                               goto end;
+                       }
+
                        res = ((uint64_t) estack_bx_v ^ (uint64_t) estack_ax_v);
-                       estack_pop(stack, top, ax, bx);
+                       estack_pop(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = res;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct binary_op);
                        PO;
                }
@@ -1034,7 +1094,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_UNARY_PLUS):
                OP(FILTER_OP_UNARY_MINUS):
                OP(FILTER_OP_UNARY_NOT):
-                       printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n",
+                       printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n",
                                (unsigned int) *(filter_opcode_t *) pc);
                        ret = -EINVAL;
                        goto end;
@@ -1043,6 +1103,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_UNARY_BIT_NOT):
                {
                        estack_ax_v = ~(uint64_t) estack_ax_v;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct unary_op);
                        PO;
                }
@@ -1055,6 +1116,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_UNARY_MINUS_S64):
                {
                        estack_ax_v = -estack_ax_v;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct unary_op);
                        PO;
                }
@@ -1067,6 +1129,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_UNARY_NOT_S64):
                {
                        estack_ax_v = !estack_ax_v;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct unary_op);
                        PO;
                }
@@ -1088,7 +1151,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                                next_pc = start_pc + insn->skip_offset;
                        } else {
                                /* Pop 1 when jump not taken */
-                               estack_pop(stack, top, ax, bx);
+                               estack_pop(stack, top, ax, bx, ax_t, bx_t);
                                next_pc += sizeof(struct logical_op);
                        }
                        PO;
@@ -1106,7 +1169,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                                next_pc = start_pc + insn->skip_offset;
                        } else {
                                /* Pop 1 when jump not taken */
-                               estack_pop(stack, top, ax, bx);
+                               estack_pop(stack, top, ax, bx, ax_t, bx_t);
                                next_pc += sizeof(struct logical_op);
                        }
                        PO;
@@ -1121,7 +1184,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                        dbg_printk("load field ref offset %u type string\n",
                                ref->offset);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.str =
                                *(const char * const *) &filter_stack_data[ref->offset];
                        if (unlikely(!estack_ax(stack, top)->u.s.str)) {
@@ -1133,6 +1196,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        estack_ax(stack, top)->u.s.literal_type =
                                ESTACK_STRING_LITERAL_TYPE_NONE;
                        estack_ax(stack, top)->u.s.user = 0;
+                       estack_ax(stack, top)->type = REG_STRING;
                        dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
                        next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
                        PO;
@@ -1145,7 +1209,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                        dbg_printk("load field ref offset %u type sequence\n",
                                ref->offset);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.seq_len =
                                *(unsigned long *) &filter_stack_data[ref->offset];
                        estack_ax(stack, top)->u.s.str =
@@ -1170,9 +1234,10 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                        dbg_printk("load field ref offset %u type s64\n",
                                ref->offset);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v =
                                ((struct literal_numeric *) &filter_stack_data[ref->offset])->v;
+                       estack_ax_t = REG_S64;
                        dbg_printk("ref load s64 %lld\n",
                                (long long) estack_ax_v);
                        next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
@@ -1191,7 +1256,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        struct load_op *insn = (struct load_op *) pc;
 
                        dbg_printk("load string %s\n", insn->data);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.str = insn->data;
                        estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
                        estack_ax(stack, top)->u.s.literal_type =
@@ -1206,7 +1271,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        struct load_op *insn = (struct load_op *) pc;
 
                        dbg_printk("load globbing pattern %s\n", insn->data);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.str = insn->data;
                        estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
                        estack_ax(stack, top)->u.s.literal_type =
@@ -1220,8 +1285,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                {
                        struct load_op *insn = (struct load_op *) pc;
 
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = ((struct literal_numeric *) insn->data)->v;
+                       estack_ax_t = REG_S64;
                        dbg_printk("load s64 %lld\n",
                                (long long) estack_ax_v);
                        next_pc += sizeof(struct load_op)
@@ -1237,7 +1303,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                /* cast */
                OP(FILTER_OP_CAST_TO_S64):
-                       printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n",
+                       printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n",
                                (unsigned int) *(filter_opcode_t *) pc);
                        ret = -EINVAL;
                        goto end;
@@ -1266,7 +1332,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                                ref->offset);
                        ctx_field = &lttng_static_ctx->fields[ref->offset];
                        ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.str = v.str;
                        if (unlikely(!estack_ax(stack, top)->u.s.str)) {
                                dbg_printk("Filter warning: loading a NULL string.\n");
@@ -1277,6 +1343,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        estack_ax(stack, top)->u.s.literal_type =
                                ESTACK_STRING_LITERAL_TYPE_NONE;
                        estack_ax(stack, top)->u.s.user = 0;
+                       estack_ax(stack, top)->type = REG_STRING;
                        dbg_printk("ref get context string %s\n", estack_ax(stack, top)->u.s.str);
                        next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
                        PO;
@@ -1293,8 +1360,9 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                                ref->offset);
                        ctx_field = &lttng_static_ctx->fields[ref->offset];
                        ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax_v = v.s64;
+                       estack_ax_t = REG_S64;
                        dbg_printk("ref get context s64 %lld\n",
                                (long long) estack_ax_v);
                        next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
@@ -1315,7 +1383,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                        dbg_printk("load field ref offset %u type user string\n",
                                ref->offset);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.user_str =
                                *(const char * const *) &filter_stack_data[ref->offset];
                        if (unlikely(!estack_ax(stack, top)->u.s.str)) {
@@ -1327,6 +1395,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        estack_ax(stack, top)->u.s.literal_type =
                                ESTACK_STRING_LITERAL_TYPE_NONE;
                        estack_ax(stack, top)->u.s.user = 1;
+                       estack_ax(stack, top)->type = REG_STRING;
                        dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
                        next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
                        PO;
@@ -1339,7 +1408,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 
                        dbg_printk("load field ref offset %u type user sequence\n",
                                ref->offset);
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.s.seq_len =
                                *(unsigned long *) &filter_stack_data[ref->offset];
                        estack_ax(stack, top)->u.s.user_str =
@@ -1360,10 +1429,11 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_GET_CONTEXT_ROOT):
                {
                        dbg_printk("op get context root\n");
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_CONTEXT;
                        /* "field" only needed for variants. */
                        estack_ax(stack, top)->u.ptr.field = NULL;
+                       estack_ax(stack, top)->type = REG_PTR;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1377,11 +1447,12 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                OP(FILTER_OP_GET_PAYLOAD_ROOT):
                {
                        dbg_printk("op get app payload root\n");
-                       estack_push(stack, top, ax, bx);
+                       estack_push(stack, top, ax, bx, ax_t, bx_t);
                        estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_PAYLOAD;
                        estack_ax(stack, top)->u.ptr.ptr = filter_stack_data;
                        /* "field" only needed for variants. */
                        estack_ax(stack, top)->u.ptr.field = NULL;
+                       estack_ax(stack, top)->type = REG_PTR;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1391,7 +1462,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op get symbol\n");
                        switch (estack_ax(stack, top)->u.ptr.type) {
                        case LOAD_OBJECT:
-                               printk(KERN_WARNING "Nested fields not implemented yet.\n");
+                               printk(KERN_WARNING "LTTng: filter: Nested fields not implemented yet.\n");
                                ret = -EINVAL;
                                goto end;
                        case LOAD_ROOT_CONTEXT:
@@ -1428,6 +1499,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        if (ret)
                                goto end;
                        estack_ax_v = estack_ax(stack, top)->u.v;
+                       estack_ax_t = estack_ax(stack, top)->type;
                        next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
                        PO;
                }
@@ -1442,6 +1514,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        if (ret)
                                goto end;
                        estack_ax_v = estack_ax(stack, top)->u.v;
+                       estack_ax_t = estack_ax(stack, top)->type;
                        next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
                        PO;
                }
@@ -1453,6 +1526,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        if (ret)
                                goto end;
                        estack_ax_v = estack_ax(stack, top)->u.v;
+                       estack_ax_t = estack_ax(stack, top)->type;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1462,6 +1536,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field s8\n");
 
                        estack_ax_v = *(int8_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1470,6 +1545,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field s16\n");
 
                        estack_ax_v = *(int16_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1478,6 +1554,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field s32\n");
 
                        estack_ax_v = *(int32_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1486,6 +1563,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field s64\n");
 
                        estack_ax_v = *(int64_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1494,6 +1572,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field u8\n");
 
                        estack_ax_v = *(uint8_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1502,6 +1581,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field u16\n");
 
                        estack_ax_v = *(uint16_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1510,6 +1590,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field u32\n");
 
                        estack_ax_v = *(uint32_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1518,6 +1599,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        dbg_printk("op load field u64\n");
 
                        estack_ax_v = *(uint64_t *) estack_ax(stack, top)->u.ptr.ptr;
+                       estack_ax_t = REG_S64;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1542,6 +1624,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
                        estack_ax(stack, top)->u.s.literal_type =
                                ESTACK_STRING_LITERAL_TYPE_NONE;
+                       estack_ax(stack, top)->type = REG_STRING;
                        next_pc += sizeof(struct load_op);
                        PO;
                }
@@ -1561,6 +1644,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data,
                        }
                        estack_ax(stack, top)->u.s.literal_type =
                                ESTACK_STRING_LITERAL_TYPE_NONE;
+                       estack_ax(stack, top)->type = REG_STRING;
                        next_pc += sizeof(struct load_op);
                        PO;
                }