2 * SPDX-License-Identifier: MIT
4 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 * LTTng UST bytecode validator.
14 #include "rculfhash.h"
16 #include "lttng-bytecode.h"
17 #include "common/hash.h"
18 #include "string-utils.h"
19 #include "lib/lttng-ust/events.h"
20 #include "common/macros.h"
23 * Number of merge points for hash table size. Hash table initialized to
24 * that size, and we do not resize, because we do not want to trigger
25 * RCU worker thread execution: fall-back on linear traversal if number
26 * of merge points exceeds this value.
28 #define DEFAULT_NR_MERGE_POINTS 128
29 #define MIN_NR_BUCKETS 128
30 #define MAX_NR_BUCKETS 128
32 /* merge point table node */
34 struct lttng_ust_lfht_node node
;
36 /* Context at merge point */
38 unsigned long target_pc
;
41 static unsigned long lttng_hash_seed
;
42 static unsigned int lttng_hash_seed_ready
;
45 int lttng_hash_match(struct lttng_ust_lfht_node
*node
, const void *key
)
47 struct lfht_mp_node
*mp_node
=
48 caa_container_of(node
, struct lfht_mp_node
, node
);
49 unsigned long key_pc
= (unsigned long) key
;
51 if (mp_node
->target_pc
== key_pc
)
58 int merge_points_compare(const struct vstack
*stacka
,
59 const struct vstack
*stackb
)
63 if (stacka
->top
!= stackb
->top
)
65 len
= stacka
->top
+ 1;
67 for (i
= 0; i
< len
; i
++) {
68 if (stacka
->e
[i
].type
!= REG_UNKNOWN
69 && stackb
->e
[i
].type
!= REG_UNKNOWN
70 && stacka
->e
[i
].type
!= stackb
->e
[i
].type
)
77 int merge_point_add_check(struct lttng_ust_lfht
*ht
, unsigned long target_pc
,
78 const struct vstack
*stack
)
80 struct lfht_mp_node
*node
;
81 unsigned long hash
= lttng_hash_mix((const char *) target_pc
,
84 struct lttng_ust_lfht_node
*ret
;
86 dbg_printf("Bytecode: adding merge point at offset %lu, hash %lu\n",
88 node
= zmalloc(sizeof(struct lfht_mp_node
));
91 node
->target_pc
= target_pc
;
92 memcpy(&node
->stack
, stack
, sizeof(node
->stack
));
93 ret
= lttng_ust_lfht_add_unique(ht
, hash
, lttng_hash_match
,
94 (const char *) target_pc
, &node
->node
);
95 if (ret
!= &node
->node
) {
96 struct lfht_mp_node
*ret_mp
=
97 caa_container_of(ret
, struct lfht_mp_node
, node
);
99 /* Key already present */
100 dbg_printf("Bytecode: compare merge points for offset %lu, hash %lu\n",
103 if (merge_points_compare(stack
, &ret_mp
->stack
)) {
104 ERR("Merge points differ for offset %lu\n",
113 * Binary comparators use top of stack and top of stack -1.
114 * Return 0 if typing is known to match, 1 if typing is dynamic
115 * (unknown), negative error value on error.
118 int bin_op_compare_check(struct vstack
*stack
, bytecode_opcode_t opcode
,
121 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
124 switch (vstack_ax(stack
)->type
) {
131 switch (vstack_bx(stack
)->type
) {
139 case REG_STAR_GLOB_STRING
:
140 if (opcode
!= BYTECODE_OP_EQ
&& opcode
!= BYTECODE_OP_NE
) {
150 case REG_STAR_GLOB_STRING
:
151 switch (vstack_bx(stack
)->type
) {
158 if (opcode
!= BYTECODE_OP_EQ
&& opcode
!= BYTECODE_OP_NE
) {
162 case REG_STAR_GLOB_STRING
:
172 switch (vstack_bx(stack
)->type
) {
179 case REG_STAR_GLOB_STRING
:
194 ERR("type mismatch for '%s' binary operator\n", str
);
198 ERR("empty stack for '%s' binary operator\n", str
);
202 ERR("unknown type for '%s' binary operator\n", str
);
207 * Binary bitwise operators use top of stack and top of stack -1.
208 * Return 0 if typing is known to match, 1 if typing is dynamic
209 * (unknown), negative error value on error.
212 int bin_op_bitwise_check(struct vstack
*stack
,
213 bytecode_opcode_t opcode
__attribute__((unused
)),
216 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
219 switch (vstack_ax(stack
)->type
) {
227 switch (vstack_bx(stack
)->type
) {
245 ERR("empty stack for '%s' binary operator\n", str
);
249 ERR("unknown type for '%s' binary operator\n", str
);
254 int validate_get_symbol(struct bytecode_runtime
*bytecode
,
255 const struct get_symbol
*sym
)
257 const char *str
, *str_limit
;
260 if (sym
->offset
>= bytecode
->p
.bc
->bc
.len
- bytecode
->p
.bc
->bc
.reloc_offset
)
263 str
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.reloc_offset
+ sym
->offset
;
264 str_limit
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.len
;
265 len_limit
= str_limit
- str
;
266 if (strnlen(str
, len_limit
) == len_limit
)
272 * Validate bytecode range overflow within the validation pass.
273 * Called for each instruction encountered.
276 int bytecode_validate_overflow(struct bytecode_runtime
*bytecode
,
277 char *start_pc
, char *pc
)
281 switch (*(bytecode_opcode_t
*) pc
) {
282 case BYTECODE_OP_UNKNOWN
:
285 ERR("unknown bytecode op %u\n",
286 (unsigned int) *(bytecode_opcode_t
*) pc
);
291 case BYTECODE_OP_RETURN
:
292 case BYTECODE_OP_RETURN_S64
:
294 if (unlikely(pc
+ sizeof(struct return_op
)
295 > start_pc
+ bytecode
->len
)) {
302 case BYTECODE_OP_MUL
:
303 case BYTECODE_OP_DIV
:
304 case BYTECODE_OP_MOD
:
305 case BYTECODE_OP_PLUS
:
306 case BYTECODE_OP_MINUS
:
308 ERR("unsupported bytecode op %u\n",
309 (unsigned int) *(bytecode_opcode_t
*) pc
);
320 case BYTECODE_OP_EQ_STRING
:
321 case BYTECODE_OP_NE_STRING
:
322 case BYTECODE_OP_GT_STRING
:
323 case BYTECODE_OP_LT_STRING
:
324 case BYTECODE_OP_GE_STRING
:
325 case BYTECODE_OP_LE_STRING
:
326 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
327 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
328 case BYTECODE_OP_EQ_S64
:
329 case BYTECODE_OP_NE_S64
:
330 case BYTECODE_OP_GT_S64
:
331 case BYTECODE_OP_LT_S64
:
332 case BYTECODE_OP_GE_S64
:
333 case BYTECODE_OP_LE_S64
:
334 case BYTECODE_OP_EQ_DOUBLE
:
335 case BYTECODE_OP_NE_DOUBLE
:
336 case BYTECODE_OP_GT_DOUBLE
:
337 case BYTECODE_OP_LT_DOUBLE
:
338 case BYTECODE_OP_GE_DOUBLE
:
339 case BYTECODE_OP_LE_DOUBLE
:
340 case BYTECODE_OP_EQ_DOUBLE_S64
:
341 case BYTECODE_OP_NE_DOUBLE_S64
:
342 case BYTECODE_OP_GT_DOUBLE_S64
:
343 case BYTECODE_OP_LT_DOUBLE_S64
:
344 case BYTECODE_OP_GE_DOUBLE_S64
:
345 case BYTECODE_OP_LE_DOUBLE_S64
:
346 case BYTECODE_OP_EQ_S64_DOUBLE
:
347 case BYTECODE_OP_NE_S64_DOUBLE
:
348 case BYTECODE_OP_GT_S64_DOUBLE
:
349 case BYTECODE_OP_LT_S64_DOUBLE
:
350 case BYTECODE_OP_GE_S64_DOUBLE
:
351 case BYTECODE_OP_LE_S64_DOUBLE
:
352 case BYTECODE_OP_BIT_RSHIFT
:
353 case BYTECODE_OP_BIT_LSHIFT
:
354 case BYTECODE_OP_BIT_AND
:
355 case BYTECODE_OP_BIT_OR
:
356 case BYTECODE_OP_BIT_XOR
:
358 if (unlikely(pc
+ sizeof(struct binary_op
)
359 > start_pc
+ bytecode
->len
)) {
366 case BYTECODE_OP_UNARY_PLUS
:
367 case BYTECODE_OP_UNARY_MINUS
:
368 case BYTECODE_OP_UNARY_NOT
:
369 case BYTECODE_OP_UNARY_PLUS_S64
:
370 case BYTECODE_OP_UNARY_MINUS_S64
:
371 case BYTECODE_OP_UNARY_NOT_S64
:
372 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
373 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
374 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
375 case BYTECODE_OP_UNARY_BIT_NOT
:
377 if (unlikely(pc
+ sizeof(struct unary_op
)
378 > start_pc
+ bytecode
->len
)) {
385 case BYTECODE_OP_AND
:
388 if (unlikely(pc
+ sizeof(struct logical_op
)
389 > start_pc
+ bytecode
->len
)) {
396 case BYTECODE_OP_LOAD_FIELD_REF
:
398 ERR("Unknown field ref type\n");
403 /* get context ref */
404 case BYTECODE_OP_GET_CONTEXT_REF
:
405 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
406 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
407 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
408 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
409 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
410 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
411 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
413 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct field_ref
)
414 > start_pc
+ bytecode
->len
)) {
420 /* load from immediate operand */
421 case BYTECODE_OP_LOAD_STRING
:
422 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
424 struct load_op
*insn
= (struct load_op
*) pc
;
425 uint32_t str_len
, maxlen
;
427 if (unlikely(pc
+ sizeof(struct load_op
)
428 > start_pc
+ bytecode
->len
)) {
433 maxlen
= start_pc
+ bytecode
->len
- pc
- sizeof(struct load_op
);
434 str_len
= strnlen(insn
->data
, maxlen
);
435 if (unlikely(str_len
>= maxlen
)) {
436 /* Final '\0' not found within range */
442 case BYTECODE_OP_LOAD_S64
:
444 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct literal_numeric
)
445 > start_pc
+ bytecode
->len
)) {
451 case BYTECODE_OP_LOAD_DOUBLE
:
453 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct literal_double
)
454 > start_pc
+ bytecode
->len
)) {
460 case BYTECODE_OP_CAST_TO_S64
:
461 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
462 case BYTECODE_OP_CAST_NOP
:
464 if (unlikely(pc
+ sizeof(struct cast_op
)
465 > start_pc
+ bytecode
->len
)) {
472 * Instructions for recursive traversal through composed types.
474 case BYTECODE_OP_GET_CONTEXT_ROOT
:
475 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
476 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
477 case BYTECODE_OP_LOAD_FIELD
:
478 case BYTECODE_OP_LOAD_FIELD_S8
:
479 case BYTECODE_OP_LOAD_FIELD_S16
:
480 case BYTECODE_OP_LOAD_FIELD_S32
:
481 case BYTECODE_OP_LOAD_FIELD_S64
:
482 case BYTECODE_OP_LOAD_FIELD_U8
:
483 case BYTECODE_OP_LOAD_FIELD_U16
:
484 case BYTECODE_OP_LOAD_FIELD_U32
:
485 case BYTECODE_OP_LOAD_FIELD_U64
:
486 case BYTECODE_OP_LOAD_FIELD_STRING
:
487 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
488 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
489 if (unlikely(pc
+ sizeof(struct load_op
)
490 > start_pc
+ bytecode
->len
)) {
495 case BYTECODE_OP_GET_SYMBOL
:
497 struct load_op
*insn
= (struct load_op
*) pc
;
498 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
500 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_symbol
)
501 > start_pc
+ bytecode
->len
)) {
505 ret
= validate_get_symbol(bytecode
, sym
);
509 case BYTECODE_OP_GET_SYMBOL_FIELD
:
510 ERR("Unexpected get symbol field");
514 case BYTECODE_OP_GET_INDEX_U16
:
515 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u16
)
516 > start_pc
+ bytecode
->len
)) {
521 case BYTECODE_OP_GET_INDEX_U64
:
522 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u64
)
523 > start_pc
+ bytecode
->len
)) {
533 unsigned long delete_all_nodes(struct lttng_ust_lfht
*ht
)
535 struct lttng_ust_lfht_iter iter
;
536 struct lfht_mp_node
*node
;
537 unsigned long nr_nodes
= 0;
539 lttng_ust_lfht_for_each_entry(ht
, &iter
, node
, node
) {
542 ret
= lttng_ust_lfht_del(ht
, lttng_ust_lfht_iter_get_node(&iter
));
544 /* note: this hash table is never used concurrently */
557 int validate_instruction_context(
558 struct bytecode_runtime
*bytecode
__attribute__((unused
)),
559 struct vstack
*stack
,
564 const bytecode_opcode_t opcode
= *(bytecode_opcode_t
*) pc
;
567 case BYTECODE_OP_UNKNOWN
:
570 ERR("unknown bytecode op %u\n",
571 (unsigned int) *(bytecode_opcode_t
*) pc
);
576 case BYTECODE_OP_RETURN
:
577 case BYTECODE_OP_RETURN_S64
:
583 case BYTECODE_OP_MUL
:
584 case BYTECODE_OP_DIV
:
585 case BYTECODE_OP_MOD
:
586 case BYTECODE_OP_PLUS
:
587 case BYTECODE_OP_MINUS
:
589 ERR("unsupported bytecode op %u\n",
590 (unsigned int) opcode
);
597 ret
= bin_op_compare_check(stack
, opcode
, "==");
604 ret
= bin_op_compare_check(stack
, opcode
, "!=");
611 ret
= bin_op_compare_check(stack
, opcode
, ">");
618 ret
= bin_op_compare_check(stack
, opcode
, "<");
625 ret
= bin_op_compare_check(stack
, opcode
, ">=");
632 ret
= bin_op_compare_check(stack
, opcode
, "<=");
638 case BYTECODE_OP_EQ_STRING
:
639 case BYTECODE_OP_NE_STRING
:
640 case BYTECODE_OP_GT_STRING
:
641 case BYTECODE_OP_LT_STRING
:
642 case BYTECODE_OP_GE_STRING
:
643 case BYTECODE_OP_LE_STRING
:
645 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
646 ERR("Empty stack\n");
650 if (vstack_ax(stack
)->type
!= REG_STRING
651 || vstack_bx(stack
)->type
!= REG_STRING
) {
652 ERR("Unexpected register type for string comparator\n");
659 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
660 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
662 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
663 ERR("Empty stack\n");
667 if (vstack_ax(stack
)->type
!= REG_STAR_GLOB_STRING
668 && vstack_bx(stack
)->type
!= REG_STAR_GLOB_STRING
) {
669 ERR("Unexpected register type for globbing pattern comparator\n");
676 case BYTECODE_OP_EQ_S64
:
677 case BYTECODE_OP_NE_S64
:
678 case BYTECODE_OP_GT_S64
:
679 case BYTECODE_OP_LT_S64
:
680 case BYTECODE_OP_GE_S64
:
681 case BYTECODE_OP_LE_S64
:
683 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
684 ERR("Empty stack\n");
688 switch (vstack_ax(stack
)->type
) {
693 ERR("Unexpected register type for s64 comparator\n");
697 switch (vstack_bx(stack
)->type
) {
702 ERR("Unexpected register type for s64 comparator\n");
709 case BYTECODE_OP_EQ_DOUBLE
:
710 case BYTECODE_OP_NE_DOUBLE
:
711 case BYTECODE_OP_GT_DOUBLE
:
712 case BYTECODE_OP_LT_DOUBLE
:
713 case BYTECODE_OP_GE_DOUBLE
:
714 case BYTECODE_OP_LE_DOUBLE
:
716 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
717 ERR("Empty stack\n");
721 if (vstack_ax(stack
)->type
!= REG_DOUBLE
&& vstack_bx(stack
)->type
!= REG_DOUBLE
) {
722 ERR("Double operator should have two double registers\n");
729 case BYTECODE_OP_EQ_DOUBLE_S64
:
730 case BYTECODE_OP_NE_DOUBLE_S64
:
731 case BYTECODE_OP_GT_DOUBLE_S64
:
732 case BYTECODE_OP_LT_DOUBLE_S64
:
733 case BYTECODE_OP_GE_DOUBLE_S64
:
734 case BYTECODE_OP_LE_DOUBLE_S64
:
736 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
737 ERR("Empty stack\n");
741 switch (vstack_ax(stack
)->type
) {
746 ERR("Double-S64 operator has unexpected register types\n");
750 switch (vstack_bx(stack
)->type
) {
754 ERR("Double-S64 operator has unexpected register types\n");
761 case BYTECODE_OP_EQ_S64_DOUBLE
:
762 case BYTECODE_OP_NE_S64_DOUBLE
:
763 case BYTECODE_OP_GT_S64_DOUBLE
:
764 case BYTECODE_OP_LT_S64_DOUBLE
:
765 case BYTECODE_OP_GE_S64_DOUBLE
:
766 case BYTECODE_OP_LE_S64_DOUBLE
:
768 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
769 ERR("Empty stack\n");
773 switch (vstack_ax(stack
)->type
) {
777 ERR("S64-Double operator has unexpected register types\n");
781 switch (vstack_bx(stack
)->type
) {
786 ERR("S64-Double operator has unexpected register types\n");
793 case BYTECODE_OP_BIT_RSHIFT
:
794 ret
= bin_op_bitwise_check(stack
, opcode
, ">>");
798 case BYTECODE_OP_BIT_LSHIFT
:
799 ret
= bin_op_bitwise_check(stack
, opcode
, "<<");
803 case BYTECODE_OP_BIT_AND
:
804 ret
= bin_op_bitwise_check(stack
, opcode
, "&");
808 case BYTECODE_OP_BIT_OR
:
809 ret
= bin_op_bitwise_check(stack
, opcode
, "|");
813 case BYTECODE_OP_BIT_XOR
:
814 ret
= bin_op_bitwise_check(stack
, opcode
, "^");
820 case BYTECODE_OP_UNARY_PLUS
:
821 case BYTECODE_OP_UNARY_MINUS
:
822 case BYTECODE_OP_UNARY_NOT
:
824 if (!vstack_ax(stack
)) {
825 ERR("Empty stack\n");
829 switch (vstack_ax(stack
)->type
) {
831 ERR("unknown register type\n");
836 case REG_STAR_GLOB_STRING
:
837 ERR("Unary op can only be applied to numeric or floating point registers\n");
851 case BYTECODE_OP_UNARY_BIT_NOT
:
853 if (!vstack_ax(stack
)) {
854 ERR("Empty stack\n");
858 switch (vstack_ax(stack
)->type
) {
860 ERR("unknown register type\n");
865 case REG_STAR_GLOB_STRING
:
867 ERR("Unary bitwise op can only be applied to numeric registers\n");
880 case BYTECODE_OP_UNARY_PLUS_S64
:
881 case BYTECODE_OP_UNARY_MINUS_S64
:
882 case BYTECODE_OP_UNARY_NOT_S64
:
884 if (!vstack_ax(stack
)) {
885 ERR("Empty stack\n");
889 if (vstack_ax(stack
)->type
!= REG_S64
&&
890 vstack_ax(stack
)->type
!= REG_U64
) {
891 ERR("Invalid register type\n");
898 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
899 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
900 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
902 if (!vstack_ax(stack
)) {
903 ERR("Empty stack\n");
907 if (vstack_ax(stack
)->type
!= REG_DOUBLE
) {
908 ERR("Invalid register type\n");
916 case BYTECODE_OP_AND
:
919 struct logical_op
*insn
= (struct logical_op
*) pc
;
921 if (!vstack_ax(stack
)) {
922 ERR("Empty stack\n");
926 if (vstack_ax(stack
)->type
!= REG_S64
927 && vstack_ax(stack
)->type
!= REG_U64
928 && vstack_ax(stack
)->type
!= REG_UNKNOWN
) {
929 ERR("Logical comparator expects S64, U64 or dynamic register\n");
934 dbg_printf("Validate jumping to bytecode offset %u\n",
935 (unsigned int) insn
->skip_offset
);
936 if (unlikely(start_pc
+ insn
->skip_offset
<= pc
)) {
937 ERR("Loops are not allowed in bytecode\n");
945 case BYTECODE_OP_LOAD_FIELD_REF
:
947 ERR("Unknown field ref type\n");
951 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
952 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
954 struct load_op
*insn
= (struct load_op
*) pc
;
955 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
957 dbg_printf("Validate load field ref offset %u type string\n",
961 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
963 struct load_op
*insn
= (struct load_op
*) pc
;
964 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
966 dbg_printf("Validate load field ref offset %u type s64\n",
970 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
972 struct load_op
*insn
= (struct load_op
*) pc
;
973 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
975 dbg_printf("Validate load field ref offset %u type double\n",
980 /* load from immediate operand */
981 case BYTECODE_OP_LOAD_STRING
:
982 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
987 case BYTECODE_OP_LOAD_S64
:
992 case BYTECODE_OP_LOAD_DOUBLE
:
997 case BYTECODE_OP_CAST_TO_S64
:
998 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
1000 struct cast_op
*insn
= (struct cast_op
*) pc
;
1002 if (!vstack_ax(stack
)) {
1003 ERR("Empty stack\n");
1007 switch (vstack_ax(stack
)->type
) {
1009 ERR("unknown register type\n");
1014 case REG_STAR_GLOB_STRING
:
1015 ERR("Cast op can only be applied to numeric or floating point registers\n");
1027 if (insn
->op
== BYTECODE_OP_CAST_DOUBLE_TO_S64
) {
1028 if (vstack_ax(stack
)->type
!= REG_DOUBLE
) {
1029 ERR("Cast expects double\n");
1036 case BYTECODE_OP_CAST_NOP
:
1041 /* get context ref */
1042 case BYTECODE_OP_GET_CONTEXT_REF
:
1044 struct load_op
*insn
= (struct load_op
*) pc
;
1045 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1047 dbg_printf("Validate get context ref offset %u type dynamic\n",
1051 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
1053 struct load_op
*insn
= (struct load_op
*) pc
;
1054 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1056 dbg_printf("Validate get context ref offset %u type string\n",
1060 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
1062 struct load_op
*insn
= (struct load_op
*) pc
;
1063 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1065 dbg_printf("Validate get context ref offset %u type s64\n",
1069 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
1071 struct load_op
*insn
= (struct load_op
*) pc
;
1072 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1074 dbg_printf("Validate get context ref offset %u type double\n",
1080 * Instructions for recursive traversal through composed types.
1082 case BYTECODE_OP_GET_CONTEXT_ROOT
:
1084 dbg_printf("Validate get context root\n");
1087 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
1089 dbg_printf("Validate get app context root\n");
1092 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
1094 dbg_printf("Validate get payload root\n");
1097 case BYTECODE_OP_LOAD_FIELD
:
1100 * We tolerate that field type is unknown at validation,
1101 * because we are performing the load specialization in
1102 * a phase after validation.
1104 dbg_printf("Validate load field\n");
1107 case BYTECODE_OP_LOAD_FIELD_S8
:
1109 dbg_printf("Validate load field s8\n");
1112 case BYTECODE_OP_LOAD_FIELD_S16
:
1114 dbg_printf("Validate load field s16\n");
1117 case BYTECODE_OP_LOAD_FIELD_S32
:
1119 dbg_printf("Validate load field s32\n");
1122 case BYTECODE_OP_LOAD_FIELD_S64
:
1124 dbg_printf("Validate load field s64\n");
1127 case BYTECODE_OP_LOAD_FIELD_U8
:
1129 dbg_printf("Validate load field u8\n");
1132 case BYTECODE_OP_LOAD_FIELD_U16
:
1134 dbg_printf("Validate load field u16\n");
1137 case BYTECODE_OP_LOAD_FIELD_U32
:
1139 dbg_printf("Validate load field u32\n");
1142 case BYTECODE_OP_LOAD_FIELD_U64
:
1144 dbg_printf("Validate load field u64\n");
1147 case BYTECODE_OP_LOAD_FIELD_STRING
:
1149 dbg_printf("Validate load field string\n");
1152 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
1154 dbg_printf("Validate load field sequence\n");
1157 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
1159 dbg_printf("Validate load field double\n");
1163 case BYTECODE_OP_GET_SYMBOL
:
1165 struct load_op
*insn
= (struct load_op
*) pc
;
1166 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
1168 dbg_printf("Validate get symbol offset %u\n", sym
->offset
);
1172 case BYTECODE_OP_GET_SYMBOL_FIELD
:
1174 struct load_op
*insn
= (struct load_op
*) pc
;
1175 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
1177 dbg_printf("Validate get symbol field offset %u\n", sym
->offset
);
1181 case BYTECODE_OP_GET_INDEX_U16
:
1183 struct load_op
*insn
= (struct load_op
*) pc
;
1184 struct get_index_u16
*get_index
= (struct get_index_u16
*) insn
->data
;
1186 dbg_printf("Validate get index u16 index %u\n", get_index
->index
);
1190 case BYTECODE_OP_GET_INDEX_U64
:
1192 struct load_op
*insn
= (struct load_op
*) pc
;
1193 struct get_index_u64
*get_index
= (struct get_index_u64
*) insn
->data
;
1195 dbg_printf("Validate get index u64 index %" PRIu64
"\n", get_index
->index
);
1209 int validate_instruction_all_contexts(struct bytecode_runtime
*bytecode
,
1210 struct lttng_ust_lfht
*merge_points
,
1211 struct vstack
*stack
,
1216 unsigned long target_pc
= pc
- start_pc
;
1217 struct lttng_ust_lfht_iter iter
;
1218 struct lttng_ust_lfht_node
*node
;
1219 struct lfht_mp_node
*mp_node
;
1222 /* Validate the context resulting from the previous instruction */
1223 ret
= validate_instruction_context(bytecode
, stack
, start_pc
, pc
);
1227 /* Validate merge points */
1228 hash
= lttng_hash_mix((const char *) target_pc
, sizeof(target_pc
),
1230 lttng_ust_lfht_lookup(merge_points
, hash
, lttng_hash_match
,
1231 (const char *) target_pc
, &iter
);
1232 node
= lttng_ust_lfht_iter_get_node(&iter
);
1234 mp_node
= caa_container_of(node
, struct lfht_mp_node
, node
);
1236 dbg_printf("Bytecode: validate merge point at offset %lu\n",
1238 if (merge_points_compare(stack
, &mp_node
->stack
)) {
1239 ERR("Merge points differ for offset %lu\n",
1243 /* Once validated, we can remove the merge point */
1244 dbg_printf("Bytecode: remove merge point at offset %lu\n",
1246 ret
= lttng_ust_lfht_del(merge_points
, node
);
1254 * >0: going to next insn.
1255 * 0: success, stop iteration.
1259 int exec_insn(struct bytecode_runtime
*bytecode
__attribute__((unused
)),
1260 struct lttng_ust_lfht
*merge_points
,
1261 struct vstack
*stack
,
1266 char *next_pc
= *_next_pc
;
1268 switch (*(bytecode_opcode_t
*) pc
) {
1269 case BYTECODE_OP_UNKNOWN
:
1272 ERR("unknown bytecode op %u\n",
1273 (unsigned int) *(bytecode_opcode_t
*) pc
);
1278 case BYTECODE_OP_RETURN
:
1280 if (!vstack_ax(stack
)) {
1281 ERR("Empty stack\n");
1285 switch (vstack_ax(stack
)->type
) {
1294 ERR("Unexpected register type %d at end of bytecode\n",
1295 (int) vstack_ax(stack
)->type
);
1303 case BYTECODE_OP_RETURN_S64
:
1305 if (!vstack_ax(stack
)) {
1306 ERR("Empty stack\n");
1310 switch (vstack_ax(stack
)->type
) {
1316 ERR("Unexpected register type %d at end of bytecode\n",
1317 (int) vstack_ax(stack
)->type
);
1327 case BYTECODE_OP_MUL
:
1328 case BYTECODE_OP_DIV
:
1329 case BYTECODE_OP_MOD
:
1330 case BYTECODE_OP_PLUS
:
1331 case BYTECODE_OP_MINUS
:
1333 ERR("unsupported bytecode op %u\n",
1334 (unsigned int) *(bytecode_opcode_t
*) pc
);
1339 case BYTECODE_OP_EQ
:
1340 case BYTECODE_OP_NE
:
1341 case BYTECODE_OP_GT
:
1342 case BYTECODE_OP_LT
:
1343 case BYTECODE_OP_GE
:
1344 case BYTECODE_OP_LE
:
1345 case BYTECODE_OP_EQ_STRING
:
1346 case BYTECODE_OP_NE_STRING
:
1347 case BYTECODE_OP_GT_STRING
:
1348 case BYTECODE_OP_LT_STRING
:
1349 case BYTECODE_OP_GE_STRING
:
1350 case BYTECODE_OP_LE_STRING
:
1351 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
1352 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
1353 case BYTECODE_OP_EQ_S64
:
1354 case BYTECODE_OP_NE_S64
:
1355 case BYTECODE_OP_GT_S64
:
1356 case BYTECODE_OP_LT_S64
:
1357 case BYTECODE_OP_GE_S64
:
1358 case BYTECODE_OP_LE_S64
:
1359 case BYTECODE_OP_EQ_DOUBLE
:
1360 case BYTECODE_OP_NE_DOUBLE
:
1361 case BYTECODE_OP_GT_DOUBLE
:
1362 case BYTECODE_OP_LT_DOUBLE
:
1363 case BYTECODE_OP_GE_DOUBLE
:
1364 case BYTECODE_OP_LE_DOUBLE
:
1365 case BYTECODE_OP_EQ_DOUBLE_S64
:
1366 case BYTECODE_OP_NE_DOUBLE_S64
:
1367 case BYTECODE_OP_GT_DOUBLE_S64
:
1368 case BYTECODE_OP_LT_DOUBLE_S64
:
1369 case BYTECODE_OP_GE_DOUBLE_S64
:
1370 case BYTECODE_OP_LE_DOUBLE_S64
:
1371 case BYTECODE_OP_EQ_S64_DOUBLE
:
1372 case BYTECODE_OP_NE_S64_DOUBLE
:
1373 case BYTECODE_OP_GT_S64_DOUBLE
:
1374 case BYTECODE_OP_LT_S64_DOUBLE
:
1375 case BYTECODE_OP_GE_S64_DOUBLE
:
1376 case BYTECODE_OP_LE_S64_DOUBLE
:
1379 if (vstack_pop(stack
)) {
1383 if (!vstack_ax(stack
)) {
1384 ERR("Empty stack\n");
1388 switch (vstack_ax(stack
)->type
) {
1393 case REG_STAR_GLOB_STRING
:
1397 ERR("Unexpected register type %d for operation\n",
1398 (int) vstack_ax(stack
)->type
);
1403 vstack_ax(stack
)->type
= REG_S64
;
1404 next_pc
+= sizeof(struct binary_op
);
1408 case BYTECODE_OP_BIT_RSHIFT
:
1409 case BYTECODE_OP_BIT_LSHIFT
:
1410 case BYTECODE_OP_BIT_AND
:
1411 case BYTECODE_OP_BIT_OR
:
1412 case BYTECODE_OP_BIT_XOR
:
1415 if (vstack_pop(stack
)) {
1419 if (!vstack_ax(stack
)) {
1420 ERR("Empty stack\n");
1424 switch (vstack_ax(stack
)->type
) {
1429 case REG_STAR_GLOB_STRING
:
1433 ERR("Unexpected register type %d for operation\n",
1434 (int) vstack_ax(stack
)->type
);
1439 vstack_ax(stack
)->type
= REG_U64
;
1440 next_pc
+= sizeof(struct binary_op
);
1445 case BYTECODE_OP_UNARY_PLUS
:
1446 case BYTECODE_OP_UNARY_MINUS
:
1449 if (!vstack_ax(stack
)) {
1450 ERR("Empty stack\n");
1454 switch (vstack_ax(stack
)->type
) {
1461 ERR("Unexpected register type %d for operation\n",
1462 (int) vstack_ax(stack
)->type
);
1466 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1467 next_pc
+= sizeof(struct unary_op
);
1471 case BYTECODE_OP_UNARY_PLUS_S64
:
1472 case BYTECODE_OP_UNARY_MINUS_S64
:
1473 case BYTECODE_OP_UNARY_NOT_S64
:
1476 if (!vstack_ax(stack
)) {
1477 ERR("Empty stack\n");
1481 switch (vstack_ax(stack
)->type
) {
1486 ERR("Unexpected register type %d for operation\n",
1487 (int) vstack_ax(stack
)->type
);
1492 next_pc
+= sizeof(struct unary_op
);
1496 case BYTECODE_OP_UNARY_NOT
:
1499 if (!vstack_ax(stack
)) {
1500 ERR("Empty stack\n");
1504 switch (vstack_ax(stack
)->type
) {
1511 ERR("Unexpected register type %d for operation\n",
1512 (int) vstack_ax(stack
)->type
);
1517 next_pc
+= sizeof(struct unary_op
);
1521 case BYTECODE_OP_UNARY_BIT_NOT
:
1524 if (!vstack_ax(stack
)) {
1525 ERR("Empty stack\n");
1529 switch (vstack_ax(stack
)->type
) {
1536 ERR("Unexpected register type %d for operation\n",
1537 (int) vstack_ax(stack
)->type
);
1542 vstack_ax(stack
)->type
= REG_U64
;
1543 next_pc
+= sizeof(struct unary_op
);
1547 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
1550 if (!vstack_ax(stack
)) {
1551 ERR("Empty stack\n");
1555 switch (vstack_ax(stack
)->type
) {
1559 ERR("Incorrect register type %d for operation\n",
1560 (int) vstack_ax(stack
)->type
);
1565 vstack_ax(stack
)->type
= REG_S64
;
1566 next_pc
+= sizeof(struct unary_op
);
1570 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
1571 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
1574 if (!vstack_ax(stack
)) {
1575 ERR("Empty stack\n");
1579 switch (vstack_ax(stack
)->type
) {
1583 ERR("Incorrect register type %d for operation\n",
1584 (int) vstack_ax(stack
)->type
);
1589 vstack_ax(stack
)->type
= REG_DOUBLE
;
1590 next_pc
+= sizeof(struct unary_op
);
1595 case BYTECODE_OP_AND
:
1596 case BYTECODE_OP_OR
:
1598 struct logical_op
*insn
= (struct logical_op
*) pc
;
1601 /* Add merge point to table */
1602 merge_ret
= merge_point_add_check(merge_points
,
1603 insn
->skip_offset
, stack
);
1609 if (!vstack_ax(stack
)) {
1610 ERR("Empty stack\n");
1614 /* There is always a cast-to-s64 operation before a or/and op. */
1615 switch (vstack_ax(stack
)->type
) {
1620 ERR("Incorrect register type %d for operation\n",
1621 (int) vstack_ax(stack
)->type
);
1626 /* Continue to next instruction */
1627 /* Pop 1 when jump not taken */
1628 if (vstack_pop(stack
)) {
1632 next_pc
+= sizeof(struct logical_op
);
1636 /* load field ref */
1637 case BYTECODE_OP_LOAD_FIELD_REF
:
1639 ERR("Unknown field ref type\n");
1643 /* get context ref */
1644 case BYTECODE_OP_GET_CONTEXT_REF
:
1646 if (vstack_push(stack
)) {
1650 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1651 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1654 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
1655 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
1656 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
1658 if (vstack_push(stack
)) {
1662 vstack_ax(stack
)->type
= REG_STRING
;
1663 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1666 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
1667 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
1669 if (vstack_push(stack
)) {
1673 vstack_ax(stack
)->type
= REG_S64
;
1674 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1677 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
1678 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
1680 if (vstack_push(stack
)) {
1684 vstack_ax(stack
)->type
= REG_DOUBLE
;
1685 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1689 /* load from immediate operand */
1690 case BYTECODE_OP_LOAD_STRING
:
1692 struct load_op
*insn
= (struct load_op
*) pc
;
1694 if (vstack_push(stack
)) {
1698 vstack_ax(stack
)->type
= REG_STRING
;
1699 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1703 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
1705 struct load_op
*insn
= (struct load_op
*) pc
;
1707 if (vstack_push(stack
)) {
1711 vstack_ax(stack
)->type
= REG_STAR_GLOB_STRING
;
1712 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1716 case BYTECODE_OP_LOAD_S64
:
1718 if (vstack_push(stack
)) {
1722 vstack_ax(stack
)->type
= REG_S64
;
1723 next_pc
+= sizeof(struct load_op
)
1724 + sizeof(struct literal_numeric
);
1728 case BYTECODE_OP_LOAD_DOUBLE
:
1730 if (vstack_push(stack
)) {
1734 vstack_ax(stack
)->type
= REG_DOUBLE
;
1735 next_pc
+= sizeof(struct load_op
)
1736 + sizeof(struct literal_double
);
1740 case BYTECODE_OP_CAST_TO_S64
:
1741 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
1744 if (!vstack_ax(stack
)) {
1745 ERR("Empty stack\n");
1749 switch (vstack_ax(stack
)->type
) {
1756 ERR("Incorrect register type %d for cast\n",
1757 (int) vstack_ax(stack
)->type
);
1761 vstack_ax(stack
)->type
= REG_S64
;
1762 next_pc
+= sizeof(struct cast_op
);
1765 case BYTECODE_OP_CAST_NOP
:
1767 next_pc
+= sizeof(struct cast_op
);
1772 * Instructions for recursive traversal through composed types.
1774 case BYTECODE_OP_GET_CONTEXT_ROOT
:
1775 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
1776 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
1778 if (vstack_push(stack
)) {
1782 vstack_ax(stack
)->type
= REG_PTR
;
1783 next_pc
+= sizeof(struct load_op
);
1787 case BYTECODE_OP_LOAD_FIELD
:
1790 if (!vstack_ax(stack
)) {
1791 ERR("Empty stack\n");
1795 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1796 ERR("Expecting pointer on top of stack\n");
1800 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1801 next_pc
+= sizeof(struct load_op
);
1805 case BYTECODE_OP_LOAD_FIELD_S8
:
1806 case BYTECODE_OP_LOAD_FIELD_S16
:
1807 case BYTECODE_OP_LOAD_FIELD_S32
:
1808 case BYTECODE_OP_LOAD_FIELD_S64
:
1811 if (!vstack_ax(stack
)) {
1812 ERR("Empty stack\n");
1816 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1817 ERR("Expecting pointer on top of stack\n");
1821 vstack_ax(stack
)->type
= REG_S64
;
1822 next_pc
+= sizeof(struct load_op
);
1826 case BYTECODE_OP_LOAD_FIELD_U8
:
1827 case BYTECODE_OP_LOAD_FIELD_U16
:
1828 case BYTECODE_OP_LOAD_FIELD_U32
:
1829 case BYTECODE_OP_LOAD_FIELD_U64
:
1832 if (!vstack_ax(stack
)) {
1833 ERR("Empty stack\n");
1837 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1838 ERR("Expecting pointer on top of stack\n");
1842 vstack_ax(stack
)->type
= REG_U64
;
1843 next_pc
+= sizeof(struct load_op
);
1847 case BYTECODE_OP_LOAD_FIELD_STRING
:
1848 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
1851 if (!vstack_ax(stack
)) {
1852 ERR("Empty stack\n");
1856 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1857 ERR("Expecting pointer on top of stack\n");
1861 vstack_ax(stack
)->type
= REG_STRING
;
1862 next_pc
+= sizeof(struct load_op
);
1866 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
1869 if (!vstack_ax(stack
)) {
1870 ERR("Empty stack\n");
1874 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1875 ERR("Expecting pointer on top of stack\n");
1879 vstack_ax(stack
)->type
= REG_DOUBLE
;
1880 next_pc
+= sizeof(struct load_op
);
1884 case BYTECODE_OP_GET_SYMBOL
:
1885 case BYTECODE_OP_GET_SYMBOL_FIELD
:
1888 if (!vstack_ax(stack
)) {
1889 ERR("Empty stack\n");
1893 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1894 ERR("Expecting pointer on top of stack\n");
1898 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_symbol
);
1902 case BYTECODE_OP_GET_INDEX_U16
:
1905 if (!vstack_ax(stack
)) {
1906 ERR("Empty stack\n");
1910 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1911 ERR("Expecting pointer on top of stack\n");
1915 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u16
);
1919 case BYTECODE_OP_GET_INDEX_U64
:
1922 if (!vstack_ax(stack
)) {
1923 ERR("Empty stack\n");
1927 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1928 ERR("Expecting pointer on top of stack\n");
1932 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u64
);
1938 *_next_pc
= next_pc
;
1943 * Never called concurrently (hash seed is shared).
1945 int lttng_bytecode_validate(struct bytecode_runtime
*bytecode
)
1947 struct lttng_ust_lfht
*merge_points
;
1948 char *pc
, *next_pc
, *start_pc
;
1950 struct vstack stack
;
1952 vstack_init(&stack
);
1954 if (!lttng_hash_seed_ready
) {
1955 lttng_hash_seed
= time(NULL
);
1956 lttng_hash_seed_ready
= 1;
1959 * Note: merge_points hash table used by single thread, and
1960 * never concurrently resized. Therefore, we can use it without
1961 * holding RCU read-side lock and free nodes without using
1964 merge_points
= lttng_ust_lfht_new(DEFAULT_NR_MERGE_POINTS
,
1965 MIN_NR_BUCKETS
, MAX_NR_BUCKETS
,
1967 if (!merge_points
) {
1968 ERR("Error allocating hash table for bytecode validation\n");
1971 start_pc
= &bytecode
->code
[0];
1972 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
1974 ret
= bytecode_validate_overflow(bytecode
, start_pc
, pc
);
1977 ERR("Bytecode overflow\n");
1980 dbg_printf("Validating op %s (%u)\n",
1981 lttng_bytecode_print_op((unsigned int) *(bytecode_opcode_t
*) pc
),
1982 (unsigned int) *(bytecode_opcode_t
*) pc
);
1985 * For each instruction, validate the current context
1986 * (traversal of entire execution flow), and validate
1987 * all merge points targeting this instruction.
1989 ret
= validate_instruction_all_contexts(bytecode
, merge_points
,
1990 &stack
, start_pc
, pc
);
1993 ret
= exec_insn(bytecode
, merge_points
, &stack
, &next_pc
, pc
);
1998 if (delete_all_nodes(merge_points
)) {
2000 ERR("Unexpected merge points\n");
2004 if (lttng_ust_lfht_destroy(merge_points
)) {
2005 ERR("Error destroying hash table\n");