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 "lttng-hash-helper.h"
18 #include "string-utils.h"
19 #include "ust-events-internal.h"
22 * Number of merge points for hash table size. Hash table initialized to
23 * that size, and we do not resize, because we do not want to trigger
24 * RCU worker thread execution: fall-back on linear traversal if number
25 * of merge points exceeds this value.
27 #define DEFAULT_NR_MERGE_POINTS 128
28 #define MIN_NR_BUCKETS 128
29 #define MAX_NR_BUCKETS 128
31 /* merge point table node */
33 struct lttng_ust_lfht_node node
;
35 /* Context at merge point */
37 unsigned long target_pc
;
40 static unsigned long lttng_hash_seed
;
41 static unsigned int lttng_hash_seed_ready
;
44 int lttng_hash_match(struct lttng_ust_lfht_node
*node
, const void *key
)
46 struct lfht_mp_node
*mp_node
=
47 caa_container_of(node
, struct lfht_mp_node
, node
);
48 unsigned long key_pc
= (unsigned long) key
;
50 if (mp_node
->target_pc
== key_pc
)
57 int merge_points_compare(const struct vstack
*stacka
,
58 const struct vstack
*stackb
)
62 if (stacka
->top
!= stackb
->top
)
64 len
= stacka
->top
+ 1;
66 for (i
= 0; i
< len
; i
++) {
67 if (stacka
->e
[i
].type
!= REG_UNKNOWN
68 && stackb
->e
[i
].type
!= REG_UNKNOWN
69 && stacka
->e
[i
].type
!= stackb
->e
[i
].type
)
76 int merge_point_add_check(struct lttng_ust_lfht
*ht
, unsigned long target_pc
,
77 const struct vstack
*stack
)
79 struct lfht_mp_node
*node
;
80 unsigned long hash
= lttng_hash_mix((const char *) target_pc
,
83 struct lttng_ust_lfht_node
*ret
;
85 dbg_printf("Bytecode: adding merge point at offset %lu, hash %lu\n",
87 node
= zmalloc(sizeof(struct lfht_mp_node
));
90 node
->target_pc
= target_pc
;
91 memcpy(&node
->stack
, stack
, sizeof(node
->stack
));
92 ret
= lttng_ust_lfht_add_unique(ht
, hash
, lttng_hash_match
,
93 (const char *) target_pc
, &node
->node
);
94 if (ret
!= &node
->node
) {
95 struct lfht_mp_node
*ret_mp
=
96 caa_container_of(ret
, struct lfht_mp_node
, node
);
98 /* Key already present */
99 dbg_printf("Bytecode: compare merge points for offset %lu, hash %lu\n",
102 if (merge_points_compare(stack
, &ret_mp
->stack
)) {
103 ERR("Merge points differ for offset %lu\n",
112 * Binary comparators use top of stack and top of stack -1.
113 * Return 0 if typing is known to match, 1 if typing is dynamic
114 * (unknown), negative error value on error.
117 int bin_op_compare_check(struct vstack
*stack
, bytecode_opcode_t opcode
,
120 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
123 switch (vstack_ax(stack
)->type
) {
130 switch (vstack_bx(stack
)->type
) {
138 case REG_STAR_GLOB_STRING
:
139 if (opcode
!= BYTECODE_OP_EQ
&& opcode
!= BYTECODE_OP_NE
) {
149 case REG_STAR_GLOB_STRING
:
150 switch (vstack_bx(stack
)->type
) {
157 if (opcode
!= BYTECODE_OP_EQ
&& opcode
!= BYTECODE_OP_NE
) {
161 case REG_STAR_GLOB_STRING
:
171 switch (vstack_bx(stack
)->type
) {
178 case REG_STAR_GLOB_STRING
:
193 ERR("type mismatch for '%s' binary operator\n", str
);
197 ERR("empty stack for '%s' binary operator\n", str
);
201 ERR("unknown type for '%s' binary operator\n", str
);
206 * Binary bitwise operators use top of stack and top of stack -1.
207 * Return 0 if typing is known to match, 1 if typing is dynamic
208 * (unknown), negative error value on error.
211 int bin_op_bitwise_check(struct vstack
*stack
, bytecode_opcode_t opcode
,
214 if (unlikely(!vstack_ax(stack
) || !vstack_bx(stack
)))
217 switch (vstack_ax(stack
)->type
) {
225 switch (vstack_bx(stack
)->type
) {
243 ERR("empty stack for '%s' binary operator\n", str
);
247 ERR("unknown type for '%s' binary operator\n", str
);
252 int validate_get_symbol(struct bytecode_runtime
*bytecode
,
253 const struct get_symbol
*sym
)
255 const char *str
, *str_limit
;
258 if (sym
->offset
>= bytecode
->p
.bc
->bc
.len
- bytecode
->p
.bc
->bc
.reloc_offset
)
261 str
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.reloc_offset
+ sym
->offset
;
262 str_limit
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.len
;
263 len_limit
= str_limit
- str
;
264 if (strnlen(str
, len_limit
) == len_limit
)
270 * Validate bytecode range overflow within the validation pass.
271 * Called for each instruction encountered.
274 int bytecode_validate_overflow(struct bytecode_runtime
*bytecode
,
275 char *start_pc
, char *pc
)
279 switch (*(bytecode_opcode_t
*) pc
) {
280 case BYTECODE_OP_UNKNOWN
:
283 ERR("unknown bytecode op %u\n",
284 (unsigned int) *(bytecode_opcode_t
*) pc
);
289 case BYTECODE_OP_RETURN
:
290 case BYTECODE_OP_RETURN_S64
:
292 if (unlikely(pc
+ sizeof(struct return_op
)
293 > start_pc
+ bytecode
->len
)) {
300 case BYTECODE_OP_MUL
:
301 case BYTECODE_OP_DIV
:
302 case BYTECODE_OP_MOD
:
303 case BYTECODE_OP_PLUS
:
304 case BYTECODE_OP_MINUS
:
306 ERR("unsupported bytecode op %u\n",
307 (unsigned int) *(bytecode_opcode_t
*) pc
);
318 case BYTECODE_OP_EQ_STRING
:
319 case BYTECODE_OP_NE_STRING
:
320 case BYTECODE_OP_GT_STRING
:
321 case BYTECODE_OP_LT_STRING
:
322 case BYTECODE_OP_GE_STRING
:
323 case BYTECODE_OP_LE_STRING
:
324 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
325 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
326 case BYTECODE_OP_EQ_S64
:
327 case BYTECODE_OP_NE_S64
:
328 case BYTECODE_OP_GT_S64
:
329 case BYTECODE_OP_LT_S64
:
330 case BYTECODE_OP_GE_S64
:
331 case BYTECODE_OP_LE_S64
:
332 case BYTECODE_OP_EQ_DOUBLE
:
333 case BYTECODE_OP_NE_DOUBLE
:
334 case BYTECODE_OP_GT_DOUBLE
:
335 case BYTECODE_OP_LT_DOUBLE
:
336 case BYTECODE_OP_GE_DOUBLE
:
337 case BYTECODE_OP_LE_DOUBLE
:
338 case BYTECODE_OP_EQ_DOUBLE_S64
:
339 case BYTECODE_OP_NE_DOUBLE_S64
:
340 case BYTECODE_OP_GT_DOUBLE_S64
:
341 case BYTECODE_OP_LT_DOUBLE_S64
:
342 case BYTECODE_OP_GE_DOUBLE_S64
:
343 case BYTECODE_OP_LE_DOUBLE_S64
:
344 case BYTECODE_OP_EQ_S64_DOUBLE
:
345 case BYTECODE_OP_NE_S64_DOUBLE
:
346 case BYTECODE_OP_GT_S64_DOUBLE
:
347 case BYTECODE_OP_LT_S64_DOUBLE
:
348 case BYTECODE_OP_GE_S64_DOUBLE
:
349 case BYTECODE_OP_LE_S64_DOUBLE
:
350 case BYTECODE_OP_BIT_RSHIFT
:
351 case BYTECODE_OP_BIT_LSHIFT
:
352 case BYTECODE_OP_BIT_AND
:
353 case BYTECODE_OP_BIT_OR
:
354 case BYTECODE_OP_BIT_XOR
:
356 if (unlikely(pc
+ sizeof(struct binary_op
)
357 > start_pc
+ bytecode
->len
)) {
364 case BYTECODE_OP_UNARY_PLUS
:
365 case BYTECODE_OP_UNARY_MINUS
:
366 case BYTECODE_OP_UNARY_NOT
:
367 case BYTECODE_OP_UNARY_PLUS_S64
:
368 case BYTECODE_OP_UNARY_MINUS_S64
:
369 case BYTECODE_OP_UNARY_NOT_S64
:
370 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
371 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
372 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
373 case BYTECODE_OP_UNARY_BIT_NOT
:
375 if (unlikely(pc
+ sizeof(struct unary_op
)
376 > start_pc
+ bytecode
->len
)) {
383 case BYTECODE_OP_AND
:
386 if (unlikely(pc
+ sizeof(struct logical_op
)
387 > start_pc
+ bytecode
->len
)) {
394 case BYTECODE_OP_LOAD_FIELD_REF
:
396 ERR("Unknown field ref type\n");
401 /* get context ref */
402 case BYTECODE_OP_GET_CONTEXT_REF
:
403 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
404 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
405 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
406 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
407 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
408 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
409 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
411 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct field_ref
)
412 > start_pc
+ bytecode
->len
)) {
418 /* load from immediate operand */
419 case BYTECODE_OP_LOAD_STRING
:
420 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
422 struct load_op
*insn
= (struct load_op
*) pc
;
423 uint32_t str_len
, maxlen
;
425 if (unlikely(pc
+ sizeof(struct load_op
)
426 > start_pc
+ bytecode
->len
)) {
431 maxlen
= start_pc
+ bytecode
->len
- pc
- sizeof(struct load_op
);
432 str_len
= strnlen(insn
->data
, maxlen
);
433 if (unlikely(str_len
>= maxlen
)) {
434 /* Final '\0' not found within range */
440 case BYTECODE_OP_LOAD_S64
:
442 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct literal_numeric
)
443 > start_pc
+ bytecode
->len
)) {
449 case BYTECODE_OP_LOAD_DOUBLE
:
451 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct literal_double
)
452 > start_pc
+ bytecode
->len
)) {
458 case BYTECODE_OP_CAST_TO_S64
:
459 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
460 case BYTECODE_OP_CAST_NOP
:
462 if (unlikely(pc
+ sizeof(struct cast_op
)
463 > start_pc
+ bytecode
->len
)) {
470 * Instructions for recursive traversal through composed types.
472 case BYTECODE_OP_GET_CONTEXT_ROOT
:
473 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
474 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
475 case BYTECODE_OP_LOAD_FIELD
:
476 case BYTECODE_OP_LOAD_FIELD_S8
:
477 case BYTECODE_OP_LOAD_FIELD_S16
:
478 case BYTECODE_OP_LOAD_FIELD_S32
:
479 case BYTECODE_OP_LOAD_FIELD_S64
:
480 case BYTECODE_OP_LOAD_FIELD_U8
:
481 case BYTECODE_OP_LOAD_FIELD_U16
:
482 case BYTECODE_OP_LOAD_FIELD_U32
:
483 case BYTECODE_OP_LOAD_FIELD_U64
:
484 case BYTECODE_OP_LOAD_FIELD_STRING
:
485 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
486 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
487 if (unlikely(pc
+ sizeof(struct load_op
)
488 > start_pc
+ bytecode
->len
)) {
493 case BYTECODE_OP_GET_SYMBOL
:
495 struct load_op
*insn
= (struct load_op
*) pc
;
496 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
498 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_symbol
)
499 > start_pc
+ bytecode
->len
)) {
503 ret
= validate_get_symbol(bytecode
, sym
);
507 case BYTECODE_OP_GET_SYMBOL_FIELD
:
508 ERR("Unexpected get symbol field");
512 case BYTECODE_OP_GET_INDEX_U16
:
513 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u16
)
514 > start_pc
+ bytecode
->len
)) {
519 case BYTECODE_OP_GET_INDEX_U64
:
520 if (unlikely(pc
+ sizeof(struct load_op
) + sizeof(struct get_index_u64
)
521 > start_pc
+ bytecode
->len
)) {
531 unsigned long delete_all_nodes(struct lttng_ust_lfht
*ht
)
533 struct lttng_ust_lfht_iter iter
;
534 struct lfht_mp_node
*node
;
535 unsigned long nr_nodes
= 0;
537 lttng_ust_lfht_for_each_entry(ht
, &iter
, node
, node
) {
540 ret
= lttng_ust_lfht_del(ht
, lttng_ust_lfht_iter_get_node(&iter
));
542 /* note: this hash table is never used concurrently */
555 int validate_instruction_context(struct bytecode_runtime
*bytecode
,
556 struct vstack
*stack
,
561 const bytecode_opcode_t opcode
= *(bytecode_opcode_t
*) pc
;
564 case BYTECODE_OP_UNKNOWN
:
567 ERR("unknown bytecode op %u\n",
568 (unsigned int) *(bytecode_opcode_t
*) pc
);
573 case BYTECODE_OP_RETURN
:
574 case BYTECODE_OP_RETURN_S64
:
580 case BYTECODE_OP_MUL
:
581 case BYTECODE_OP_DIV
:
582 case BYTECODE_OP_MOD
:
583 case BYTECODE_OP_PLUS
:
584 case BYTECODE_OP_MINUS
:
586 ERR("unsupported bytecode op %u\n",
587 (unsigned int) opcode
);
594 ret
= bin_op_compare_check(stack
, opcode
, "==");
601 ret
= bin_op_compare_check(stack
, opcode
, "!=");
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
, "<=");
635 case BYTECODE_OP_EQ_STRING
:
636 case BYTECODE_OP_NE_STRING
:
637 case BYTECODE_OP_GT_STRING
:
638 case BYTECODE_OP_LT_STRING
:
639 case BYTECODE_OP_GE_STRING
:
640 case BYTECODE_OP_LE_STRING
:
642 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
643 ERR("Empty stack\n");
647 if (vstack_ax(stack
)->type
!= REG_STRING
648 || vstack_bx(stack
)->type
!= REG_STRING
) {
649 ERR("Unexpected register type for string comparator\n");
656 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
657 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
659 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
660 ERR("Empty stack\n");
664 if (vstack_ax(stack
)->type
!= REG_STAR_GLOB_STRING
665 && vstack_bx(stack
)->type
!= REG_STAR_GLOB_STRING
) {
666 ERR("Unexpected register type for globbing pattern comparator\n");
673 case BYTECODE_OP_EQ_S64
:
674 case BYTECODE_OP_NE_S64
:
675 case BYTECODE_OP_GT_S64
:
676 case BYTECODE_OP_LT_S64
:
677 case BYTECODE_OP_GE_S64
:
678 case BYTECODE_OP_LE_S64
:
680 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
681 ERR("Empty stack\n");
685 switch (vstack_ax(stack
)->type
) {
690 ERR("Unexpected register type for s64 comparator\n");
694 switch (vstack_bx(stack
)->type
) {
699 ERR("Unexpected register type for s64 comparator\n");
706 case BYTECODE_OP_EQ_DOUBLE
:
707 case BYTECODE_OP_NE_DOUBLE
:
708 case BYTECODE_OP_GT_DOUBLE
:
709 case BYTECODE_OP_LT_DOUBLE
:
710 case BYTECODE_OP_GE_DOUBLE
:
711 case BYTECODE_OP_LE_DOUBLE
:
713 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
714 ERR("Empty stack\n");
718 if (vstack_ax(stack
)->type
!= REG_DOUBLE
&& vstack_bx(stack
)->type
!= REG_DOUBLE
) {
719 ERR("Double operator should have two double registers\n");
726 case BYTECODE_OP_EQ_DOUBLE_S64
:
727 case BYTECODE_OP_NE_DOUBLE_S64
:
728 case BYTECODE_OP_GT_DOUBLE_S64
:
729 case BYTECODE_OP_LT_DOUBLE_S64
:
730 case BYTECODE_OP_GE_DOUBLE_S64
:
731 case BYTECODE_OP_LE_DOUBLE_S64
:
733 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
734 ERR("Empty stack\n");
738 switch (vstack_ax(stack
)->type
) {
743 ERR("Double-S64 operator has unexpected register types\n");
747 switch (vstack_bx(stack
)->type
) {
751 ERR("Double-S64 operator has unexpected register types\n");
758 case BYTECODE_OP_EQ_S64_DOUBLE
:
759 case BYTECODE_OP_NE_S64_DOUBLE
:
760 case BYTECODE_OP_GT_S64_DOUBLE
:
761 case BYTECODE_OP_LT_S64_DOUBLE
:
762 case BYTECODE_OP_GE_S64_DOUBLE
:
763 case BYTECODE_OP_LE_S64_DOUBLE
:
765 if (!vstack_ax(stack
) || !vstack_bx(stack
)) {
766 ERR("Empty stack\n");
770 switch (vstack_ax(stack
)->type
) {
774 ERR("S64-Double operator has unexpected register types\n");
778 switch (vstack_bx(stack
)->type
) {
783 ERR("S64-Double operator has unexpected register types\n");
790 case BYTECODE_OP_BIT_RSHIFT
:
791 ret
= bin_op_bitwise_check(stack
, opcode
, ">>");
795 case BYTECODE_OP_BIT_LSHIFT
:
796 ret
= bin_op_bitwise_check(stack
, opcode
, "<<");
800 case BYTECODE_OP_BIT_AND
:
801 ret
= bin_op_bitwise_check(stack
, opcode
, "&");
805 case BYTECODE_OP_BIT_OR
:
806 ret
= bin_op_bitwise_check(stack
, opcode
, "|");
810 case BYTECODE_OP_BIT_XOR
:
811 ret
= bin_op_bitwise_check(stack
, opcode
, "^");
817 case BYTECODE_OP_UNARY_PLUS
:
818 case BYTECODE_OP_UNARY_MINUS
:
819 case BYTECODE_OP_UNARY_NOT
:
821 if (!vstack_ax(stack
)) {
822 ERR("Empty stack\n");
826 switch (vstack_ax(stack
)->type
) {
828 ERR("unknown register type\n");
833 case REG_STAR_GLOB_STRING
:
834 ERR("Unary op can only be applied to numeric or floating point registers\n");
848 case BYTECODE_OP_UNARY_BIT_NOT
:
850 if (!vstack_ax(stack
)) {
851 ERR("Empty stack\n");
855 switch (vstack_ax(stack
)->type
) {
857 ERR("unknown register type\n");
862 case REG_STAR_GLOB_STRING
:
864 ERR("Unary bitwise op can only be applied to numeric registers\n");
877 case BYTECODE_OP_UNARY_PLUS_S64
:
878 case BYTECODE_OP_UNARY_MINUS_S64
:
879 case BYTECODE_OP_UNARY_NOT_S64
:
881 if (!vstack_ax(stack
)) {
882 ERR("Empty stack\n");
886 if (vstack_ax(stack
)->type
!= REG_S64
&&
887 vstack_ax(stack
)->type
!= REG_U64
) {
888 ERR("Invalid register type\n");
895 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
896 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
897 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
899 if (!vstack_ax(stack
)) {
900 ERR("Empty stack\n");
904 if (vstack_ax(stack
)->type
!= REG_DOUBLE
) {
905 ERR("Invalid register type\n");
913 case BYTECODE_OP_AND
:
916 struct logical_op
*insn
= (struct logical_op
*) pc
;
918 if (!vstack_ax(stack
)) {
919 ERR("Empty stack\n");
923 if (vstack_ax(stack
)->type
!= REG_S64
924 && vstack_ax(stack
)->type
!= REG_U64
925 && vstack_ax(stack
)->type
!= REG_UNKNOWN
) {
926 ERR("Logical comparator expects S64, U64 or dynamic register\n");
931 dbg_printf("Validate jumping to bytecode offset %u\n",
932 (unsigned int) insn
->skip_offset
);
933 if (unlikely(start_pc
+ insn
->skip_offset
<= pc
)) {
934 ERR("Loops are not allowed in bytecode\n");
942 case BYTECODE_OP_LOAD_FIELD_REF
:
944 ERR("Unknown field ref type\n");
948 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
949 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
951 struct load_op
*insn
= (struct load_op
*) pc
;
952 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
954 dbg_printf("Validate load field ref offset %u type string\n",
958 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
960 struct load_op
*insn
= (struct load_op
*) pc
;
961 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
963 dbg_printf("Validate load field ref offset %u type s64\n",
967 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
969 struct load_op
*insn
= (struct load_op
*) pc
;
970 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
972 dbg_printf("Validate load field ref offset %u type double\n",
977 /* load from immediate operand */
978 case BYTECODE_OP_LOAD_STRING
:
979 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
984 case BYTECODE_OP_LOAD_S64
:
989 case BYTECODE_OP_LOAD_DOUBLE
:
994 case BYTECODE_OP_CAST_TO_S64
:
995 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
997 struct cast_op
*insn
= (struct cast_op
*) pc
;
999 if (!vstack_ax(stack
)) {
1000 ERR("Empty stack\n");
1004 switch (vstack_ax(stack
)->type
) {
1006 ERR("unknown register type\n");
1011 case REG_STAR_GLOB_STRING
:
1012 ERR("Cast op can only be applied to numeric or floating point registers\n");
1024 if (insn
->op
== BYTECODE_OP_CAST_DOUBLE_TO_S64
) {
1025 if (vstack_ax(stack
)->type
!= REG_DOUBLE
) {
1026 ERR("Cast expects double\n");
1033 case BYTECODE_OP_CAST_NOP
:
1038 /* get context ref */
1039 case BYTECODE_OP_GET_CONTEXT_REF
:
1041 struct load_op
*insn
= (struct load_op
*) pc
;
1042 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1044 dbg_printf("Validate get context ref offset %u type dynamic\n",
1048 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
1050 struct load_op
*insn
= (struct load_op
*) pc
;
1051 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1053 dbg_printf("Validate get context ref offset %u type string\n",
1057 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
1059 struct load_op
*insn
= (struct load_op
*) pc
;
1060 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1062 dbg_printf("Validate get context ref offset %u type s64\n",
1066 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
1068 struct load_op
*insn
= (struct load_op
*) pc
;
1069 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
1071 dbg_printf("Validate get context ref offset %u type double\n",
1077 * Instructions for recursive traversal through composed types.
1079 case BYTECODE_OP_GET_CONTEXT_ROOT
:
1081 dbg_printf("Validate get context root\n");
1084 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
1086 dbg_printf("Validate get app context root\n");
1089 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
1091 dbg_printf("Validate get payload root\n");
1094 case BYTECODE_OP_LOAD_FIELD
:
1097 * We tolerate that field type is unknown at validation,
1098 * because we are performing the load specialization in
1099 * a phase after validation.
1101 dbg_printf("Validate load field\n");
1104 case BYTECODE_OP_LOAD_FIELD_S8
:
1106 dbg_printf("Validate load field s8\n");
1109 case BYTECODE_OP_LOAD_FIELD_S16
:
1111 dbg_printf("Validate load field s16\n");
1114 case BYTECODE_OP_LOAD_FIELD_S32
:
1116 dbg_printf("Validate load field s32\n");
1119 case BYTECODE_OP_LOAD_FIELD_S64
:
1121 dbg_printf("Validate load field s64\n");
1124 case BYTECODE_OP_LOAD_FIELD_U8
:
1126 dbg_printf("Validate load field u8\n");
1129 case BYTECODE_OP_LOAD_FIELD_U16
:
1131 dbg_printf("Validate load field u16\n");
1134 case BYTECODE_OP_LOAD_FIELD_U32
:
1136 dbg_printf("Validate load field u32\n");
1139 case BYTECODE_OP_LOAD_FIELD_U64
:
1141 dbg_printf("Validate load field u64\n");
1144 case BYTECODE_OP_LOAD_FIELD_STRING
:
1146 dbg_printf("Validate load field string\n");
1149 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
1151 dbg_printf("Validate load field sequence\n");
1154 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
1156 dbg_printf("Validate load field double\n");
1160 case BYTECODE_OP_GET_SYMBOL
:
1162 struct load_op
*insn
= (struct load_op
*) pc
;
1163 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
1165 dbg_printf("Validate get symbol offset %u\n", sym
->offset
);
1169 case BYTECODE_OP_GET_SYMBOL_FIELD
:
1171 struct load_op
*insn
= (struct load_op
*) pc
;
1172 struct get_symbol
*sym
= (struct get_symbol
*) insn
->data
;
1174 dbg_printf("Validate get symbol field offset %u\n", sym
->offset
);
1178 case BYTECODE_OP_GET_INDEX_U16
:
1180 struct load_op
*insn
= (struct load_op
*) pc
;
1181 struct get_index_u16
*get_index
= (struct get_index_u16
*) insn
->data
;
1183 dbg_printf("Validate get index u16 index %u\n", get_index
->index
);
1187 case BYTECODE_OP_GET_INDEX_U64
:
1189 struct load_op
*insn
= (struct load_op
*) pc
;
1190 struct get_index_u64
*get_index
= (struct get_index_u64
*) insn
->data
;
1192 dbg_printf("Validate get index u64 index %" PRIu64
"\n", get_index
->index
);
1206 int validate_instruction_all_contexts(struct bytecode_runtime
*bytecode
,
1207 struct lttng_ust_lfht
*merge_points
,
1208 struct vstack
*stack
,
1213 unsigned long target_pc
= pc
- start_pc
;
1214 struct lttng_ust_lfht_iter iter
;
1215 struct lttng_ust_lfht_node
*node
;
1216 struct lfht_mp_node
*mp_node
;
1219 /* Validate the context resulting from the previous instruction */
1220 ret
= validate_instruction_context(bytecode
, stack
, start_pc
, pc
);
1224 /* Validate merge points */
1225 hash
= lttng_hash_mix((const char *) target_pc
, sizeof(target_pc
),
1227 lttng_ust_lfht_lookup(merge_points
, hash
, lttng_hash_match
,
1228 (const char *) target_pc
, &iter
);
1229 node
= lttng_ust_lfht_iter_get_node(&iter
);
1231 mp_node
= caa_container_of(node
, struct lfht_mp_node
, node
);
1233 dbg_printf("Bytecode: validate merge point at offset %lu\n",
1235 if (merge_points_compare(stack
, &mp_node
->stack
)) {
1236 ERR("Merge points differ for offset %lu\n",
1240 /* Once validated, we can remove the merge point */
1241 dbg_printf("Bytecode: remove merge point at offset %lu\n",
1243 ret
= lttng_ust_lfht_del(merge_points
, node
);
1251 * >0: going to next insn.
1252 * 0: success, stop iteration.
1256 int exec_insn(struct bytecode_runtime
*bytecode
,
1257 struct lttng_ust_lfht
*merge_points
,
1258 struct vstack
*stack
,
1263 char *next_pc
= *_next_pc
;
1265 switch (*(bytecode_opcode_t
*) pc
) {
1266 case BYTECODE_OP_UNKNOWN
:
1269 ERR("unknown bytecode op %u\n",
1270 (unsigned int) *(bytecode_opcode_t
*) pc
);
1275 case BYTECODE_OP_RETURN
:
1277 if (!vstack_ax(stack
)) {
1278 ERR("Empty stack\n");
1282 switch (vstack_ax(stack
)->type
) {
1291 ERR("Unexpected register type %d at end of bytecode\n",
1292 (int) vstack_ax(stack
)->type
);
1300 case BYTECODE_OP_RETURN_S64
:
1302 if (!vstack_ax(stack
)) {
1303 ERR("Empty stack\n");
1307 switch (vstack_ax(stack
)->type
) {
1313 ERR("Unexpected register type %d at end of bytecode\n",
1314 (int) vstack_ax(stack
)->type
);
1324 case BYTECODE_OP_MUL
:
1325 case BYTECODE_OP_DIV
:
1326 case BYTECODE_OP_MOD
:
1327 case BYTECODE_OP_PLUS
:
1328 case BYTECODE_OP_MINUS
:
1330 ERR("unsupported bytecode op %u\n",
1331 (unsigned int) *(bytecode_opcode_t
*) pc
);
1336 case BYTECODE_OP_EQ
:
1337 case BYTECODE_OP_NE
:
1338 case BYTECODE_OP_GT
:
1339 case BYTECODE_OP_LT
:
1340 case BYTECODE_OP_GE
:
1341 case BYTECODE_OP_LE
:
1342 case BYTECODE_OP_EQ_STRING
:
1343 case BYTECODE_OP_NE_STRING
:
1344 case BYTECODE_OP_GT_STRING
:
1345 case BYTECODE_OP_LT_STRING
:
1346 case BYTECODE_OP_GE_STRING
:
1347 case BYTECODE_OP_LE_STRING
:
1348 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
1349 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
1350 case BYTECODE_OP_EQ_S64
:
1351 case BYTECODE_OP_NE_S64
:
1352 case BYTECODE_OP_GT_S64
:
1353 case BYTECODE_OP_LT_S64
:
1354 case BYTECODE_OP_GE_S64
:
1355 case BYTECODE_OP_LE_S64
:
1356 case BYTECODE_OP_EQ_DOUBLE
:
1357 case BYTECODE_OP_NE_DOUBLE
:
1358 case BYTECODE_OP_GT_DOUBLE
:
1359 case BYTECODE_OP_LT_DOUBLE
:
1360 case BYTECODE_OP_GE_DOUBLE
:
1361 case BYTECODE_OP_LE_DOUBLE
:
1362 case BYTECODE_OP_EQ_DOUBLE_S64
:
1363 case BYTECODE_OP_NE_DOUBLE_S64
:
1364 case BYTECODE_OP_GT_DOUBLE_S64
:
1365 case BYTECODE_OP_LT_DOUBLE_S64
:
1366 case BYTECODE_OP_GE_DOUBLE_S64
:
1367 case BYTECODE_OP_LE_DOUBLE_S64
:
1368 case BYTECODE_OP_EQ_S64_DOUBLE
:
1369 case BYTECODE_OP_NE_S64_DOUBLE
:
1370 case BYTECODE_OP_GT_S64_DOUBLE
:
1371 case BYTECODE_OP_LT_S64_DOUBLE
:
1372 case BYTECODE_OP_GE_S64_DOUBLE
:
1373 case BYTECODE_OP_LE_S64_DOUBLE
:
1376 if (vstack_pop(stack
)) {
1380 if (!vstack_ax(stack
)) {
1381 ERR("Empty stack\n");
1385 switch (vstack_ax(stack
)->type
) {
1390 case REG_STAR_GLOB_STRING
:
1394 ERR("Unexpected register type %d for operation\n",
1395 (int) vstack_ax(stack
)->type
);
1400 vstack_ax(stack
)->type
= REG_S64
;
1401 next_pc
+= sizeof(struct binary_op
);
1405 case BYTECODE_OP_BIT_RSHIFT
:
1406 case BYTECODE_OP_BIT_LSHIFT
:
1407 case BYTECODE_OP_BIT_AND
:
1408 case BYTECODE_OP_BIT_OR
:
1409 case BYTECODE_OP_BIT_XOR
:
1412 if (vstack_pop(stack
)) {
1416 if (!vstack_ax(stack
)) {
1417 ERR("Empty stack\n");
1421 switch (vstack_ax(stack
)->type
) {
1426 case REG_STAR_GLOB_STRING
:
1430 ERR("Unexpected register type %d for operation\n",
1431 (int) vstack_ax(stack
)->type
);
1436 vstack_ax(stack
)->type
= REG_U64
;
1437 next_pc
+= sizeof(struct binary_op
);
1442 case BYTECODE_OP_UNARY_PLUS
:
1443 case BYTECODE_OP_UNARY_MINUS
:
1446 if (!vstack_ax(stack
)) {
1447 ERR("Empty stack\n");
1451 switch (vstack_ax(stack
)->type
) {
1458 ERR("Unexpected register type %d for operation\n",
1459 (int) vstack_ax(stack
)->type
);
1463 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1464 next_pc
+= sizeof(struct unary_op
);
1468 case BYTECODE_OP_UNARY_PLUS_S64
:
1469 case BYTECODE_OP_UNARY_MINUS_S64
:
1470 case BYTECODE_OP_UNARY_NOT_S64
:
1473 if (!vstack_ax(stack
)) {
1474 ERR("Empty stack\n");
1478 switch (vstack_ax(stack
)->type
) {
1483 ERR("Unexpected register type %d for operation\n",
1484 (int) vstack_ax(stack
)->type
);
1489 next_pc
+= sizeof(struct unary_op
);
1493 case BYTECODE_OP_UNARY_NOT
:
1496 if (!vstack_ax(stack
)) {
1497 ERR("Empty stack\n");
1501 switch (vstack_ax(stack
)->type
) {
1508 ERR("Unexpected register type %d for operation\n",
1509 (int) vstack_ax(stack
)->type
);
1514 next_pc
+= sizeof(struct unary_op
);
1518 case BYTECODE_OP_UNARY_BIT_NOT
:
1521 if (!vstack_ax(stack
)) {
1522 ERR("Empty stack\n");
1526 switch (vstack_ax(stack
)->type
) {
1533 ERR("Unexpected register type %d for operation\n",
1534 (int) vstack_ax(stack
)->type
);
1539 vstack_ax(stack
)->type
= REG_U64
;
1540 next_pc
+= sizeof(struct unary_op
);
1544 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
1547 if (!vstack_ax(stack
)) {
1548 ERR("Empty stack\n");
1552 switch (vstack_ax(stack
)->type
) {
1556 ERR("Incorrect register type %d for operation\n",
1557 (int) vstack_ax(stack
)->type
);
1562 vstack_ax(stack
)->type
= REG_S64
;
1563 next_pc
+= sizeof(struct unary_op
);
1567 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
1568 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
1571 if (!vstack_ax(stack
)) {
1572 ERR("Empty stack\n");
1576 switch (vstack_ax(stack
)->type
) {
1580 ERR("Incorrect register type %d for operation\n",
1581 (int) vstack_ax(stack
)->type
);
1586 vstack_ax(stack
)->type
= REG_DOUBLE
;
1587 next_pc
+= sizeof(struct unary_op
);
1592 case BYTECODE_OP_AND
:
1593 case BYTECODE_OP_OR
:
1595 struct logical_op
*insn
= (struct logical_op
*) pc
;
1598 /* Add merge point to table */
1599 merge_ret
= merge_point_add_check(merge_points
,
1600 insn
->skip_offset
, stack
);
1606 if (!vstack_ax(stack
)) {
1607 ERR("Empty stack\n");
1611 /* There is always a cast-to-s64 operation before a or/and op. */
1612 switch (vstack_ax(stack
)->type
) {
1617 ERR("Incorrect register type %d for operation\n",
1618 (int) vstack_ax(stack
)->type
);
1623 /* Continue to next instruction */
1624 /* Pop 1 when jump not taken */
1625 if (vstack_pop(stack
)) {
1629 next_pc
+= sizeof(struct logical_op
);
1633 /* load field ref */
1634 case BYTECODE_OP_LOAD_FIELD_REF
:
1636 ERR("Unknown field ref type\n");
1640 /* get context ref */
1641 case BYTECODE_OP_GET_CONTEXT_REF
:
1643 if (vstack_push(stack
)) {
1647 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1648 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1651 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
1652 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
1653 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
1655 if (vstack_push(stack
)) {
1659 vstack_ax(stack
)->type
= REG_STRING
;
1660 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1663 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
1664 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
1666 if (vstack_push(stack
)) {
1670 vstack_ax(stack
)->type
= REG_S64
;
1671 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1674 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
1675 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
1677 if (vstack_push(stack
)) {
1681 vstack_ax(stack
)->type
= REG_DOUBLE
;
1682 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1686 /* load from immediate operand */
1687 case BYTECODE_OP_LOAD_STRING
:
1689 struct load_op
*insn
= (struct load_op
*) pc
;
1691 if (vstack_push(stack
)) {
1695 vstack_ax(stack
)->type
= REG_STRING
;
1696 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1700 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
1702 struct load_op
*insn
= (struct load_op
*) pc
;
1704 if (vstack_push(stack
)) {
1708 vstack_ax(stack
)->type
= REG_STAR_GLOB_STRING
;
1709 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1713 case BYTECODE_OP_LOAD_S64
:
1715 if (vstack_push(stack
)) {
1719 vstack_ax(stack
)->type
= REG_S64
;
1720 next_pc
+= sizeof(struct load_op
)
1721 + sizeof(struct literal_numeric
);
1725 case BYTECODE_OP_LOAD_DOUBLE
:
1727 if (vstack_push(stack
)) {
1731 vstack_ax(stack
)->type
= REG_DOUBLE
;
1732 next_pc
+= sizeof(struct load_op
)
1733 + sizeof(struct literal_double
);
1737 case BYTECODE_OP_CAST_TO_S64
:
1738 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
1741 if (!vstack_ax(stack
)) {
1742 ERR("Empty stack\n");
1746 switch (vstack_ax(stack
)->type
) {
1753 ERR("Incorrect register type %d for cast\n",
1754 (int) vstack_ax(stack
)->type
);
1758 vstack_ax(stack
)->type
= REG_S64
;
1759 next_pc
+= sizeof(struct cast_op
);
1762 case BYTECODE_OP_CAST_NOP
:
1764 next_pc
+= sizeof(struct cast_op
);
1769 * Instructions for recursive traversal through composed types.
1771 case BYTECODE_OP_GET_CONTEXT_ROOT
:
1772 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
1773 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
1775 if (vstack_push(stack
)) {
1779 vstack_ax(stack
)->type
= REG_PTR
;
1780 next_pc
+= sizeof(struct load_op
);
1784 case BYTECODE_OP_LOAD_FIELD
:
1787 if (!vstack_ax(stack
)) {
1788 ERR("Empty stack\n");
1792 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1793 ERR("Expecting pointer on top of stack\n");
1797 vstack_ax(stack
)->type
= REG_UNKNOWN
;
1798 next_pc
+= sizeof(struct load_op
);
1802 case BYTECODE_OP_LOAD_FIELD_S8
:
1803 case BYTECODE_OP_LOAD_FIELD_S16
:
1804 case BYTECODE_OP_LOAD_FIELD_S32
:
1805 case BYTECODE_OP_LOAD_FIELD_S64
:
1808 if (!vstack_ax(stack
)) {
1809 ERR("Empty stack\n");
1813 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1814 ERR("Expecting pointer on top of stack\n");
1818 vstack_ax(stack
)->type
= REG_S64
;
1819 next_pc
+= sizeof(struct load_op
);
1823 case BYTECODE_OP_LOAD_FIELD_U8
:
1824 case BYTECODE_OP_LOAD_FIELD_U16
:
1825 case BYTECODE_OP_LOAD_FIELD_U32
:
1826 case BYTECODE_OP_LOAD_FIELD_U64
:
1829 if (!vstack_ax(stack
)) {
1830 ERR("Empty stack\n");
1834 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1835 ERR("Expecting pointer on top of stack\n");
1839 vstack_ax(stack
)->type
= REG_U64
;
1840 next_pc
+= sizeof(struct load_op
);
1844 case BYTECODE_OP_LOAD_FIELD_STRING
:
1845 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
1848 if (!vstack_ax(stack
)) {
1849 ERR("Empty stack\n");
1853 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1854 ERR("Expecting pointer on top of stack\n");
1858 vstack_ax(stack
)->type
= REG_STRING
;
1859 next_pc
+= sizeof(struct load_op
);
1863 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
1866 if (!vstack_ax(stack
)) {
1867 ERR("Empty stack\n");
1871 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1872 ERR("Expecting pointer on top of stack\n");
1876 vstack_ax(stack
)->type
= REG_DOUBLE
;
1877 next_pc
+= sizeof(struct load_op
);
1881 case BYTECODE_OP_GET_SYMBOL
:
1882 case BYTECODE_OP_GET_SYMBOL_FIELD
:
1885 if (!vstack_ax(stack
)) {
1886 ERR("Empty stack\n");
1890 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1891 ERR("Expecting pointer on top of stack\n");
1895 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_symbol
);
1899 case BYTECODE_OP_GET_INDEX_U16
:
1902 if (!vstack_ax(stack
)) {
1903 ERR("Empty stack\n");
1907 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1908 ERR("Expecting pointer on top of stack\n");
1912 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u16
);
1916 case BYTECODE_OP_GET_INDEX_U64
:
1919 if (!vstack_ax(stack
)) {
1920 ERR("Empty stack\n");
1924 if (vstack_ax(stack
)->type
!= REG_PTR
) {
1925 ERR("Expecting pointer on top of stack\n");
1929 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u64
);
1935 *_next_pc
= next_pc
;
1940 * Never called concurrently (hash seed is shared).
1942 int lttng_bytecode_validate(struct bytecode_runtime
*bytecode
)
1944 struct lttng_ust_lfht
*merge_points
;
1945 char *pc
, *next_pc
, *start_pc
;
1947 struct vstack stack
;
1949 vstack_init(&stack
);
1951 if (!lttng_hash_seed_ready
) {
1952 lttng_hash_seed
= time(NULL
);
1953 lttng_hash_seed_ready
= 1;
1956 * Note: merge_points hash table used by single thread, and
1957 * never concurrently resized. Therefore, we can use it without
1958 * holding RCU read-side lock and free nodes without using
1961 merge_points
= lttng_ust_lfht_new(DEFAULT_NR_MERGE_POINTS
,
1962 MIN_NR_BUCKETS
, MAX_NR_BUCKETS
,
1964 if (!merge_points
) {
1965 ERR("Error allocating hash table for bytecode validation\n");
1968 start_pc
= &bytecode
->code
[0];
1969 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
1971 ret
= bytecode_validate_overflow(bytecode
, start_pc
, pc
);
1974 ERR("Bytecode overflow\n");
1977 dbg_printf("Validating op %s (%u)\n",
1978 lttng_bytecode_print_op((unsigned int) *(bytecode_opcode_t
*) pc
),
1979 (unsigned int) *(bytecode_opcode_t
*) pc
);
1982 * For each instruction, validate the current context
1983 * (traversal of entire execution flow), and validate
1984 * all merge points targeting this instruction.
1986 ret
= validate_instruction_all_contexts(bytecode
, merge_points
,
1987 &stack
, start_pc
, pc
);
1990 ret
= exec_insn(bytecode
, merge_points
, &stack
, &next_pc
, pc
);
1995 if (delete_all_nodes(merge_points
)) {
1997 ERR("Unexpected merge points\n");
2001 if (lttng_ust_lfht_destroy(merge_points
)) {
2002 ERR("Error destroying hash table\n");