projects / lttng-modules.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
bytecode: generalize `struct lttng_filter_bytecode_node`
[lttng-modules.git] / src / lttng-filter-validator.c
diff --git a/src/lttng-filter-validator.c b/src/lttng-filter-validator.c
index 38d6ed07bb531da45e1ca83ca9c1373acb71837f..3353be2b374cf7a4520df8c6cfe7e0310009c8b0 100644 (file)
--- a/src/lttng-filter-validator.c
+++ b/src/lttng-filter-validator.c
@@ -87,7 +87,7 @@ int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc,
                                target_pc, hash);
                kfree(mp_node);
                if (merge_points_compare(stack, &lookup_node->stack)) {
-                       printk(KERN_WARNING "Merge points differ for offset %lu\n",
+                       printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n",
                                target_pc);
                        return -EINVAL;
                }
@@ -127,6 +127,7 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode,
                        }
                        break;
                case REG_S64:
+               case REG_U64:
                        goto error_mismatch;
                }
                break;
@@ -144,10 +145,12 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode,
                        break;
                case REG_STAR_GLOB_STRING:
                case REG_S64:
+               case REG_U64:
                        goto error_mismatch;
                }
                break;
        case REG_S64:
+       case REG_U64:
                switch (vstack_bx(stack)->type) {
                default:
                case REG_DOUBLE:
@@ -158,6 +161,7 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode,
                case REG_STAR_GLOB_STRING:
                        goto error_mismatch;
                case REG_S64:
+               case REG_U64:
                        break;
                }
                break;
@@ -170,6 +174,7 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode,
                case REG_STRING:
                case REG_STAR_GLOB_STRING:
                case REG_S64:
+               case REG_U64:
                        goto unknown;
                }
                break;
@@ -180,15 +185,15 @@ unknown:
        return 1;
 
 error_empty:
-       printk(KERN_WARNING "empty stack for '%s' binary operator\n", str);
+       printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str);
        return -EINVAL;
 
 error_mismatch:
-       printk(KERN_WARNING "type mismatch for '%s' binary operator\n", str);
+       printk(KERN_WARNING "LTTng: filter: type mismatch for '%s' binary operator\n", str);
        return -EINVAL;
 
 error_type:
-       printk(KERN_WARNING "unknown type for '%s' binary operator\n", str);
+       printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str);
        return -EINVAL;
 }
 
@@ -215,13 +220,13 @@ int bin_op_bitwise_check(struct vstack *stack, filter_opcode_t opcode,
                case REG_DOUBLE:
                        goto error_type;
                case REG_TYPE_UNKNOWN:
-               case REG_STRING:
-               case REG_STAR_GLOB_STRING:
                case REG_S64:
+               case REG_U64:
                        goto unknown;
                }
                break;
        case REG_S64:
+       case REG_U64:
                switch (vstack_bx(stack)->type) {
                default:
                case REG_DOUBLE:
@@ -229,6 +234,7 @@ int bin_op_bitwise_check(struct vstack *stack, filter_opcode_t opcode,
                case REG_TYPE_UNKNOWN:
                        goto unknown;
                case REG_S64:
+               case REG_U64:
                        break;
                }
                break;
@@ -239,11 +245,11 @@ unknown:
        return 1;
 
 error_empty:
-       printk(KERN_WARNING "empty stack for '%s' binary operator\n", str);
+       printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str);
        return -EINVAL;
 
 error_type:
-       printk(KERN_WARNING "unknown type for '%s' binary operator\n", str);
+       printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str);
        return -EINVAL;
 }
 
@@ -279,7 +285,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNKNOWN:
        default:
        {
-               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;
                break;
@@ -328,7 +334,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNARY_MINUS_DOUBLE:
        case FILTER_OP_UNARY_NOT_DOUBLE:
        {
-               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;
                break;
@@ -397,7 +403,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
        /* load field ref */
        case FILTER_OP_LOAD_FIELD_REF:
        {
-               printk(KERN_WARNING "Unknown field ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n");
                ret = -EINVAL;
                break;
        }
@@ -405,7 +411,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
        /* get context ref */
        case FILTER_OP_GET_CONTEXT_REF:
        {
-               printk(KERN_WARNING "Unknown field ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n");
                ret = -EINVAL;
                break;
        }
@@ -504,7 +510,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
        }
 
        case FILTER_OP_GET_SYMBOL_FIELD:
-               printk(KERN_WARNING "Unexpected get symbol field\n");
+               printk(KERN_WARNING "LTTng: filter: Unexpected get symbol field\n");
                ret = -EINVAL;
                break;
 
@@ -564,7 +570,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNKNOWN:
        default:
        {
-               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;
@@ -609,7 +615,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_CAST_DOUBLE_TO_S64:
        case FILTER_OP_GET_CONTEXT_REF_DOUBLE:
        {
-               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;
@@ -666,13 +672,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_LE_STRING:
        {
                if (!vstack_ax(stack) || !vstack_bx(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_STRING
                                || vstack_bx(stack)->type != REG_STRING) {
-                       printk(KERN_WARNING "Unexpected register type for string comparator\n");
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type for string comparator\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -684,13 +690,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_NE_STAR_GLOB_STRING:
        {
                if (!vstack_ax(stack) || !vstack_bx(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_STAR_GLOB_STRING
                                && vstack_bx(stack)->type != REG_STAR_GLOB_STRING) {
-                       printk(KERN_WARNING "Unexpected register type for globbing pattern comparator\n");
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type for globbing pattern comparator\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -705,13 +711,25 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_LE_S64:
        {
                if (!vstack_ax(stack) || !vstack_bx(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
-               if (vstack_ax(stack)->type != REG_S64
-                               || vstack_bx(stack)->type != REG_S64) {
-                       printk(KERN_WARNING "Unexpected register type for s64 comparator\n");
+               switch (vstack_ax(stack)->type) {
+               case REG_S64:
+               case REG_U64:
+                       break;
+               default:
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type for s64 comparator\n");
+                       ret = -EINVAL;
+                       goto end;
+               }
+               switch (vstack_bx(stack)->type) {
+               case REG_S64:
+               case REG_U64:
+                       break;
+               default:
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type for s64 comparator\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -750,23 +768,24 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNARY_NOT:
        {
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                default:
                case REG_DOUBLE:
-                       printk(KERN_WARNING "unknown register type\n");
+                       printk(KERN_WARNING "LTTng: filter: unknown register type\n");
                        ret = -EINVAL;
                        goto end;
 
                case REG_STRING:
                case REG_STAR_GLOB_STRING:
-                       printk(KERN_WARNING "Unary op can only be applied to numeric or floating point registers\n");
+                       printk(KERN_WARNING "LTTng: filter: Unary op can only be applied to numeric or floating point registers\n");
                        ret = -EINVAL;
                        goto end;
                case REG_S64:
+               case REG_U64:
                case REG_TYPE_UNKNOWN:
                        break;
                }
@@ -775,24 +794,24 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNARY_BIT_NOT:
        {
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                default:
-                       printk(KERN_WARNING "unknown register type\n");
+                       printk(KERN_WARNING "LTTng: filter: unknown register type\n");
                        ret = -EINVAL;
                        goto end;
 
                case REG_STRING:
                case REG_STAR_GLOB_STRING:
                case REG_DOUBLE:
-                       printk(KERN_WARNING "Unary bitwise op can only be applied to numeric registers\n");
+                       printk(KERN_WARNING "LTTng: filter: Unary bitwise op can only be applied to numeric registers\n");
                        ret = -EINVAL;
                        goto end;
                case REG_S64:
-                       break;
+               case REG_U64:
                case REG_TYPE_UNKNOWN:
                        break;
                }
@@ -804,12 +823,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNARY_NOT_S64:
        {
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
-               if (vstack_ax(stack)->type != REG_S64) {
-                       printk(KERN_WARNING "Invalid register type\n");
+               if (vstack_ax(stack)->type != REG_S64 &&
+                               vstack_ax(stack)->type != REG_U64) {
+                       printk(KERN_WARNING "LTTng: filter: Invalid register type\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -823,12 +843,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
                struct logical_op *insn = (struct logical_op *) pc;
 
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
-               if (vstack_ax(stack)->type != REG_S64) {
-                       printk(KERN_WARNING "Logical comparator expects S64 register\n");
+               if (vstack_ax(stack)->type != REG_S64 &&
+                               vstack_ax(stack)->type != REG_U64) {
+                       printk(KERN_WARNING "LTTng: filter: Logical comparator expects S64 register\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -836,7 +857,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
                dbg_printk("Validate jumping to bytecode offset %u\n",
                        (unsigned int) insn->skip_offset);
                if (unlikely(start_pc + insn->skip_offset <= pc)) {
-                       printk(KERN_WARNING "Loops are not allowed in bytecode\n");
+                       printk(KERN_WARNING "LTTng: filter: Loops are not allowed in bytecode\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -846,7 +867,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        /* load field ref */
        case FILTER_OP_LOAD_FIELD_REF:
        {
-               printk(KERN_WARNING "Unknown field ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n");
                ret = -EINVAL;
                goto end;
        }
@@ -889,20 +910,20 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
                struct cast_op *insn = (struct cast_op *) pc;
 
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                default:
                case REG_DOUBLE:
-                       printk(KERN_WARNING "unknown register type\n");
+                       printk(KERN_WARNING "LTTng: filter: unknown register type\n");
                        ret = -EINVAL;
                        goto end;
 
                case REG_STRING:
                case REG_STAR_GLOB_STRING:
-                       printk(KERN_WARNING "Cast op can only be applied to numeric or floating point registers\n");
+                       printk(KERN_WARNING "LTTng: filter: Cast op can only be applied to numeric or floating point registers\n");
                        ret = -EINVAL;
                        goto end;
                case REG_S64:
@@ -910,7 +931,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
                }
                if (insn->op == FILTER_OP_CAST_DOUBLE_TO_S64) {
                        if (vstack_ax(stack)->type != REG_DOUBLE) {
-                               printk(KERN_WARNING "Cast expects double\n");
+                               printk(KERN_WARNING "LTTng: filter: Cast expects double\n");
                                ret = -EINVAL;
                                goto end;
                        }
@@ -925,7 +946,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode,
        /* get context ref */
        case FILTER_OP_GET_CONTEXT_REF:
        {
-               printk(KERN_WARNING "Unknown get context ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n");
                ret = -EINVAL;
                goto end;
        }
@@ -1109,7 +1130,7 @@ int validate_instruction_all_contexts(struct bytecode_runtime *bytecode,
                dbg_printk("Filter: validate merge point at offset %lu\n",
                                target_pc);
                if (merge_points_compare(stack, &mp_node->stack)) {
-                       printk(KERN_WARNING "Merge points differ for offset %lu\n",
+                       printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n",
                                target_pc);
                        return -EINVAL;
                }
@@ -1141,7 +1162,7 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_UNKNOWN:
        default:
        {
-               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;
@@ -1150,16 +1171,20 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_RETURN:
        {
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
+               case REG_DOUBLE:
+               case REG_STRING:
+               case REG_PTR:
                case REG_TYPE_UNKNOWN:
                        break;
                default:
-                       printk(KERN_WARNING "Unexpected register type %d at end of bytecode\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
@@ -1172,16 +1197,17 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_RETURN_S64:
        {
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                        break;
                default:
                case REG_TYPE_UNKNOWN:
-                       printk(KERN_WARNING "Unexpected register type %d at end of bytecode\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
@@ -1224,7 +1250,7 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_LOAD_DOUBLE:
        case FILTER_OP_CAST_DOUBLE_TO_S64:
        {
-               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;
@@ -1250,6 +1276,36 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_LT_S64:
        case FILTER_OP_GE_S64:
        case FILTER_OP_LE_S64:
+       {
+               /* Pop 2, push 1 */
+               if (vstack_pop(stack)) {
+                       ret = -EINVAL;
+                       goto end;
+               }
+               if (!vstack_ax(stack)) {
+                       printk(KERN_WARNING "Empty stack\n");
+                       ret = -EINVAL;
+                       goto end;
+               }
+               switch (vstack_ax(stack)->type) {
+               case REG_S64:
+               case REG_U64:
+               case REG_DOUBLE:
+               case REG_STRING:
+               case REG_STAR_GLOB_STRING:
+               case REG_TYPE_UNKNOWN:
+                       break;
+               default:
+                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                               (int) vstack_ax(stack)->type);
+                       ret = -EINVAL;
+                       goto end;
+               }
+
+               vstack_ax(stack)->type = REG_S64;
+               next_pc += sizeof(struct binary_op);
+               break;
+       }
        case FILTER_OP_BIT_RSHIFT:
        case FILTER_OP_BIT_LSHIFT:
        case FILTER_OP_BIT_AND:
@@ -1262,25 +1318,26 @@ int exec_insn(struct bytecode_runtime *bytecode,
                        goto end;
                }
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                case REG_DOUBLE:
                case REG_STRING:
                case REG_STAR_GLOB_STRING:
                case REG_TYPE_UNKNOWN:
                        break;
                default:
-                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
                }
 
-               vstack_ax(stack)->type = REG_S64;
+               vstack_ax(stack)->type = REG_U64;
                next_pc += sizeof(struct binary_op);
                break;
        }
@@ -1291,16 +1348,17 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                case REG_TYPE_UNKNOWN:
                        break;
                default:
-                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
@@ -1317,21 +1375,21 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                        break;
                default:
-                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
                }
 
-               vstack_ax(stack)->type = REG_S64;
                next_pc += sizeof(struct unary_op);
                break;
        }
@@ -1340,22 +1398,22 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                case REG_TYPE_UNKNOWN:
                        break;
                default:
-                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
                }
 
-               vstack_ax(stack)->type = REG_S64;
                next_pc += sizeof(struct unary_op);
                break;
        }
@@ -1364,23 +1422,24 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                case REG_TYPE_UNKNOWN:
                        break;
                case REG_DOUBLE:
                default:
-                       printk(KERN_WARNING "Unexpected register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
                }
 
-               vstack_ax(stack)->type = REG_S64;
+               vstack_ax(stack)->type = REG_U64;
                next_pc += sizeof(struct unary_op);
                break;
        }
@@ -1401,16 +1460,17 @@ int exec_insn(struct bytecode_runtime *bytecode,
                }
 
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                /* There is always a cast-to-s64 operation before a or/and op. */
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                        break;
                default:
-                       printk(KERN_WARNING "Incorrect register type %d for operation\n",
+                       printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for operation\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
@@ -1429,14 +1489,14 @@ int exec_insn(struct bytecode_runtime *bytecode,
        /* load field ref */
        case FILTER_OP_LOAD_FIELD_REF:
        {
-               printk(KERN_WARNING "Unknown field ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n");
                ret = -EINVAL;
                goto end;
        }
        /* get context ref */
        case FILTER_OP_GET_CONTEXT_REF:
        {
-               printk(KERN_WARNING "Unknown get context ref type\n");
+               printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n");
                ret = -EINVAL;
                goto end;
        }
@@ -1509,17 +1569,18 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n");
                        ret = -EINVAL;
                        goto end;
                }
                switch (vstack_ax(stack)->type) {
                case REG_S64:
+               case REG_U64:
                case REG_DOUBLE:
                case REG_TYPE_UNKNOWN:
                        break;
                default:
-                       printk(KERN_WARNING "Incorrect register type %d for cast\n",
+                       printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for cast\n",
                                (int) vstack_ax(stack)->type);
                        ret = -EINVAL;
                        goto end;
@@ -1554,12 +1615,12 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1572,6 +1633,22 @@ int exec_insn(struct bytecode_runtime *bytecode,
        case FILTER_OP_LOAD_FIELD_S16:
        case FILTER_OP_LOAD_FIELD_S32:
        case FILTER_OP_LOAD_FIELD_S64:
+       {
+               /* Pop 1, push 1 */
+               if (!vstack_ax(stack)) {
+                       printk(KERN_WARNING "Empty stack\n\n");
+                       ret = -EINVAL;
+                       goto end;
+               }
+               if (vstack_ax(stack)->type != REG_PTR) {
+                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       ret = -EINVAL;
+                       goto end;
+               }
+               vstack_ax(stack)->type = REG_S64;
+               next_pc += sizeof(struct load_op);
+               break;
+       }
        case FILTER_OP_LOAD_FIELD_U8:
        case FILTER_OP_LOAD_FIELD_U16:
        case FILTER_OP_LOAD_FIELD_U32:
@@ -1579,31 +1656,30 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
-               vstack_ax(stack)->type = REG_S64;
+               vstack_ax(stack)->type = REG_U64;
                next_pc += sizeof(struct load_op);
                break;
        }
-
        case FILTER_OP_LOAD_FIELD_STRING:
        case FILTER_OP_LOAD_FIELD_SEQUENCE:
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1616,12 +1692,12 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1635,12 +1711,12 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1652,12 +1728,12 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1669,12 +1745,12 @@ int exec_insn(struct bytecode_runtime *bytecode,
        {
                /* Pop 1, push 1 */
                if (!vstack_ax(stack)) {
-                       printk(KERN_WARNING "Empty stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Empty stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
                if (vstack_ax(stack)->type != REG_PTR) {
-                       printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
+                       printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n");
                        ret = -EINVAL;
                        goto end;
                }
@@ -1702,7 +1778,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode)
 
        mp_table = kzalloc(sizeof(*mp_table), GFP_KERNEL);
        if (!mp_table) {
-               printk(KERN_WARNING "Error allocating hash table for bytecode validation\n");
+               printk(KERN_WARNING "LTTng: filter: Error allocating hash table for bytecode validation\n");
                return -ENOMEM;
        }
        start_pc = &bytecode->code[0];
@@ -1711,7 +1787,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode)
                ret = bytecode_validate_overflow(bytecode, start_pc, pc);
                if (ret != 0) {
                        if (ret == -ERANGE)
-                               printk(KERN_WARNING "filter bytecode overflow\n");
+                               printk(KERN_WARNING "LTTng: filter: filter bytecode overflow\n");
                        goto end;
                }
                dbg_printk("Validating op %s (%u)\n",
@@ -1734,7 +1810,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode)
 end:
        if (delete_all_nodes(mp_table)) {
                if (!ret) {
-                       printk(KERN_WARNING "Unexpected merge points\n");
+                       printk(KERN_WARNING "LTTng: filter: Unexpected merge points\n");
                        ret = -EINVAL;
                }
        }
LTTng 2.0/0.x modules
This page took 0.036786 seconds and 4 git commands to generate.