1 /* SPDX-License-Identifier: MIT
3 * lttng-filter-validator.c
5 * LTTng modules filter bytecode validator.
7 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 #include <linux/types.h>
11 #include <linux/jhash.h>
12 #include <linux/slab.h>
14 #include <wrapper/list.h>
15 #include <lttng-filter.h>
17 #define MERGE_POINT_TABLE_BITS 7
18 #define MERGE_POINT_TABLE_SIZE (1U << MERGE_POINT_TABLE_BITS)
20 /* merge point table node */
22 struct hlist_node node
;
24 /* Context at merge point */
26 unsigned long target_pc
;
30 struct hlist_head mp_head
[MERGE_POINT_TABLE_SIZE
];
34 int lttng_hash_match(struct mp_node
*mp_node
, unsigned long key_pc
)
36 if (mp_node
->target_pc
== key_pc
)
43 int merge_points_compare(const struct vstack
*stacka
,
44 const struct vstack
*stackb
)
48 if (stacka
->top
!= stackb
->top
)
50 len
= stacka
->top
+ 1;
51 WARN_ON_ONCE(len
< 0);
52 for (i
= 0; i
< len
; i
++) {
53 if (stacka
->e
[i
].type
!= stackb
->e
[i
].type
)
60 int merge_point_add_check(struct mp_table
*mp_table
, unsigned long target_pc
,
61 const struct vstack
*stack
)
63 struct mp_node
*mp_node
;
64 unsigned long hash
= jhash_1word(target_pc
, 0);
65 struct hlist_head
*head
;
66 struct mp_node
*lookup_node
;
69 dbg_printk("Filter: adding merge point at offset %lu, hash %lu\n",
71 mp_node
= kzalloc(sizeof(struct mp_node
), GFP_KERNEL
);
74 mp_node
->target_pc
= target_pc
;
75 memcpy(&mp_node
->stack
, stack
, sizeof(mp_node
->stack
));
77 head
= &mp_table
->mp_head
[hash
& (MERGE_POINT_TABLE_SIZE
- 1)];
78 lttng_hlist_for_each_entry(lookup_node
, head
, node
) {
79 if (lttng_hash_match(lookup_node
, target_pc
)) {
85 /* Key already present */
86 dbg_printk("Filter: compare merge points for offset %lu, hash %lu\n",
89 if (merge_points_compare(stack
, &lookup_node
->stack
)) {
90 printk(KERN_WARNING
"Merge points differ for offset %lu\n",
95 hlist_add_head(&mp_node
->node
, head
);
101 * Binary comparators use top of stack and top of stack -1.
104 int bin_op_compare_check(struct vstack
*stack
, const filter_opcode_t opcode
,
107 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
110 switch (vstack_ax(stack
)->type
) {
116 switch (vstack_bx(stack
)->type
) {
120 case REG_TYPE_UNKNOWN
:
124 case REG_STAR_GLOB_STRING
:
125 if (opcode
!= FILTER_OP_EQ
&& opcode
!= FILTER_OP_NE
) {
133 case REG_STAR_GLOB_STRING
:
134 switch (vstack_bx(stack
)->type
) {
138 case REG_TYPE_UNKNOWN
:
141 if (opcode
!= FILTER_OP_EQ
&& opcode
!= FILTER_OP_NE
) {
145 case REG_STAR_GLOB_STRING
:
151 switch (vstack_bx(stack
)->type
) {
155 case REG_TYPE_UNKNOWN
:
158 case REG_STAR_GLOB_STRING
:
164 case REG_TYPE_UNKNOWN
:
165 switch (vstack_bx(stack
)->type
) {
169 case REG_TYPE_UNKNOWN
:
171 case REG_STAR_GLOB_STRING
:
183 printk(KERN_WARNING
"empty stack for '%s' binary operator\n", str
);
187 printk(KERN_WARNING
"type mismatch for '%s' binary operator\n", str
);
191 printk(KERN_WARNING
"unknown type for '%s' binary operator\n", str
);
196 * Binary bitwise operators use top of stack and top of stack -1.
197 * Return 0 if typing is known to match, 1 if typing is dynamic
198 * (unknown), negative error value on error.
201 int bin_op_bitwise_check(struct vstack
*stack
, filter_opcode_t opcode
,
204 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
207 switch (vstack_ax(stack
)->type
) {
212 case REG_TYPE_UNKNOWN
:
213 switch (vstack_bx(stack
)->type
) {
217 case REG_TYPE_UNKNOWN
:
219 case REG_STAR_GLOB_STRING
:
225 switch (vstack_bx(stack
)->type
) {
229 case REG_TYPE_UNKNOWN
:
242 printk(KERN_WARNING
"empty stack for '%s' binary operator\n", str
);
246 printk(KERN_WARNING
"unknown type for '%s' binary operator\n", str
);
251 int validate_get_symbol(struct bytecode_runtime
*bytecode
,
252 const struct get_symbol
*sym
)
254 const char *str
, *str_limit
;
257 if (sym
->offset
>= bytecode
->p
.bc
->bc
.len
- bytecode
->p
.bc
->bc
.reloc_offset
)
260 str
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.reloc_offset
+ sym
->offset
;
261 str_limit
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.len
;
262 len_limit
= str_limit
- str
;
263 if (strnlen(str
, len_limit
) == len_limit
)
269 * Validate bytecode range overflow within the validation pass.
270 * Called for each instruction encountered.
273 int bytecode_validate_overflow(struct bytecode_runtime
*bytecode
,
274 char *start_pc
, char *pc
)
278 switch (*(filter_opcode_t
*) pc
) {
279 case FILTER_OP_UNKNOWN
:
282 printk(KERN_WARNING
"unknown bytecode op %u\n",
283 (unsigned int) *(filter_opcode_t
*) pc
);
288 case FILTER_OP_RETURN
:
289 case FILTER_OP_RETURN_S64
:
291 if (unlikely(pc
+ sizeof(struct return_op
)
292 > start_pc
+ bytecode
->len
)) {
303 case FILTER_OP_MINUS
:
304 case FILTER_OP_EQ_DOUBLE
:
305 case FILTER_OP_NE_DOUBLE
:
306 case FILTER_OP_GT_DOUBLE
:
307 case FILTER_OP_LT_DOUBLE
:
308 case FILTER_OP_GE_DOUBLE
:
309 case FILTER_OP_LE_DOUBLE
:
311 case FILTER_OP_EQ_DOUBLE_S64
:
312 case FILTER_OP_NE_DOUBLE_S64
:
313 case FILTER_OP_GT_DOUBLE_S64
:
314 case FILTER_OP_LT_DOUBLE_S64
:
315 case FILTER_OP_GE_DOUBLE_S64
:
316 case FILTER_OP_LE_DOUBLE_S64
:
317 case FILTER_OP_EQ_S64_DOUBLE
:
318 case FILTER_OP_NE_S64_DOUBLE
:
319 case FILTER_OP_GT_S64_DOUBLE
:
320 case FILTER_OP_LT_S64_DOUBLE
:
321 case FILTER_OP_GE_S64_DOUBLE
:
322 case FILTER_OP_LE_S64_DOUBLE
:
323 case FILTER_OP_LOAD_FIELD_REF_DOUBLE
:
324 case FILTER_OP_GET_CONTEXT_REF_DOUBLE
:
325 case FILTER_OP_LOAD_DOUBLE
:
326 case FILTER_OP_CAST_DOUBLE_TO_S64
:
327 case FILTER_OP_UNARY_PLUS_DOUBLE
:
328 case FILTER_OP_UNARY_MINUS_DOUBLE
:
329 case FILTER_OP_UNARY_NOT_DOUBLE
:
331 printk(KERN_WARNING
"unsupported bytecode op %u\n",
332 (unsigned int) *(filter_opcode_t
*) pc
);
343 case FILTER_OP_EQ_STRING
:
344 case FILTER_OP_NE_STRING
:
345 case FILTER_OP_GT_STRING
:
346 case FILTER_OP_LT_STRING
:
347 case FILTER_OP_GE_STRING
:
348 case FILTER_OP_LE_STRING
:
349 case FILTER_OP_EQ_STAR_GLOB_STRING
:
350 case FILTER_OP_NE_STAR_GLOB_STRING
:
351 case FILTER_OP_EQ_S64
:
352 case FILTER_OP_NE_S64
:
353 case FILTER_OP_GT_S64
:
354 case FILTER_OP_LT_S64
:
355 case FILTER_OP_GE_S64
:
356 case FILTER_OP_LE_S64
:
357 case FILTER_OP_BIT_RSHIFT
:
358 case FILTER_OP_BIT_LSHIFT
:
359 case FILTER_OP_BIT_AND
:
360 case FILTER_OP_BIT_OR
:
361 case FILTER_OP_BIT_XOR
:
363 if (unlikely(pc
+ sizeof(struct binary_op
)
364 > start_pc
+ bytecode
->len
)) {
371 case FILTER_OP_UNARY_PLUS
:
372 case FILTER_OP_UNARY_MINUS
:
373 case FILTER_OP_UNARY_NOT
:
374 case FILTER_OP_UNARY_PLUS_S64
:
375 case FILTER_OP_UNARY_MINUS_S64
:
376 case FILTER_OP_UNARY_NOT_S64
:
377 case FILTER_OP_UNARY_BIT_NOT
:
379 if (unlikely(pc
+ sizeof(struct unary_op
)
380 > start_pc
+ bytecode
->len
)) {
390 if (unlikely(pc
+ sizeof(struct logical_op
)
391 > start_pc
+ bytecode
->len
)) {
397 /* load field and get context ref */
398 case FILTER_OP_LOAD_FIELD_REF
:
399 case FILTER_OP_GET_CONTEXT_REF
:
400 case FILTER_OP_LOAD_FIELD_REF_STRING
:
401 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE
:
402 case FILTER_OP_LOAD_FIELD_REF_USER_STRING
:
403 case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE
:
404 case FILTER_OP_LOAD_FIELD_REF_S64
:
405 case FILTER_OP_GET_CONTEXT_REF_STRING
:
406 case FILTER_OP_GET_CONTEXT_REF_S64
:
408 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct field_ref
)
409 > start_pc
+ bytecode
->len
)) {
415 /* load from immediate operand */
416 case FILTER_OP_LOAD_STRING
:
417 case FILTER_OP_LOAD_STAR_GLOB_STRING
:
419 struct load_op
*insn
= (struct load_op
*) pc
;
420 uint32_t str_len
, maxlen
;
422 if (unlikely(pc
+ sizeof(struct load_op
)
423 > start_pc
+ bytecode
->len
)) {
428 maxlen
= start_pc
+ bytecode
->len
- pc
- sizeof(struct load_op
);
429 str_len
= strnlen(insn
->data
, maxlen
);
430 if (unlikely(str_len
>= maxlen
)) {
431 /* Final '\0' not found within range */
437 case FILTER_OP_LOAD_S64
:
439 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct literal_numeric
)
440 > start_pc
+ bytecode
->len
)) {
446 case FILTER_OP_CAST_TO_S64
:
447 case FILTER_OP_CAST_NOP
:
449 if (unlikely(pc
+ sizeof(struct cast_op
)
450 > start_pc
+ bytecode
->len
)) {
457 * Instructions for recursive traversal through composed types.
459 case FILTER_OP_GET_CONTEXT_ROOT
:
460 case FILTER_OP_GET_APP_CONTEXT_ROOT
:
461 case FILTER_OP_GET_PAYLOAD_ROOT
:
462 case FILTER_OP_LOAD_FIELD
:
463 case FILTER_OP_LOAD_FIELD_S8
:
464 case FILTER_OP_LOAD_FIELD_S16
:
465 case FILTER_OP_LOAD_FIELD_S32
:
466 case FILTER_OP_LOAD_FIELD_S64
:
467 case FILTER_OP_LOAD_FIELD_U8
:
468 case FILTER_OP_LOAD_FIELD_U16
:
469 case FILTER_OP_LOAD_FIELD_U32
:
470 case FILTER_OP_LOAD_FIELD_U64
:
471 case FILTER_OP_LOAD_FIELD_STRING
:
472 case FILTER_OP_LOAD_FIELD_SEQUENCE
:
473 case FILTER_OP_LOAD_FIELD_DOUBLE
:
474 if (unlikely(pc
+ sizeof(struct load_op
)
475 > start_pc
+ bytecode
->len
)) {
480 case FILTER_OP_GET_SYMBOL
:
482 struct load_op
*insn
= (struct load_op
*) pc
;
483 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
485 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_symbol
)
486 > start_pc
+ bytecode
->len
)) {
490 ret
= validate_get_symbol(bytecode
, sym
);
494 case FILTER_OP_GET_SYMBOL_FIELD
:
495 printk(KERN_WARNING
"Unexpected get symbol field\n");
499 case FILTER_OP_GET_INDEX_U16
:
500 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u16
)
501 > start_pc
+ bytecode
->len
)) {
506 case FILTER_OP_GET_INDEX_U64
:
507 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u64
)
508 > start_pc
+ bytecode
->len
)) {
518 unsigned long delete_all_nodes(struct mp_table
*mp_table
)
520 struct mp_node
*mp_node
;
521 struct hlist_node
*tmp
;
522 unsigned long nr_nodes
= 0;
525 for (i
= 0; i
< MERGE_POINT_TABLE_SIZE
; i
++) {
526 struct hlist_head
*head
;
528 head
= &mp_table
->mp_head
[i
];
529 lttng_hlist_for_each_entry_safe(mp_node
, tmp
, head
, node
) {
543 int validate_instruction_context(struct bytecode_runtime
*bytecode
,
544 struct vstack
*stack
,
549 const filter_opcode_t opcode
= *(filter_opcode_t
*) pc
;
552 case FILTER_OP_UNKNOWN
:
555 printk(KERN_WARNING
"unknown bytecode op %u\n",
556 (unsigned int) *(filter_opcode_t
*) pc
);
561 case FILTER_OP_RETURN
:
562 case FILTER_OP_RETURN_S64
:
572 case FILTER_OP_MINUS
:
574 case FILTER_OP_EQ_DOUBLE
:
575 case FILTER_OP_NE_DOUBLE
:
576 case FILTER_OP_GT_DOUBLE
:
577 case FILTER_OP_LT_DOUBLE
:
578 case FILTER_OP_GE_DOUBLE
:
579 case FILTER_OP_LE_DOUBLE
:
580 case FILTER_OP_EQ_DOUBLE_S64
:
581 case FILTER_OP_NE_DOUBLE_S64
:
582 case FILTER_OP_GT_DOUBLE_S64
:
583 case FILTER_OP_LT_DOUBLE_S64
:
584 case FILTER_OP_GE_DOUBLE_S64
:
585 case FILTER_OP_LE_DOUBLE_S64
:
586 case FILTER_OP_EQ_S64_DOUBLE
:
587 case FILTER_OP_NE_S64_DOUBLE
:
588 case FILTER_OP_GT_S64_DOUBLE
:
589 case FILTER_OP_LT_S64_DOUBLE
:
590 case FILTER_OP_GE_S64_DOUBLE
:
591 case FILTER_OP_LE_S64_DOUBLE
:
592 case FILTER_OP_UNARY_PLUS_DOUBLE
:
593 case FILTER_OP_UNARY_MINUS_DOUBLE
:
594 case FILTER_OP_UNARY_NOT_DOUBLE
:
595 case FILTER_OP_LOAD_FIELD_REF_DOUBLE
:
596 case FILTER_OP_LOAD_DOUBLE
:
597 case FILTER_OP_CAST_DOUBLE_TO_S64
:
598 case FILTER_OP_GET_CONTEXT_REF_DOUBLE
:
600 printk(KERN_WARNING
"unsupported bytecode op %u\n",
601 (unsigned int) *(filter_opcode_t
*) pc
);
608 ret
= bin_op_compare_check(stack
, opcode
, "==");
615 ret
= bin_op_compare_check(stack
, opcode
, "!=");
622 ret
= bin_op_compare_check(stack
, opcode
, ">");
629 ret
= bin_op_compare_check(stack
, opcode
, "<");
636 ret
= bin_op_compare_check(stack
, opcode
, ">=");
643 ret
= bin_op_compare_check(stack
, opcode
, "<=");
649 case FILTER_OP_EQ_STRING
:
650 case FILTER_OP_NE_STRING
:
651 case FILTER_OP_GT_STRING
:
652 case FILTER_OP_LT_STRING
:
653 case FILTER_OP_GE_STRING
:
654 case FILTER_OP_LE_STRING
:
656 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
657 printk(KERN_WARNING
"Empty stack\n");
661 if (vstack_ax(stack
)->type
!= REG_STRING
662 || vstack_bx(stack
)->type
!= REG_STRING
) {
663 printk(KERN_WARNING
"Unexpected register type for string comparator\n");
671 case FILTER_OP_EQ_STAR_GLOB_STRING
:
672 case FILTER_OP_NE_STAR_GLOB_STRING
:
674 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
675 printk(KERN_WARNING
"Empty stack\n");
679 if (vstack_ax(stack
)->type
!= REG_STAR_GLOB_STRING
680 && vstack_bx(stack
)->type
!= REG_STAR_GLOB_STRING
) {
681 printk(KERN_WARNING
"Unexpected register type for globbing pattern comparator\n");
688 case FILTER_OP_EQ_S64
:
689 case FILTER_OP_NE_S64
:
690 case FILTER_OP_GT_S64
:
691 case FILTER_OP_LT_S64
:
692 case FILTER_OP_GE_S64
:
693 case FILTER_OP_LE_S64
:
695 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
696 printk(KERN_WARNING
"Empty stack\n");
700 if (vstack_ax(stack
)->type
!= REG_S64
701 || vstack_bx(stack
)->type
!= REG_S64
) {
702 printk(KERN_WARNING
"Unexpected register type for s64 comparator\n");
709 case FILTER_OP_BIT_RSHIFT
:
710 ret
= bin_op_bitwise_check(stack
, opcode
, ">>");
714 case FILTER_OP_BIT_LSHIFT
:
715 ret
= bin_op_bitwise_check(stack
, opcode
, "<<");
719 case FILTER_OP_BIT_AND
:
720 ret
= bin_op_bitwise_check(stack
, opcode
, "&");
724 case FILTER_OP_BIT_OR
:
725 ret
= bin_op_bitwise_check(stack
, opcode
, "|");
729 case FILTER_OP_BIT_XOR
:
730 ret
= bin_op_bitwise_check(stack
, opcode
, "^");
736 case FILTER_OP_UNARY_PLUS
:
737 case FILTER_OP_UNARY_MINUS
:
738 case FILTER_OP_UNARY_NOT
:
740 if (!vstack_ax(stack
)) {
741 printk(KERN_WARNING
"Empty stack\n");
745 switch (vstack_ax(stack
)->type
) {
748 printk(KERN_WARNING
"unknown register type\n");
753 case REG_STAR_GLOB_STRING
:
754 printk(KERN_WARNING
"Unary op can only be applied to numeric or floating point registers\n");
758 case REG_TYPE_UNKNOWN
:
763 case FILTER_OP_UNARY_BIT_NOT
:
765 if (!vstack_ax(stack
)) {
766 printk(KERN_WARNING
"Empty stack\n");
770 switch (vstack_ax(stack
)->type
) {
772 printk(KERN_WARNING
"unknown register type\n");
777 case REG_STAR_GLOB_STRING
:
779 printk(KERN_WARNING
"Unary bitwise op can only be applied to numeric registers\n");
784 case REG_TYPE_UNKNOWN
:
790 case FILTER_OP_UNARY_PLUS_S64
:
791 case FILTER_OP_UNARY_MINUS_S64
:
792 case FILTER_OP_UNARY_NOT_S64
:
794 if (!vstack_ax(stack
)) {
795 printk(KERN_WARNING
"Empty stack\n");
799 if (vstack_ax(stack
)->type
!= REG_S64
) {
800 printk(KERN_WARNING
"Invalid register type\n");
811 struct logical_op
*insn
= (struct logical_op
*) pc
;
813 if (!vstack_ax(stack
)) {
814 printk(KERN_WARNING
"Empty stack\n");
818 if (vstack_ax(stack
)->type
!= REG_S64
) {
819 printk(KERN_WARNING
"Logical comparator expects S64 register\n");
824 dbg_printk("Validate jumping to bytecode offset %u\n",
825 (unsigned int) insn
->skip_offset
);
826 if (unlikely(start_pc
+ insn
->skip_offset
<= pc
)) {
827 printk(KERN_WARNING
"Loops are not allowed in bytecode\n");
835 case FILTER_OP_LOAD_FIELD_REF
:
837 printk(KERN_WARNING
"Unknown field ref type\n");
841 case FILTER_OP_LOAD_FIELD_REF_STRING
:
842 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE
:
843 case FILTER_OP_LOAD_FIELD_REF_USER_STRING
:
844 case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE
:
846 struct load_op
*insn
= (struct load_op
*) pc
;
847 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
849 dbg_printk("Validate load field ref offset %u type string\n",
853 case FILTER_OP_LOAD_FIELD_REF_S64
:
855 struct load_op
*insn
= (struct load_op
*) pc
;
856 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
858 dbg_printk("Validate load field ref offset %u type s64\n",
863 /* load from immediate operand */
864 case FILTER_OP_LOAD_STRING
:
865 case FILTER_OP_LOAD_STAR_GLOB_STRING
:
870 case FILTER_OP_LOAD_S64
:
875 case FILTER_OP_CAST_TO_S64
:
877 struct cast_op
*insn
= (struct cast_op
*) pc
;
879 if (!vstack_ax(stack
)) {
880 printk(KERN_WARNING
"Empty stack\n");
884 switch (vstack_ax(stack
)->type
) {
887 printk(KERN_WARNING
"unknown register type\n");
892 case REG_STAR_GLOB_STRING
:
893 printk(KERN_WARNING
"Cast op can only be applied to numeric or floating point registers\n");
899 if (insn
->op
== FILTER_OP_CAST_DOUBLE_TO_S64
) {
900 if (vstack_ax(stack
)->type
!= REG_DOUBLE
) {
901 printk(KERN_WARNING
"Cast expects double\n");
908 case FILTER_OP_CAST_NOP
:
913 /* get context ref */
914 case FILTER_OP_GET_CONTEXT_REF
:
916 printk(KERN_WARNING
"Unknown get context ref type\n");
920 case FILTER_OP_GET_CONTEXT_REF_STRING
:
922 struct load_op
*insn
= (struct load_op
*) pc
;
923 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
925 dbg_printk("Validate get context ref offset %u type string\n",
929 case FILTER_OP_GET_CONTEXT_REF_S64
:
931 struct load_op
*insn
= (struct load_op
*) pc
;
932 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
934 dbg_printk("Validate get context ref offset %u type s64\n",
940 * Instructions for recursive traversal through composed types.
942 case FILTER_OP_GET_CONTEXT_ROOT
:
944 dbg_printk("Validate get context root\n");
947 case FILTER_OP_GET_APP_CONTEXT_ROOT
:
949 dbg_printk("Validate get app context root\n");
952 case FILTER_OP_GET_PAYLOAD_ROOT
:
954 dbg_printk("Validate get payload root\n");
957 case FILTER_OP_LOAD_FIELD
:
960 * We tolerate that field type is unknown at validation,
961 * because we are performing the load specialization in
962 * a phase after validation.
964 dbg_printk("Validate load field\n");
969 * Disallow already specialized bytecode op load field instructions to
970 * ensure that the received bytecode does not:
972 * - Read user-space memory without proper get_user accessors,
973 * - Read a memory area larger than the memory targeted by the instrumentation.
975 case FILTER_OP_LOAD_FIELD_S8
:
976 case FILTER_OP_LOAD_FIELD_S16
:
977 case FILTER_OP_LOAD_FIELD_S32
:
978 case FILTER_OP_LOAD_FIELD_S64
:
979 case FILTER_OP_LOAD_FIELD_U8
:
980 case FILTER_OP_LOAD_FIELD_U16
:
981 case FILTER_OP_LOAD_FIELD_U32
:
982 case FILTER_OP_LOAD_FIELD_U64
:
983 case FILTER_OP_LOAD_FIELD_STRING
:
984 case FILTER_OP_LOAD_FIELD_SEQUENCE
:
985 case FILTER_OP_LOAD_FIELD_DOUBLE
:
987 dbg_printk("Validate load field, reject specialized load instruction (%d)\n",
993 case FILTER_OP_GET_SYMBOL
:
995 struct load_op
*insn
= (struct load_op
*) pc
;
996 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
998 dbg_printk("Validate get symbol offset %u\n", sym
->offset
);
1002 case FILTER_OP_GET_SYMBOL_FIELD
:
1004 struct load_op
*insn
= (struct load_op
*) pc
;
1005 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
1007 dbg_printk("Validate get symbol field offset %u\n", sym
->offset
);
1011 case FILTER_OP_GET_INDEX_U16
:
1013 struct load_op
*insn
= (struct load_op
*) pc
;
1014 struct get_index_u16
*get_index
= (struct get_index_u16
*) insn
->data
;
1016 dbg_printk("Validate get index u16 index %u\n", get_index
->index
);
1020 case FILTER_OP_GET_INDEX_U64
:
1022 struct load_op
*insn
= (struct load_op
*) pc
;
1023 struct get_index_u64
*get_index
= (struct get_index_u64
*) insn
->data
;
1025 dbg_printk("Validate get index u64 index %llu\n",
1026 (unsigned long long) get_index
->index
);
1040 int validate_instruction_all_contexts(struct bytecode_runtime
*bytecode
,
1041 struct mp_table
*mp_table
,
1042 struct vstack
*stack
,
1047 unsigned long target_pc
= pc
- start_pc
;
1049 struct hlist_head
*head
;
1050 struct mp_node
*mp_node
;
1052 /* Validate the context resulting from the previous instruction */
1053 ret
= validate_instruction_context(bytecode
, stack
, start_pc
, pc
);
1057 /* Validate merge points */
1058 hash
= jhash_1word(target_pc
, 0);
1059 head
= &mp_table
->mp_head
[hash
& (MERGE_POINT_TABLE_SIZE
- 1)];
1060 lttng_hlist_for_each_entry(mp_node
, head
, node
) {
1061 if (lttng_hash_match(mp_node
, target_pc
)) {
1067 dbg_printk("Filter: validate merge point at offset %lu\n",
1069 if (merge_points_compare(stack
, &mp_node
->stack
)) {
1070 printk(KERN_WARNING
"Merge points differ for offset %lu\n",
1074 /* Once validated, we can remove the merge point */
1075 dbg_printk("Filter: remove merge point at offset %lu\n",
1077 hlist_del(&mp_node
->node
);
1083 * Validate load instructions: specialized instructions not accepted as input.
1086 * >0: going to next insn.
1087 * 0: success, stop iteration.
1091 int validate_load(char **_next_pc
,
1095 char *next_pc
= *_next_pc
;
1097 switch (*(filter_opcode_t
*) pc
) {
1098 case FILTER_OP_UNKNOWN
:
1101 printk(KERN_WARNING
"LTTng: bytecode: unknown bytecode op %u\n",
1102 (unsigned int) *(filter_opcode_t
*) pc
);
1107 case FILTER_OP_RETURN
:
1109 next_pc
+= sizeof(struct return_op
);
1113 case FILTER_OP_RETURN_S64
:
1115 next_pc
+= sizeof(struct return_op
);
1123 case FILTER_OP_PLUS
:
1124 case FILTER_OP_MINUS
:
1125 /* Floating point */
1126 case FILTER_OP_EQ_DOUBLE
:
1127 case FILTER_OP_NE_DOUBLE
:
1128 case FILTER_OP_GT_DOUBLE
:
1129 case FILTER_OP_LT_DOUBLE
:
1130 case FILTER_OP_GE_DOUBLE
:
1131 case FILTER_OP_LE_DOUBLE
:
1132 case FILTER_OP_EQ_DOUBLE_S64
:
1133 case FILTER_OP_NE_DOUBLE_S64
:
1134 case FILTER_OP_GT_DOUBLE_S64
:
1135 case FILTER_OP_LT_DOUBLE_S64
:
1136 case FILTER_OP_GE_DOUBLE_S64
:
1137 case FILTER_OP_LE_DOUBLE_S64
:
1138 case FILTER_OP_EQ_S64_DOUBLE
:
1139 case FILTER_OP_NE_S64_DOUBLE
:
1140 case FILTER_OP_GT_S64_DOUBLE
:
1141 case FILTER_OP_LT_S64_DOUBLE
:
1142 case FILTER_OP_GE_S64_DOUBLE
:
1143 case FILTER_OP_LE_S64_DOUBLE
:
1144 case FILTER_OP_UNARY_PLUS_DOUBLE
:
1145 case FILTER_OP_UNARY_MINUS_DOUBLE
:
1146 case FILTER_OP_UNARY_NOT_DOUBLE
:
1147 case FILTER_OP_LOAD_FIELD_REF_DOUBLE
:
1148 case FILTER_OP_GET_CONTEXT_REF_DOUBLE
:
1149 case FILTER_OP_LOAD_DOUBLE
:
1150 case FILTER_OP_CAST_DOUBLE_TO_S64
:
1152 printk(KERN_WARNING
"LTTng: bytecode: unsupported bytecode op %u\n",
1153 (unsigned int) *(filter_opcode_t
*) pc
);
1164 case FILTER_OP_EQ_STRING
:
1165 case FILTER_OP_NE_STRING
:
1166 case FILTER_OP_GT_STRING
:
1167 case FILTER_OP_LT_STRING
:
1168 case FILTER_OP_GE_STRING
:
1169 case FILTER_OP_LE_STRING
:
1170 case FILTER_OP_EQ_STAR_GLOB_STRING
:
1171 case FILTER_OP_NE_STAR_GLOB_STRING
:
1172 case FILTER_OP_EQ_S64
:
1173 case FILTER_OP_NE_S64
:
1174 case FILTER_OP_GT_S64
:
1175 case FILTER_OP_LT_S64
:
1176 case FILTER_OP_GE_S64
:
1177 case FILTER_OP_LE_S64
:
1178 case FILTER_OP_BIT_RSHIFT
:
1179 case FILTER_OP_BIT_LSHIFT
:
1180 case FILTER_OP_BIT_AND
:
1181 case FILTER_OP_BIT_OR
:
1182 case FILTER_OP_BIT_XOR
:
1184 next_pc
+= sizeof(struct binary_op
);
1189 case FILTER_OP_UNARY_PLUS
:
1190 case FILTER_OP_UNARY_MINUS
:
1191 case FILTER_OP_UNARY_PLUS_S64
:
1192 case FILTER_OP_UNARY_MINUS_S64
:
1193 case FILTER_OP_UNARY_NOT_S64
:
1194 case FILTER_OP_UNARY_NOT
:
1195 case FILTER_OP_UNARY_BIT_NOT
:
1197 next_pc
+= sizeof(struct unary_op
);
1205 next_pc
+= sizeof(struct logical_op
);
1209 /* load field ref */
1210 case FILTER_OP_LOAD_FIELD_REF
:
1211 /* get context ref */
1212 case FILTER_OP_GET_CONTEXT_REF
:
1214 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1217 case FILTER_OP_LOAD_FIELD_REF_STRING
:
1218 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE
:
1219 case FILTER_OP_GET_CONTEXT_REF_STRING
:
1220 case FILTER_OP_LOAD_FIELD_REF_USER_STRING
:
1221 case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE
:
1222 case FILTER_OP_LOAD_FIELD_REF_S64
:
1223 case FILTER_OP_GET_CONTEXT_REF_S64
:
1226 * Reject specialized load field ref instructions.
1232 /* load from immediate operand */
1233 case FILTER_OP_LOAD_STRING
:
1234 case FILTER_OP_LOAD_STAR_GLOB_STRING
:
1236 struct load_op
*insn
= (struct load_op
*) pc
;
1238 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1242 case FILTER_OP_LOAD_S64
:
1244 next_pc
+= sizeof(struct load_op
) + sizeof(struct literal_numeric
);
1248 case FILTER_OP_CAST_TO_S64
:
1249 case FILTER_OP_CAST_NOP
:
1251 next_pc
+= sizeof(struct cast_op
);
1256 * Instructions for recursive traversal through composed types.
1258 case FILTER_OP_GET_CONTEXT_ROOT
:
1259 case FILTER_OP_GET_APP_CONTEXT_ROOT
:
1260 case FILTER_OP_GET_PAYLOAD_ROOT
:
1261 case FILTER_OP_LOAD_FIELD
:
1263 next_pc
+= sizeof(struct load_op
);
1267 case FILTER_OP_LOAD_FIELD_S8
:
1268 case FILTER_OP_LOAD_FIELD_S16
:
1269 case FILTER_OP_LOAD_FIELD_S32
:
1270 case FILTER_OP_LOAD_FIELD_S64
:
1271 case FILTER_OP_LOAD_FIELD_U8
:
1272 case FILTER_OP_LOAD_FIELD_U16
:
1273 case FILTER_OP_LOAD_FIELD_U32
:
1274 case FILTER_OP_LOAD_FIELD_U64
:
1275 case FILTER_OP_LOAD_FIELD_STRING
:
1276 case FILTER_OP_LOAD_FIELD_SEQUENCE
:
1277 case FILTER_OP_LOAD_FIELD_DOUBLE
:
1280 * Reject specialized load field instructions.
1286 case FILTER_OP_GET_SYMBOL
:
1287 case FILTER_OP_GET_SYMBOL_FIELD
:
1289 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_symbol
);
1293 case FILTER_OP_GET_INDEX_U16
:
1295 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u16
);
1299 case FILTER_OP_GET_INDEX_U64
:
1301 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u64
);
1307 *_next_pc
= next_pc
;
1313 * >0: going to next insn.
1314 * 0: success, stop iteration.
1318 int exec_insn(struct bytecode_runtime
*bytecode
,
1319 struct mp_table
*mp_table
,
1320 struct vstack
*stack
,
1325 char *next_pc
= *_next_pc
;
1327 switch (*(filter_opcode_t
*) pc
) {
1328 case FILTER_OP_UNKNOWN
:
1331 printk(KERN_WARNING
"unknown bytecode op %u\n",
1332 (unsigned int) *(filter_opcode_t
*) pc
);
1337 case FILTER_OP_RETURN
:
1339 if (!vstack_ax(stack
)) {
1340 printk(KERN_WARNING
"Empty stack\n");
1344 switch (vstack_ax(stack
)->type
) {
1346 case REG_TYPE_UNKNOWN
:
1349 printk(KERN_WARNING
"Unexpected register type %d at end of bytecode\n",
1350 (int) vstack_ax(stack
)->type
);
1359 case FILTER_OP_RETURN_S64
:
1361 if (!vstack_ax(stack
)) {
1362 printk(KERN_WARNING
"Empty stack\n");
1366 switch (vstack_ax(stack
)->type
) {
1370 case REG_TYPE_UNKNOWN
:
1371 printk(KERN_WARNING
"Unexpected register type %d at end of bytecode\n",
1372 (int) vstack_ax(stack
)->type
);
1385 case FILTER_OP_PLUS
:
1386 case FILTER_OP_MINUS
:
1387 /* Floating point */
1388 case FILTER_OP_EQ_DOUBLE
:
1389 case FILTER_OP_NE_DOUBLE
:
1390 case FILTER_OP_GT_DOUBLE
:
1391 case FILTER_OP_LT_DOUBLE
:
1392 case FILTER_OP_GE_DOUBLE
:
1393 case FILTER_OP_LE_DOUBLE
:
1394 case FILTER_OP_EQ_DOUBLE_S64
:
1395 case FILTER_OP_NE_DOUBLE_S64
:
1396 case FILTER_OP_GT_DOUBLE_S64
:
1397 case FILTER_OP_LT_DOUBLE_S64
:
1398 case FILTER_OP_GE_DOUBLE_S64
:
1399 case FILTER_OP_LE_DOUBLE_S64
:
1400 case FILTER_OP_EQ_S64_DOUBLE
:
1401 case FILTER_OP_NE_S64_DOUBLE
:
1402 case FILTER_OP_GT_S64_DOUBLE
:
1403 case FILTER_OP_LT_S64_DOUBLE
:
1404 case FILTER_OP_GE_S64_DOUBLE
:
1405 case FILTER_OP_LE_S64_DOUBLE
:
1406 case FILTER_OP_UNARY_PLUS_DOUBLE
:
1407 case FILTER_OP_UNARY_MINUS_DOUBLE
:
1408 case FILTER_OP_UNARY_NOT_DOUBLE
:
1409 case FILTER_OP_LOAD_FIELD_REF_DOUBLE
:
1410 case FILTER_OP_GET_CONTEXT_REF_DOUBLE
:
1411 case FILTER_OP_LOAD_DOUBLE
:
1412 case FILTER_OP_CAST_DOUBLE_TO_S64
:
1414 printk(KERN_WARNING
"unsupported bytecode op %u\n",
1415 (unsigned int) *(filter_opcode_t
*) pc
);
1426 case FILTER_OP_EQ_STRING
:
1427 case FILTER_OP_NE_STRING
:
1428 case FILTER_OP_GT_STRING
:
1429 case FILTER_OP_LT_STRING
:
1430 case FILTER_OP_GE_STRING
:
1431 case FILTER_OP_LE_STRING
:
1432 case FILTER_OP_EQ_STAR_GLOB_STRING
:
1433 case FILTER_OP_NE_STAR_GLOB_STRING
:
1434 case FILTER_OP_EQ_S64
:
1435 case FILTER_OP_NE_S64
:
1436 case FILTER_OP_GT_S64
:
1437 case FILTER_OP_LT_S64
:
1438 case FILTER_OP_GE_S64
:
1439 case FILTER_OP_LE_S64
:
1440 case FILTER_OP_BIT_RSHIFT
:
1441 case FILTER_OP_BIT_LSHIFT
:
1442 case FILTER_OP_BIT_AND
:
1443 case FILTER_OP_BIT_OR
:
1444 case FILTER_OP_BIT_XOR
:
1447 if (vstack_pop(stack
)) {
1451 if (!vstack_ax(stack
)) {
1452 printk(KERN_WARNING
"Empty stack\n");
1456 switch (vstack_ax(stack
)->type
) {
1460 case REG_STAR_GLOB_STRING
:
1461 case REG_TYPE_UNKNOWN
:
1464 printk(KERN_WARNING
"Unexpected register type %d for operation\n",
1465 (int) vstack_ax(stack
)->type
);
1470 vstack_ax(stack
)->type
= REG_S64
;
1471 next_pc
+= sizeof(struct binary_op
);
1476 case FILTER_OP_UNARY_PLUS
:
1477 case FILTER_OP_UNARY_MINUS
:
1480 if (!vstack_ax(stack
)) {
1481 printk(KERN_WARNING
"Empty stack\n\n");
1485 switch (vstack_ax(stack
)->type
) {
1487 case REG_TYPE_UNKNOWN
:
1490 printk(KERN_WARNING
"Unexpected register type %d for operation\n",
1491 (int) vstack_ax(stack
)->type
);
1496 vstack_ax(stack
)->type
= REG_TYPE_UNKNOWN
;
1497 next_pc
+= sizeof(struct unary_op
);
1501 case FILTER_OP_UNARY_PLUS_S64
:
1502 case FILTER_OP_UNARY_MINUS_S64
:
1503 case FILTER_OP_UNARY_NOT_S64
:
1506 if (!vstack_ax(stack
)) {
1507 printk(KERN_WARNING
"Empty stack\n\n");
1511 switch (vstack_ax(stack
)->type
) {
1515 printk(KERN_WARNING
"Unexpected register type %d for operation\n",
1516 (int) vstack_ax(stack
)->type
);
1521 vstack_ax(stack
)->type
= REG_S64
;
1522 next_pc
+= sizeof(struct unary_op
);
1526 case FILTER_OP_UNARY_NOT
:
1529 if (!vstack_ax(stack
)) {
1530 printk(KERN_WARNING
"Empty stack\n\n");
1534 switch (vstack_ax(stack
)->type
) {
1536 case REG_TYPE_UNKNOWN
:
1539 printk(KERN_WARNING
"Unexpected register type %d for operation\n",
1540 (int) vstack_ax(stack
)->type
);
1545 vstack_ax(stack
)->type
= REG_S64
;
1546 next_pc
+= sizeof(struct unary_op
);
1550 case FILTER_OP_UNARY_BIT_NOT
:
1553 if (!vstack_ax(stack
)) {
1554 printk(KERN_WARNING
"Empty stack\n");
1558 switch (vstack_ax(stack
)->type
) {
1560 case REG_TYPE_UNKNOWN
:
1564 printk(KERN_WARNING
"Unexpected register type %d for operation\n",
1565 (int) vstack_ax(stack
)->type
);
1570 vstack_ax(stack
)->type
= REG_S64
;
1571 next_pc
+= sizeof(struct unary_op
);
1579 struct logical_op
*insn
= (struct logical_op
*) pc
;
1582 /* Add merge point to table */
1583 merge_ret
= merge_point_add_check(mp_table
,
1584 insn
->skip_offset
, stack
);
1590 if (!vstack_ax(stack
)) {
1591 printk(KERN_WARNING
"Empty stack\n\n");
1595 /* There is always a cast-to-s64 operation before a or/and op. */
1596 switch (vstack_ax(stack
)->type
) {
1600 printk(KERN_WARNING
"Incorrect register type %d for operation\n",
1601 (int) vstack_ax(stack
)->type
);
1606 /* Continue to next instruction */
1607 /* Pop 1 when jump not taken */
1608 if (vstack_pop(stack
)) {
1612 next_pc
+= sizeof(struct logical_op
);
1616 /* load field ref */
1617 case FILTER_OP_LOAD_FIELD_REF
:
1619 printk(KERN_WARNING
"Unknown field ref type\n");
1623 /* get context ref */
1624 case FILTER_OP_GET_CONTEXT_REF
:
1626 printk(KERN_WARNING
"Unknown get context ref type\n");
1630 case FILTER_OP_LOAD_FIELD_REF_STRING
:
1631 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE
:
1632 case FILTER_OP_GET_CONTEXT_REF_STRING
:
1633 case FILTER_OP_LOAD_FIELD_REF_USER_STRING
:
1634 case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE
:
1636 if (vstack_push(stack
)) {
1640 vstack_ax(stack
)->type
= REG_STRING
;
1641 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1644 case FILTER_OP_LOAD_FIELD_REF_S64
:
1645 case FILTER_OP_GET_CONTEXT_REF_S64
:
1647 if (vstack_push(stack
)) {
1651 vstack_ax(stack
)->type
= REG_S64
;
1652 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1656 /* load from immediate operand */
1657 case FILTER_OP_LOAD_STRING
:
1659 struct load_op
*insn
= (struct load_op
*) pc
;
1661 if (vstack_push(stack
)) {
1665 vstack_ax(stack
)->type
= REG_STRING
;
1666 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1670 case FILTER_OP_LOAD_STAR_GLOB_STRING
:
1672 struct load_op
*insn
= (struct load_op
*) pc
;
1674 if (vstack_push(stack
)) {
1678 vstack_ax(stack
)->type
= REG_STAR_GLOB_STRING
;
1679 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1683 case FILTER_OP_LOAD_S64
:
1685 if (vstack_push(stack
)) {
1689 vstack_ax(stack
)->type
= REG_S64
;
1690 next_pc
+= sizeof(struct load_op
)
1691 + sizeof(struct literal_numeric
);
1695 case FILTER_OP_CAST_TO_S64
:
1698 if (!vstack_ax(stack
)) {
1699 printk(KERN_WARNING
"Empty stack\n");
1703 switch (vstack_ax(stack
)->type
) {
1706 case REG_TYPE_UNKNOWN
:
1709 printk(KERN_WARNING
"Incorrect register type %d for cast\n",
1710 (int) vstack_ax(stack
)->type
);
1714 vstack_ax(stack
)->type
= REG_S64
;
1715 next_pc
+= sizeof(struct cast_op
);
1718 case FILTER_OP_CAST_NOP
:
1720 next_pc
+= sizeof(struct cast_op
);
1725 * Instructions for recursive traversal through composed types.
1727 case FILTER_OP_GET_CONTEXT_ROOT
:
1728 case FILTER_OP_GET_APP_CONTEXT_ROOT
:
1729 case FILTER_OP_GET_PAYLOAD_ROOT
:
1731 if (vstack_push(stack
)) {
1735 vstack_ax(stack
)->type
= REG_PTR
;
1736 next_pc
+= sizeof(struct load_op
);
1740 case FILTER_OP_LOAD_FIELD
:
1743 if (!vstack_ax(stack
)) {
1744 printk(KERN_WARNING
"Empty stack\n\n");
1748 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1749 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1753 vstack_ax(stack
)->type
= REG_TYPE_UNKNOWN
;
1754 next_pc
+= sizeof(struct load_op
);
1758 case FILTER_OP_LOAD_FIELD_S8
:
1759 case FILTER_OP_LOAD_FIELD_S16
:
1760 case FILTER_OP_LOAD_FIELD_S32
:
1761 case FILTER_OP_LOAD_FIELD_S64
:
1762 case FILTER_OP_LOAD_FIELD_U8
:
1763 case FILTER_OP_LOAD_FIELD_U16
:
1764 case FILTER_OP_LOAD_FIELD_U32
:
1765 case FILTER_OP_LOAD_FIELD_U64
:
1768 if (!vstack_ax(stack
)) {
1769 printk(KERN_WARNING
"Empty stack\n\n");
1773 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1774 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1778 vstack_ax(stack
)->type
= REG_S64
;
1779 next_pc
+= sizeof(struct load_op
);
1783 case FILTER_OP_LOAD_FIELD_STRING
:
1784 case FILTER_OP_LOAD_FIELD_SEQUENCE
:
1787 if (!vstack_ax(stack
)) {
1788 printk(KERN_WARNING
"Empty stack\n\n");
1792 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1793 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1797 vstack_ax(stack
)->type
= REG_STRING
;
1798 next_pc
+= sizeof(struct load_op
);
1802 case FILTER_OP_LOAD_FIELD_DOUBLE
:
1805 if (!vstack_ax(stack
)) {
1806 printk(KERN_WARNING
"Empty stack\n\n");
1810 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1811 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1815 vstack_ax(stack
)->type
= REG_DOUBLE
;
1816 next_pc
+= sizeof(struct load_op
);
1820 case FILTER_OP_GET_SYMBOL
:
1821 case FILTER_OP_GET_SYMBOL_FIELD
:
1824 if (!vstack_ax(stack
)) {
1825 printk(KERN_WARNING
"Empty stack\n\n");
1829 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1830 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1834 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_symbol
);
1838 case FILTER_OP_GET_INDEX_U16
:
1841 if (!vstack_ax(stack
)) {
1842 printk(KERN_WARNING
"Empty stack\n\n");
1846 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1847 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1851 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u16
);
1855 case FILTER_OP_GET_INDEX_U64
:
1858 if (!vstack_ax(stack
)) {
1859 printk(KERN_WARNING
"Empty stack\n\n");
1863 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1864 printk(KERN_WARNING
"Expecting pointer on top of stack\n\n");
1868 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u64
);
1874 *_next_pc
= next_pc
;
1878 int lttng_filter_validate_bytecode_load(struct bytecode_runtime
*bytecode
)
1880 char *pc
, *next_pc
, *start_pc
;
1883 start_pc
= &bytecode
->code
[0];
1884 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
1886 ret
= bytecode_validate_overflow(bytecode
, start_pc
, pc
);
1889 printk(KERN_WARNING
"LTTng: bytecode: bytecode overflow\n");
1892 dbg_printk("Validating loads: op %s (%u)\n",
1893 lttng_filter_print_op((unsigned int) *(filter_opcode_t
*) pc
),
1894 (unsigned int) *(filter_opcode_t
*) pc
);
1896 ret
= validate_load(&next_pc
, pc
);
1905 * Never called concurrently (hash seed is shared).
1907 int lttng_filter_validate_bytecode(struct bytecode_runtime
*bytecode
)
1909 struct mp_table
*mp_table
;
1910 char *pc
, *next_pc
, *start_pc
;
1912 struct vstack stack
;
1914 vstack_init(&stack
);
1916 mp_table
= kzalloc(sizeof(*mp_table
), GFP_KERNEL
);
1918 printk(KERN_WARNING
"Error allocating hash table for bytecode validation\n");
1921 start_pc
= &bytecode
->code
[0];
1922 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
1924 ret
= bytecode_validate_overflow(bytecode
, start_pc
, pc
);
1927 printk(KERN_WARNING
"filter bytecode overflow\n");
1930 dbg_printk("Validating op %s (%u)\n",
1931 lttng_filter_print_op((unsigned int) *(filter_opcode_t
*) pc
),
1932 (unsigned int) *(filter_opcode_t
*) pc
);
1935 * For each instruction, validate the current context
1936 * (traversal of entire execution flow), and validate
1937 * all merge points targeting this instruction.
1939 ret
= validate_instruction_all_contexts(bytecode
, mp_table
,
1940 &stack
, start_pc
, pc
);
1943 ret
= exec_insn(bytecode
, mp_table
, &stack
, &next_pc
, pc
);
1948 if (delete_all_nodes(mp_table
)) {
1950 printk(KERN_WARNING
"Unexpected merge points\n");