projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Rename "tsc" to "timestamp"
[lttng-modules.git] / src / lttng-bytecode-validator.c
1 /* SPDX-License-Identifier: MIT
2 *
3 * lttng-bytecode-validator.c
4 *
5 * LTTng modules bytecode bytecode validator.
6 *
7 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 */
9
10 #include <linux/types.h>
11 #include <linux/jhash.h>
12 #include <linux/slab.h>
13
14 #include <wrapper/list.h>
15 #include <lttng/lttng-bytecode.h>
16
17 #define MERGE_POINT_TABLE_BITS 7
18 #define MERGE_POINT_TABLE_SIZE (1U << MERGE_POINT_TABLE_BITS)
19
20 /* merge point table node */
21 struct mp_node {
22 struct hlist_node node;
23
24 /* Context at merge point */
25 struct vstack stack;
26 unsigned long target_pc;
27 };
28
29 struct mp_table {
30 struct hlist_head mp_head[MERGE_POINT_TABLE_SIZE];
31 };
32
33 static
34 int lttng_hash_match(struct mp_node *mp_node, unsigned long key_pc)
35 {
36 if (mp_node->target_pc == key_pc)
37 return 1;
38 else
39 return 0;
40 }
41
42 static
43 int merge_points_compare(const struct vstack *stacka,
44 const struct vstack *stackb)
45 {
46 int i, len;
47
48 if (stacka->top != stackb->top)
49 return 1;
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)
54 return 1;
55 }
56 return 0;
57 }
58
59 static
60 int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc,
61 const struct vstack *stack)
62 {
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;
67 int found = 0;
68
69 dbg_printk("Bytecode: adding merge point at offset %lu, hash %lu\n",
70 target_pc, hash);
71 mp_node = kzalloc(sizeof(struct mp_node), GFP_KERNEL);
72 if (!mp_node)
73 return -ENOMEM;
74 mp_node->target_pc = target_pc;
75 memcpy(&mp_node->stack, stack, sizeof(mp_node->stack));
76
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)) {
80 found = 1;
81 break;
82 }
83 }
84 if (found) {
85 /* Key already present */
86 dbg_printk("Bytecode: compare merge points for offset %lu, hash %lu\n",
87 target_pc, hash);
88 kfree(mp_node);
89 if (merge_points_compare(stack, &lookup_node->stack)) {
90 printk(KERN_WARNING "LTTng: bytecode: Merge points differ for offset %lu\n",
91 target_pc);
92 return -EINVAL;
93 }
94 } else {
95 hlist_add_head(&mp_node->node, head);
96 }
97 return 0;
98 }
99
100 /*
101 * Binary comparators use top of stack and top of stack -1.
102 */
103 static
104 int bin_op_compare_check(struct vstack *stack, const bytecode_opcode_t opcode,
105 const char *str)
106 {
107 if (unlikely(!vstack_ax(stack) || !vstack_bx(stack)))
108 goto error_empty;
109
110 switch (vstack_ax(stack)->type) {
111 default:
112 case REG_DOUBLE:
113 goto error_type;
114
115 case REG_STRING:
116 switch (vstack_bx(stack)->type) {
117 default:
118 case REG_DOUBLE:
119 goto error_type;
120 case REG_TYPE_UNKNOWN:
121 goto unknown;
122 case REG_STRING:
123 break;
124 case REG_STAR_GLOB_STRING:
125 if (opcode != BYTECODE_OP_EQ && opcode != BYTECODE_OP_NE) {
126 goto error_mismatch;
127 }
128 break;
129 case REG_S64:
130 case REG_U64:
131 goto error_mismatch;
132 }
133 break;
134 case REG_STAR_GLOB_STRING:
135 switch (vstack_bx(stack)->type) {
136 default:
137 case REG_DOUBLE:
138 goto error_type;
139 case REG_TYPE_UNKNOWN:
140 goto unknown;
141 case REG_STRING:
142 if (opcode != BYTECODE_OP_EQ && opcode != BYTECODE_OP_NE) {
143 goto error_mismatch;
144 }
145 break;
146 case REG_STAR_GLOB_STRING:
147 case REG_S64:
148 case REG_U64:
149 goto error_mismatch;
150 }
151 break;
152 case REG_S64:
153 case REG_U64:
154 switch (vstack_bx(stack)->type) {
155 default:
156 case REG_DOUBLE:
157 goto error_type;
158 case REG_TYPE_UNKNOWN:
159 goto unknown;
160 case REG_STRING:
161 case REG_STAR_GLOB_STRING:
162 goto error_mismatch;
163 case REG_S64:
164 case REG_U64:
165 break;
166 }
167 break;
168 case REG_TYPE_UNKNOWN:
169 switch (vstack_bx(stack)->type) {
170 default:
171 case REG_DOUBLE:
172 goto error_type;
173 case REG_TYPE_UNKNOWN:
174 case REG_STRING:
175 case REG_STAR_GLOB_STRING:
176 case REG_S64:
177 case REG_U64:
178 goto unknown;
179 }
180 break;
181 }
182 return 0;
183
184 unknown:
185 return 1;
186
187 error_empty:
188 printk(KERN_WARNING "LTTng: bytecode: empty stack for '%s' binary operator\n", str);
189 return -EINVAL;
190
191 error_mismatch:
192 printk(KERN_WARNING "LTTng: bytecode: type mismatch for '%s' binary operator\n", str);
193 return -EINVAL;
194
195 error_type:
196 printk(KERN_WARNING "LTTng: bytecode: unknown type for '%s' binary operator\n", str);
197 return -EINVAL;
198 }
199
200 /*
201 * Binary bitwise operators use top of stack and top of stack -1.
202 * Return 0 if typing is known to match, 1 if typing is dynamic
203 * (unknown), negative error value on error.
204 */
205 static
206 int bin_op_bitwise_check(struct vstack *stack, bytecode_opcode_t opcode,
207 const char *str)
208 {
209 if (unlikely(!vstack_ax(stack) || !vstack_bx(stack)))
210 goto error_empty;
211
212 switch (vstack_ax(stack)->type) {
213 default:
214 case REG_DOUBLE:
215 goto error_type;
216
217 case REG_TYPE_UNKNOWN:
218 switch (vstack_bx(stack)->type) {
219 default:
220 case REG_DOUBLE:
221 goto error_type;
222 case REG_TYPE_UNKNOWN:
223 case REG_S64:
224 case REG_U64:
225 goto unknown;
226 }
227 break;
228 case REG_S64:
229 case REG_U64:
230 switch (vstack_bx(stack)->type) {
231 default:
232 case REG_DOUBLE:
233 goto error_type;
234 case REG_TYPE_UNKNOWN:
235 goto unknown;
236 case REG_S64:
237 case REG_U64:
238 break;
239 }
240 break;
241 }
242 return 0;
243
244 unknown:
245 return 1;
246
247 error_empty:
248 printk(KERN_WARNING "LTTng: bytecode: empty stack for '%s' binary operator\n", str);
249 return -EINVAL;
250
251 error_type:
252 printk(KERN_WARNING "LTTng: bytecode: unknown type for '%s' binary operator\n", str);
253 return -EINVAL;
254 }
255
256 static
257 int validate_get_symbol(struct bytecode_runtime *bytecode,
258 const struct get_symbol *sym)
259 {
260 const char *str, *str_limit;
261 size_t len_limit;
262
263 if (sym->offset >= bytecode->p.bc->bc.len - bytecode->p.bc->bc.reloc_offset)
264 return -EINVAL;
265
266 str = bytecode->p.bc->bc.data + bytecode->p.bc->bc.reloc_offset + sym->offset;
267 str_limit = bytecode->p.bc->bc.data + bytecode->p.bc->bc.len;
268 len_limit = str_limit - str;
269 if (strnlen(str, len_limit) == len_limit)
270 return -EINVAL;
271 return 0;
272 }
273
274 /*
275 * Validate bytecode range overflow within the validation pass.
276 * Called for each instruction encountered.
277 */
278 static
279 int bytecode_validate_overflow(struct bytecode_runtime *bytecode,
280 char *start_pc, char *pc)
281 {
282 int ret = 0;
283
284 switch (*(bytecode_opcode_t *) pc) {
285 case BYTECODE_OP_UNKNOWN:
286 default:
287 {
288 printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n",
289 (unsigned int) *(bytecode_opcode_t *) pc);
290 ret = -EINVAL;
291 break;
292 }
293
294 case BYTECODE_OP_RETURN:
295 case BYTECODE_OP_RETURN_S64:
296 {
297 if (unlikely(pc + sizeof(struct return_op)
298 > start_pc + bytecode->len)) {
299 ret = -ERANGE;
300 }
301 break;
302 }
303
304 /* binary */
305 case BYTECODE_OP_MUL:
306 case BYTECODE_OP_DIV:
307 case BYTECODE_OP_MOD:
308 case BYTECODE_OP_PLUS:
309 case BYTECODE_OP_MINUS:
310 case BYTECODE_OP_EQ_DOUBLE:
311 case BYTECODE_OP_NE_DOUBLE:
312 case BYTECODE_OP_GT_DOUBLE:
313 case BYTECODE_OP_LT_DOUBLE:
314 case BYTECODE_OP_GE_DOUBLE:
315 case BYTECODE_OP_LE_DOUBLE:
316 /* Floating point */
317 case BYTECODE_OP_EQ_DOUBLE_S64:
318 case BYTECODE_OP_NE_DOUBLE_S64:
319 case BYTECODE_OP_GT_DOUBLE_S64:
320 case BYTECODE_OP_LT_DOUBLE_S64:
321 case BYTECODE_OP_GE_DOUBLE_S64:
322 case BYTECODE_OP_LE_DOUBLE_S64:
323 case BYTECODE_OP_EQ_S64_DOUBLE:
324 case BYTECODE_OP_NE_S64_DOUBLE:
325 case BYTECODE_OP_GT_S64_DOUBLE:
326 case BYTECODE_OP_LT_S64_DOUBLE:
327 case BYTECODE_OP_GE_S64_DOUBLE:
328 case BYTECODE_OP_LE_S64_DOUBLE:
329 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE:
330 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE:
331 case BYTECODE_OP_LOAD_DOUBLE:
332 case BYTECODE_OP_CAST_DOUBLE_TO_S64:
333 case BYTECODE_OP_UNARY_PLUS_DOUBLE:
334 case BYTECODE_OP_UNARY_MINUS_DOUBLE:
335 case BYTECODE_OP_UNARY_NOT_DOUBLE:
336 {
337 printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n",
338 (unsigned int) *(bytecode_opcode_t *) pc);
339 ret = -EINVAL;
340 break;
341 }
342
343 case BYTECODE_OP_EQ:
344 case BYTECODE_OP_NE:
345 case BYTECODE_OP_GT:
346 case BYTECODE_OP_LT:
347 case BYTECODE_OP_GE:
348 case BYTECODE_OP_LE:
349 case BYTECODE_OP_EQ_STRING:
350 case BYTECODE_OP_NE_STRING:
351 case BYTECODE_OP_GT_STRING:
352 case BYTECODE_OP_LT_STRING:
353 case BYTECODE_OP_GE_STRING:
354 case BYTECODE_OP_LE_STRING:
355 case BYTECODE_OP_EQ_STAR_GLOB_STRING:
356 case BYTECODE_OP_NE_STAR_GLOB_STRING:
357 case BYTECODE_OP_EQ_S64:
358 case BYTECODE_OP_NE_S64:
359 case BYTECODE_OP_GT_S64:
360 case BYTECODE_OP_LT_S64:
361 case BYTECODE_OP_GE_S64:
362 case BYTECODE_OP_LE_S64:
363 case BYTECODE_OP_BIT_RSHIFT:
364 case BYTECODE_OP_BIT_LSHIFT:
365 case BYTECODE_OP_BIT_AND:
366 case BYTECODE_OP_BIT_OR:
367 case BYTECODE_OP_BIT_XOR:
368 {
369 if (unlikely(pc + sizeof(struct binary_op)
370 > start_pc + bytecode->len)) {
371 ret = -ERANGE;
372 }
373 break;
374 }
375
376 /* unary */
377 case BYTECODE_OP_UNARY_PLUS:
378 case BYTECODE_OP_UNARY_MINUS:
379 case BYTECODE_OP_UNARY_NOT:
380 case BYTECODE_OP_UNARY_PLUS_S64:
381 case BYTECODE_OP_UNARY_MINUS_S64:
382 case BYTECODE_OP_UNARY_NOT_S64:
383 case BYTECODE_OP_UNARY_BIT_NOT:
384 {
385 if (unlikely(pc + sizeof(struct unary_op)
386 > start_pc + bytecode->len)) {
387 ret = -ERANGE;
388 }
389 break;
390 }
391
392 /* logical */
393 case BYTECODE_OP_AND:
394 case BYTECODE_OP_OR:
395 {
396 if (unlikely(pc + sizeof(struct logical_op)
397 > start_pc + bytecode->len)) {
398 ret = -ERANGE;
399 }
400 break;
401 }
402
403 /* load field ref */
404 case BYTECODE_OP_LOAD_FIELD_REF:
405 {
406 printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n");
407 ret = -EINVAL;
408 break;
409 }
410
411 /* get context ref */
412 case BYTECODE_OP_GET_CONTEXT_REF:
413 {
414 printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n");
415 ret = -EINVAL;
416 break;
417 }
418 case BYTECODE_OP_LOAD_FIELD_REF_STRING:
419 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE:
420 case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING:
421 case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE:
422 case BYTECODE_OP_LOAD_FIELD_REF_S64:
423 case BYTECODE_OP_GET_CONTEXT_REF_STRING:
424 case BYTECODE_OP_GET_CONTEXT_REF_S64:
425 {
426 if (unlikely(pc + sizeof(struct load_op) + sizeof(struct field_ref)
427 > start_pc + bytecode->len)) {
428 ret = -ERANGE;
429 }
430 break;
431 }
432
433 /* load from immediate operand */
434 case BYTECODE_OP_LOAD_STRING:
435 case BYTECODE_OP_LOAD_STAR_GLOB_STRING:
436 {
437 struct load_op *insn = (struct load_op *) pc;
438 uint32_t str_len, maxlen;
439
440 if (unlikely(pc + sizeof(struct load_op)
441 > start_pc + bytecode->len)) {
442 ret = -ERANGE;
443 break;
444 }
445
446 maxlen = start_pc + bytecode->len - pc - sizeof(struct load_op);
447 str_len = strnlen(insn->data, maxlen);
448 if (unlikely(str_len >= maxlen)) {
449 /* Final '\0' not found within range */
450 ret = -ERANGE;
451 }
452 break;
453 }
454
455 case BYTECODE_OP_LOAD_S64:
456 {
457 if (unlikely(pc + sizeof(struct load_op) + sizeof(struct literal_numeric)
458 > start_pc + bytecode->len)) {
459 ret = -ERANGE;
460 }
461 break;
462 }
463
464 case BYTECODE_OP_CAST_TO_S64:
465 case BYTECODE_OP_CAST_NOP:
466 {
467 if (unlikely(pc + sizeof(struct cast_op)
468 > start_pc + bytecode->len)) {
469 ret = -ERANGE;
470 }
471 break;
472 }
473
474 /*
475 * Instructions for recursive traversal through composed types.
476 */
477 case BYTECODE_OP_GET_CONTEXT_ROOT:
478 case BYTECODE_OP_GET_APP_CONTEXT_ROOT:
479 case BYTECODE_OP_GET_PAYLOAD_ROOT:
480 case BYTECODE_OP_LOAD_FIELD:
481 case BYTECODE_OP_LOAD_FIELD_S8:
482 case BYTECODE_OP_LOAD_FIELD_S16:
483 case BYTECODE_OP_LOAD_FIELD_S32:
484 case BYTECODE_OP_LOAD_FIELD_S64:
485 case BYTECODE_OP_LOAD_FIELD_U8:
486 case BYTECODE_OP_LOAD_FIELD_U16:
487 case BYTECODE_OP_LOAD_FIELD_U32:
488 case BYTECODE_OP_LOAD_FIELD_U64:
489 case BYTECODE_OP_LOAD_FIELD_STRING:
490 case BYTECODE_OP_LOAD_FIELD_SEQUENCE:
491 case BYTECODE_OP_LOAD_FIELD_DOUBLE:
492 if (unlikely(pc + sizeof(struct load_op)
493 > start_pc + bytecode->len)) {
494 ret = -ERANGE;
495 }
496 break;
497
498 case BYTECODE_OP_GET_SYMBOL:
499 {
500 struct load_op *insn = (struct load_op *) pc;
501 struct get_symbol *sym = (struct get_symbol *) insn->data;
502
503 if (unlikely(pc + sizeof(struct load_op) + sizeof(struct get_symbol)
504 > start_pc + bytecode->len)) {
505 ret = -ERANGE;
506 break;
507 }
508 ret = validate_get_symbol(bytecode, sym);
509 break;
510 }
511
512 case BYTECODE_OP_GET_SYMBOL_FIELD:
513 printk(KERN_WARNING "LTTng: bytecode: Unexpected get symbol field\n");
514 ret = -EINVAL;
515 break;
516
517 case BYTECODE_OP_GET_INDEX_U16:
518 if (unlikely(pc + sizeof(struct load_op) + sizeof(struct get_index_u16)
519 > start_pc + bytecode->len)) {
520 ret = -ERANGE;
521 }
522 break;
523
524 case BYTECODE_OP_GET_INDEX_U64:
525 if (unlikely(pc + sizeof(struct load_op) + sizeof(struct get_index_u64)
526 > start_pc + bytecode->len)) {
527 ret = -ERANGE;
528 }
529 break;
530 }
531
532 return ret;
533 }
534
535 static
536 unsigned long delete_all_nodes(struct mp_table *mp_table)
537 {
538 struct mp_node *mp_node;
539 struct hlist_node *tmp;
540 unsigned long nr_nodes = 0;
541 int i;
542
543 for (i = 0; i < MERGE_POINT_TABLE_SIZE; i++) {
544 struct hlist_head *head;
545
546 head = &mp_table->mp_head[i];
547 lttng_hlist_for_each_entry_safe(mp_node, tmp, head, node) {
548 kfree(mp_node);
549 nr_nodes++;
550 }
551 }
552 return nr_nodes;
553 }
554
555 /*
556 * Return value:
557 * >=0: success
558 * <0: error
559 */
560 static
561 int validate_instruction_context(struct bytecode_runtime *bytecode,
562 struct vstack *stack,
563 char *start_pc,
564 char *pc)
565 {
566 int ret = 0;
567 const bytecode_opcode_t opcode = *(bytecode_opcode_t *) pc;
568
569 switch (opcode) {
570 case BYTECODE_OP_UNKNOWN:
571 default:
572 {
573 printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n",
574 (unsigned int) *(bytecode_opcode_t *) pc);
575 ret = -EINVAL;
576 goto end;
577 }
578
579 case BYTECODE_OP_RETURN:
580 case BYTECODE_OP_RETURN_S64:
581 {
582 goto end;
583 }
584
585 /* binary */
586 case BYTECODE_OP_MUL:
587 case BYTECODE_OP_DIV:
588 case BYTECODE_OP_MOD:
589 case BYTECODE_OP_PLUS:
590 case BYTECODE_OP_MINUS:
591 /* Floating point */
592 case BYTECODE_OP_EQ_DOUBLE:
593 case BYTECODE_OP_NE_DOUBLE:
594 case BYTECODE_OP_GT_DOUBLE:
595 case BYTECODE_OP_LT_DOUBLE:
596 case BYTECODE_OP_GE_DOUBLE:
597 case BYTECODE_OP_LE_DOUBLE:
598 case BYTECODE_OP_EQ_DOUBLE_S64:
599 case BYTECODE_OP_NE_DOUBLE_S64:
600 case BYTECODE_OP_GT_DOUBLE_S64:
601 case BYTECODE_OP_LT_DOUBLE_S64:
602 case BYTECODE_OP_GE_DOUBLE_S64:
603 case BYTECODE_OP_LE_DOUBLE_S64:
604 case BYTECODE_OP_EQ_S64_DOUBLE:
605 case BYTECODE_OP_NE_S64_DOUBLE:
606 case BYTECODE_OP_GT_S64_DOUBLE:
607 case BYTECODE_OP_LT_S64_DOUBLE:
608 case BYTECODE_OP_GE_S64_DOUBLE:
609 case BYTECODE_OP_LE_S64_DOUBLE:
610 case BYTECODE_OP_UNARY_PLUS_DOUBLE:
611 case BYTECODE_OP_UNARY_MINUS_DOUBLE:
612 case BYTECODE_OP_UNARY_NOT_DOUBLE:
613 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE:
614 case BYTECODE_OP_LOAD_DOUBLE:
615 case BYTECODE_OP_CAST_DOUBLE_TO_S64:
616 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE:
617 {
618 printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n",
619 (unsigned int) *(bytecode_opcode_t *) pc);
620 ret = -EINVAL;
621 goto end;
622 }
623
624 case BYTECODE_OP_EQ:
625 {
626 ret = bin_op_compare_check(stack, opcode, "==");
627 if (ret < 0)
628 goto end;
629 break;
630 }
631 case BYTECODE_OP_NE:
632 {
633 ret = bin_op_compare_check(stack, opcode, "!=");
634 if (ret < 0)
635 goto end;
636 break;
637 }
638 case BYTECODE_OP_GT:
639 {
640 ret = bin_op_compare_check(stack, opcode, ">");
641 if (ret < 0)
642 goto end;
643 break;
644 }
645 case BYTECODE_OP_LT:
646 {
647 ret = bin_op_compare_check(stack, opcode, "<");
648 if (ret < 0)
649 goto end;
650 break;
651 }
652 case BYTECODE_OP_GE:
653 {
654 ret = bin_op_compare_check(stack, opcode, ">=");
655 if (ret < 0)
656 goto end;
657 break;
658 }
659 case BYTECODE_OP_LE:
660 {
661 ret = bin_op_compare_check(stack, opcode, "<=");
662 if (ret < 0)
663 goto end;
664 break;
665 }
666
667 case BYTECODE_OP_EQ_STRING:
668 case BYTECODE_OP_NE_STRING:
669 case BYTECODE_OP_GT_STRING:
670 case BYTECODE_OP_LT_STRING:
671 case BYTECODE_OP_GE_STRING:
672 case BYTECODE_OP_LE_STRING:
673 {
674 if (!vstack_ax(stack) || !vstack_bx(stack)) {
675 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
676 ret = -EINVAL;
677 goto end;
678 }
679 if (vstack_ax(stack)->type != REG_STRING
680 || vstack_bx(stack)->type != REG_STRING) {
681 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for string comparator\n");
682 ret = -EINVAL;
683 goto end;
684 }
685 break;
686 }
687
688
689 case BYTECODE_OP_EQ_STAR_GLOB_STRING:
690 case BYTECODE_OP_NE_STAR_GLOB_STRING:
691 {
692 if (!vstack_ax(stack) || !vstack_bx(stack)) {
693 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
694 ret = -EINVAL;
695 goto end;
696 }
697 if (vstack_ax(stack)->type != REG_STAR_GLOB_STRING
698 && vstack_bx(stack)->type != REG_STAR_GLOB_STRING) {
699 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for globbing pattern comparator\n");
700 ret = -EINVAL;
701 goto end;
702 }
703 break;
704 }
705
706 case BYTECODE_OP_EQ_S64:
707 case BYTECODE_OP_NE_S64:
708 case BYTECODE_OP_GT_S64:
709 case BYTECODE_OP_LT_S64:
710 case BYTECODE_OP_GE_S64:
711 case BYTECODE_OP_LE_S64:
712 {
713 if (!vstack_ax(stack) || !vstack_bx(stack)) {
714 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
715 ret = -EINVAL;
716 goto end;
717 }
718 switch (vstack_ax(stack)->type) {
719 case REG_S64:
720 case REG_U64:
721 break;
722 default:
723 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for s64 comparator\n");
724 ret = -EINVAL;
725 goto end;
726 }
727 switch (vstack_bx(stack)->type) {
728 case REG_S64:
729 case REG_U64:
730 break;
731 default:
732 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for s64 comparator\n");
733 ret = -EINVAL;
734 goto end;
735 }
736 break;
737 }
738
739 case BYTECODE_OP_BIT_RSHIFT:
740 ret = bin_op_bitwise_check(stack, opcode, ">>");
741 if (ret < 0)
742 goto end;
743 break;
744 case BYTECODE_OP_BIT_LSHIFT:
745 ret = bin_op_bitwise_check(stack, opcode, "<<");
746 if (ret < 0)
747 goto end;
748 break;
749 case BYTECODE_OP_BIT_AND:
750 ret = bin_op_bitwise_check(stack, opcode, "&");
751 if (ret < 0)
752 goto end;
753 break;
754 case BYTECODE_OP_BIT_OR:
755 ret = bin_op_bitwise_check(stack, opcode, "|");
756 if (ret < 0)
757 goto end;
758 break;
759 case BYTECODE_OP_BIT_XOR:
760 ret = bin_op_bitwise_check(stack, opcode, "^");
761 if (ret < 0)
762 goto end;
763 break;
764
765 /* unary */
766 case BYTECODE_OP_UNARY_PLUS:
767 case BYTECODE_OP_UNARY_MINUS:
768 case BYTECODE_OP_UNARY_NOT:
769 {
770 if (!vstack_ax(stack)) {
771 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
772 ret = -EINVAL;
773 goto end;
774 }
775 switch (vstack_ax(stack)->type) {
776 default:
777 case REG_DOUBLE:
778 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
779 ret = -EINVAL;
780 goto end;
781
782 case REG_STRING:
783 case REG_STAR_GLOB_STRING:
784 printk(KERN_WARNING "LTTng: bytecode: Unary op can only be applied to numeric or floating point registers\n");
785 ret = -EINVAL;
786 goto end;
787 case REG_S64:
788 case REG_U64:
789 case REG_TYPE_UNKNOWN:
790 break;
791 }
792 break;
793 }
794 case BYTECODE_OP_UNARY_BIT_NOT:
795 {
796 if (!vstack_ax(stack)) {
797 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
798 ret = -EINVAL;
799 goto end;
800 }
801 switch (vstack_ax(stack)->type) {
802 default:
803 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
804 ret = -EINVAL;
805 goto end;
806
807 case REG_STRING:
808 case REG_STAR_GLOB_STRING:
809 case REG_DOUBLE:
810 printk(KERN_WARNING "LTTng: bytecode: Unary bitwise op can only be applied to numeric registers\n");
811 ret = -EINVAL;
812 goto end;
813 case REG_S64:
814 case REG_U64:
815 case REG_TYPE_UNKNOWN:
816 break;
817 }
818 break;
819 }
820
821 case BYTECODE_OP_UNARY_PLUS_S64:
822 case BYTECODE_OP_UNARY_MINUS_S64:
823 case BYTECODE_OP_UNARY_NOT_S64:
824 {
825 if (!vstack_ax(stack)) {
826 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
827 ret = -EINVAL;
828 goto end;
829 }
830 if (vstack_ax(stack)->type != REG_S64 &&
831 vstack_ax(stack)->type != REG_U64) {
832 printk(KERN_WARNING "LTTng: bytecode: Invalid register type\n");
833 ret = -EINVAL;
834 goto end;
835 }
836 break;
837 }
838
839 /* logical */
840 case BYTECODE_OP_AND:
841 case BYTECODE_OP_OR:
842 {
843 struct logical_op *insn = (struct logical_op *) pc;
844
845 if (!vstack_ax(stack)) {
846 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
847 ret = -EINVAL;
848 goto end;
849 }
850 if (vstack_ax(stack)->type != REG_S64 &&
851 vstack_ax(stack)->type != REG_U64) {
852 printk(KERN_WARNING "LTTng: bytecode: Logical comparator expects S64 register\n");
853 ret = -EINVAL;
854 goto end;
855 }
856
857 dbg_printk("Validate jumping to bytecode offset %u\n",
858 (unsigned int) insn->skip_offset);
859 if (unlikely(start_pc + insn->skip_offset <= pc)) {
860 printk(KERN_WARNING "LTTng: bytecode: Loops are not allowed in bytecode\n");
861 ret = -EINVAL;
862 goto end;
863 }
864 break;
865 }
866
867 /* load field ref */
868 case BYTECODE_OP_LOAD_FIELD_REF:
869 {
870 printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n");
871 ret = -EINVAL;
872 goto end;
873 }
874 case BYTECODE_OP_LOAD_FIELD_REF_STRING:
875 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE:
876 case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING:
877 case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE:
878 {
879 struct load_op *insn = (struct load_op *) pc;
880 struct field_ref *ref = (struct field_ref *) insn->data;
881
882 dbg_printk("Validate load field ref offset %u type string\n",
883 ref->offset);
884 break;
885 }
886 case BYTECODE_OP_LOAD_FIELD_REF_S64:
887 {
888 struct load_op *insn = (struct load_op *) pc;
889 struct field_ref *ref = (struct field_ref *) insn->data;
890
891 dbg_printk("Validate load field ref offset %u type s64\n",
892 ref->offset);
893 break;
894 }
895
896 /* load from immediate operand */
897 case BYTECODE_OP_LOAD_STRING:
898 case BYTECODE_OP_LOAD_STAR_GLOB_STRING:
899 {
900 break;
901 }
902
903 case BYTECODE_OP_LOAD_S64:
904 {
905 break;
906 }
907
908 case BYTECODE_OP_CAST_TO_S64:
909 {
910 struct cast_op *insn = (struct cast_op *) pc;
911
912 if (!vstack_ax(stack)) {
913 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
914 ret = -EINVAL;
915 goto end;
916 }
917 switch (vstack_ax(stack)->type) {
918 default:
919 case REG_DOUBLE:
920 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
921 ret = -EINVAL;
922 goto end;
923
924 case REG_STRING:
925 case REG_STAR_GLOB_STRING:
926 printk(KERN_WARNING "LTTng: bytecode: Cast op can only be applied to numeric or floating point registers\n");
927 ret = -EINVAL;
928 goto end;
929 case REG_S64:
930 break;
931 }
932 if (insn->op == BYTECODE_OP_CAST_DOUBLE_TO_S64) {
933 if (vstack_ax(stack)->type != REG_DOUBLE) {
934 printk(KERN_WARNING "LTTng: bytecode: Cast expects double\n");
935 ret = -EINVAL;
936 goto end;
937 }
938 }
939 break;
940 }
941 case BYTECODE_OP_CAST_NOP:
942 {
943 break;
944 }
945
946 /* get context ref */
947 case BYTECODE_OP_GET_CONTEXT_REF:
948 {
949 printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n");
950 ret = -EINVAL;
951 goto end;
952 }
953 case BYTECODE_OP_GET_CONTEXT_REF_STRING:
954 {
955 struct load_op *insn = (struct load_op *) pc;
956 struct field_ref *ref = (struct field_ref *) insn->data;
957
958 dbg_printk("Validate get context ref offset %u type string\n",
959 ref->offset);
960 break;
961 }
962 case BYTECODE_OP_GET_CONTEXT_REF_S64:
963 {
964 struct load_op *insn = (struct load_op *) pc;
965 struct field_ref *ref = (struct field_ref *) insn->data;
966
967 dbg_printk("Validate get context ref offset %u type s64\n",
968 ref->offset);
969 break;
970 }
971
972 /*
973 * Instructions for recursive traversal through composed types.
974 */
975 case BYTECODE_OP_GET_CONTEXT_ROOT:
976 {
977 dbg_printk("Validate get context root\n");
978 break;
979 }
980 case BYTECODE_OP_GET_APP_CONTEXT_ROOT:
981 {
982 dbg_printk("Validate get app context root\n");
983 break;
984 }
985 case BYTECODE_OP_GET_PAYLOAD_ROOT:
986 {
987 dbg_printk("Validate get payload root\n");
988 break;
989 }
990 case BYTECODE_OP_LOAD_FIELD:
991 {
992 /*
993 * We tolerate that field type is unknown at validation,
994 * because we are performing the load specialization in
995 * a phase after validation.
996 */
997 dbg_printk("Validate load field\n");
998 break;
999 }
1000 case BYTECODE_OP_LOAD_FIELD_S8:
1001 {
1002 dbg_printk("Validate load field s8\n");
1003 break;
1004 }
1005 case BYTECODE_OP_LOAD_FIELD_S16:
1006 {
1007 dbg_printk("Validate load field s16\n");
1008 break;
1009 }
1010 case BYTECODE_OP_LOAD_FIELD_S32:
1011 {
1012 dbg_printk("Validate load field s32\n");
1013 break;
1014 }
1015 case BYTECODE_OP_LOAD_FIELD_S64:
1016 {
1017 dbg_printk("Validate load field s64\n");
1018 break;
1019 }
1020 case BYTECODE_OP_LOAD_FIELD_U8:
1021 {
1022 dbg_printk("Validate load field u8\n");
1023 break;
1024 }
1025 case BYTECODE_OP_LOAD_FIELD_U16:
1026 {
1027 dbg_printk("Validate load field u16\n");
1028 break;
1029 }
1030 case BYTECODE_OP_LOAD_FIELD_U32:
1031 {
1032 dbg_printk("Validate load field u32\n");
1033 break;
1034 }
1035 case BYTECODE_OP_LOAD_FIELD_U64:
1036 {
1037 dbg_printk("Validate load field u64\n");
1038 break;
1039 }
1040 case BYTECODE_OP_LOAD_FIELD_STRING:
1041 {
1042 dbg_printk("Validate load field string\n");
1043 break;
1044 }
1045 case BYTECODE_OP_LOAD_FIELD_SEQUENCE:
1046 {
1047 dbg_printk("Validate load field sequence\n");
1048 break;
1049 }
1050 case BYTECODE_OP_LOAD_FIELD_DOUBLE:
1051 {
1052 dbg_printk("Validate load field double\n");
1053 break;
1054 }
1055
1056 case BYTECODE_OP_GET_SYMBOL:
1057 {
1058 struct load_op *insn = (struct load_op *) pc;
1059 struct get_symbol *sym = (struct get_symbol *) insn->data;
1060
1061 dbg_printk("Validate get symbol offset %u\n", sym->offset);
1062 break;
1063 }
1064
1065 case BYTECODE_OP_GET_SYMBOL_FIELD:
1066 {
1067 struct load_op *insn = (struct load_op *) pc;
1068 struct get_symbol *sym = (struct get_symbol *) insn->data;
1069
1070 dbg_printk("Validate get symbol field offset %u\n", sym->offset);
1071 break;
1072 }
1073
1074 case BYTECODE_OP_GET_INDEX_U16:
1075 {
1076 struct load_op *insn = (struct load_op *) pc;
1077 struct get_index_u16 *get_index = (struct get_index_u16 *) insn->data;
1078
1079 dbg_printk("Validate get index u16 index %u\n", get_index->index);
1080 break;
1081 }
1082
1083 case BYTECODE_OP_GET_INDEX_U64:
1084 {
1085 struct load_op *insn = (struct load_op *) pc;
1086 struct get_index_u64 *get_index = (struct get_index_u64 *) insn->data;
1087
1088 dbg_printk("Validate get index u64 index %llu\n",
1089 (unsigned long long) get_index->index);
1090 break;
1091 }
1092 }
1093 end:
1094 return ret;
1095 }
1096
1097 /*
1098 * Return value:
1099 * 0: success
1100 * <0: error
1101 */
1102 static
1103 int validate_instruction_all_contexts(struct bytecode_runtime *bytecode,
1104 struct mp_table *mp_table,
1105 struct vstack *stack,
1106 char *start_pc,
1107 char *pc)
1108 {
1109 int ret, found = 0;
1110 unsigned long target_pc = pc - start_pc;
1111 unsigned long hash;
1112 struct hlist_head *head;
1113 struct mp_node *mp_node;
1114
1115 /* Validate the context resulting from the previous instruction */
1116 ret = validate_instruction_context(bytecode, stack, start_pc, pc);
1117 if (ret < 0)
1118 return ret;
1119
1120 /* Validate merge points */
1121 hash = jhash_1word(target_pc, 0);
1122 head = &mp_table->mp_head[hash & (MERGE_POINT_TABLE_SIZE - 1)];
1123 lttng_hlist_for_each_entry(mp_node, head, node) {
1124 if (lttng_hash_match(mp_node, target_pc)) {
1125 found = 1;
1126 break;
1127 }
1128 }
1129 if (found) {
1130 dbg_printk("Bytecode: validate merge point at offset %lu\n",
1131 target_pc);
1132 if (merge_points_compare(stack, &mp_node->stack)) {
1133 printk(KERN_WARNING "LTTng: bytecode: Merge points differ for offset %lu\n",
1134 target_pc);
1135 return -EINVAL;
1136 }
1137 /* Once validated, we can remove the merge point */
1138 dbg_printk("Bytecode: remove merge point at offset %lu\n",
1139 target_pc);
1140 hlist_del(&mp_node->node);
1141 }
1142 return 0;
1143 }
1144
1145 /*
1146 * Return value:
1147 * >0: going to next insn.
1148 * 0: success, stop iteration.
1149 * <0: error
1150 */
1151 static
1152 int exec_insn(struct bytecode_runtime *bytecode,
1153 struct mp_table *mp_table,
1154 struct vstack *stack,
1155 char **_next_pc,
1156 char *pc)
1157 {
1158 int ret = 1;
1159 char *next_pc = *_next_pc;
1160
1161 switch (*(bytecode_opcode_t *) pc) {
1162 case BYTECODE_OP_UNKNOWN:
1163 default:
1164 {
1165 printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n",
1166 (unsigned int) *(bytecode_opcode_t *) pc);
1167 ret = -EINVAL;
1168 goto end;
1169 }
1170
1171 case BYTECODE_OP_RETURN:
1172 {
1173 if (!vstack_ax(stack)) {
1174 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
1175 ret = -EINVAL;
1176 goto end;
1177 }
1178 switch (vstack_ax(stack)->type) {
1179 case REG_S64:
1180 case REG_U64:
1181 case REG_DOUBLE:
1182 case REG_STRING:
1183 case REG_PTR:
1184 case REG_TYPE_UNKNOWN:
1185 break;
1186 default:
1187 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d at end of bytecode\n",
1188 (int) vstack_ax(stack)->type);
1189 ret = -EINVAL;
1190 goto end;
1191 }
1192
1193 ret = 0;
1194 goto end;
1195 }
1196
1197 case BYTECODE_OP_RETURN_S64:
1198 {
1199 if (!vstack_ax(stack)) {
1200 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
1201 ret = -EINVAL;
1202 goto end;
1203 }
1204 switch (vstack_ax(stack)->type) {
1205 case REG_S64:
1206 case REG_U64:
1207 break;
1208 default:
1209 case REG_TYPE_UNKNOWN:
1210 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d at end of bytecode\n",
1211 (int) vstack_ax(stack)->type);
1212 ret = -EINVAL;
1213 goto end;
1214 }
1215
1216 ret = 0;
1217 goto end;
1218 }
1219
1220 /* binary */
1221 case BYTECODE_OP_MUL:
1222 case BYTECODE_OP_DIV:
1223 case BYTECODE_OP_MOD:
1224 case BYTECODE_OP_PLUS:
1225 case BYTECODE_OP_MINUS:
1226 /* Floating point */
1227 case BYTECODE_OP_EQ_DOUBLE:
1228 case BYTECODE_OP_NE_DOUBLE:
1229 case BYTECODE_OP_GT_DOUBLE:
1230 case BYTECODE_OP_LT_DOUBLE:
1231 case BYTECODE_OP_GE_DOUBLE:
1232 case BYTECODE_OP_LE_DOUBLE:
1233 case BYTECODE_OP_EQ_DOUBLE_S64:
1234 case BYTECODE_OP_NE_DOUBLE_S64:
1235 case BYTECODE_OP_GT_DOUBLE_S64:
1236 case BYTECODE_OP_LT_DOUBLE_S64:
1237 case BYTECODE_OP_GE_DOUBLE_S64:
1238 case BYTECODE_OP_LE_DOUBLE_S64:
1239 case BYTECODE_OP_EQ_S64_DOUBLE:
1240 case BYTECODE_OP_NE_S64_DOUBLE:
1241 case BYTECODE_OP_GT_S64_DOUBLE:
1242 case BYTECODE_OP_LT_S64_DOUBLE:
1243 case BYTECODE_OP_GE_S64_DOUBLE:
1244 case BYTECODE_OP_LE_S64_DOUBLE:
1245 case BYTECODE_OP_UNARY_PLUS_DOUBLE:
1246 case BYTECODE_OP_UNARY_MINUS_DOUBLE:
1247 case BYTECODE_OP_UNARY_NOT_DOUBLE:
1248 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE:
1249 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE:
1250 case BYTECODE_OP_LOAD_DOUBLE:
1251 case BYTECODE_OP_CAST_DOUBLE_TO_S64:
1252 {
1253 printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n",
1254 (unsigned int) *(bytecode_opcode_t *) pc);
1255 ret = -EINVAL;
1256 goto end;
1257 }
1258
1259 case BYTECODE_OP_EQ:
1260 case BYTECODE_OP_NE:
1261 case BYTECODE_OP_GT:
1262 case BYTECODE_OP_LT:
1263 case BYTECODE_OP_GE:
1264 case BYTECODE_OP_LE:
1265 case BYTECODE_OP_EQ_STRING:
1266 case BYTECODE_OP_NE_STRING:
1267 case BYTECODE_OP_GT_STRING:
1268 case BYTECODE_OP_LT_STRING:
1269 case BYTECODE_OP_GE_STRING:
1270 case BYTECODE_OP_LE_STRING:
1271 case BYTECODE_OP_EQ_STAR_GLOB_STRING:
1272 case BYTECODE_OP_NE_STAR_GLOB_STRING:
1273 case BYTECODE_OP_EQ_S64:
1274 case BYTECODE_OP_NE_S64:
1275 case BYTECODE_OP_GT_S64:
1276 case BYTECODE_OP_LT_S64:
1277 case BYTECODE_OP_GE_S64:
1278 case BYTECODE_OP_LE_S64:
1279 {
1280 /* Pop 2, push 1 */
1281 if (vstack_pop(stack)) {
1282 ret = -EINVAL;
1283 goto end;
1284 }
1285 if (!vstack_ax(stack)) {
1286 printk(KERN_WARNING "Empty stack\n");
1287 ret = -EINVAL;
1288 goto end;
1289 }
1290 switch (vstack_ax(stack)->type) {
1291 case REG_S64:
1292 case REG_U64:
1293 case REG_DOUBLE:
1294 case REG_STRING:
1295 case REG_STAR_GLOB_STRING:
1296 case REG_TYPE_UNKNOWN:
1297 break;
1298 default:
1299 printk(KERN_WARNING "Unexpected register type %d for operation\n",
1300 (int) vstack_ax(stack)->type);
1301 ret = -EINVAL;
1302 goto end;
1303 }
1304
1305 vstack_ax(stack)->type = REG_S64;
1306 next_pc += sizeof(struct binary_op);
1307 break;
1308 }
1309 case BYTECODE_OP_BIT_RSHIFT:
1310 case BYTECODE_OP_BIT_LSHIFT:
1311 case BYTECODE_OP_BIT_AND:
1312 case BYTECODE_OP_BIT_OR:
1313 case BYTECODE_OP_BIT_XOR:
1314 {
1315 /* Pop 2, push 1 */
1316 if (vstack_pop(stack)) {
1317 ret = -EINVAL;
1318 goto end;
1319 }
1320 if (!vstack_ax(stack)) {
1321 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
1322 ret = -EINVAL;
1323 goto end;
1324 }
1325 switch (vstack_ax(stack)->type) {
1326 case REG_S64:
1327 case REG_U64:
1328 case REG_DOUBLE:
1329 case REG_STRING:
1330 case REG_STAR_GLOB_STRING:
1331 case REG_TYPE_UNKNOWN:
1332 break;
1333 default:
1334 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n",
1335 (int) vstack_ax(stack)->type);
1336 ret = -EINVAL;
1337 goto end;
1338 }
1339
1340 vstack_ax(stack)->type = REG_U64;
1341 next_pc += sizeof(struct binary_op);
1342 break;
1343 }
1344
1345 /* unary */
1346 case BYTECODE_OP_UNARY_PLUS:
1347 case BYTECODE_OP_UNARY_MINUS:
1348 {
1349 /* Pop 1, push 1 */
1350 if (!vstack_ax(stack)) {
1351 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1352 ret = -EINVAL;
1353 goto end;
1354 }
1355 switch (vstack_ax(stack)->type) {
1356 case REG_S64:
1357 case REG_U64:
1358 case REG_TYPE_UNKNOWN:
1359 break;
1360 default:
1361 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n",
1362 (int) vstack_ax(stack)->type);
1363 ret = -EINVAL;
1364 goto end;
1365 }
1366
1367 vstack_ax(stack)->type = REG_TYPE_UNKNOWN;
1368 next_pc += sizeof(struct unary_op);
1369 break;
1370 }
1371
1372 case BYTECODE_OP_UNARY_PLUS_S64:
1373 case BYTECODE_OP_UNARY_MINUS_S64:
1374 case BYTECODE_OP_UNARY_NOT_S64:
1375 {
1376 /* Pop 1, push 1 */
1377 if (!vstack_ax(stack)) {
1378 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1379 ret = -EINVAL;
1380 goto end;
1381 }
1382 switch (vstack_ax(stack)->type) {
1383 case REG_S64:
1384 case REG_U64:
1385 break;
1386 default:
1387 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n",
1388 (int) vstack_ax(stack)->type);
1389 ret = -EINVAL;
1390 goto end;
1391 }
1392
1393 next_pc += sizeof(struct unary_op);
1394 break;
1395 }
1396
1397 case BYTECODE_OP_UNARY_NOT:
1398 {
1399 /* Pop 1, push 1 */
1400 if (!vstack_ax(stack)) {
1401 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1402 ret = -EINVAL;
1403 goto end;
1404 }
1405 switch (vstack_ax(stack)->type) {
1406 case REG_S64:
1407 case REG_U64:
1408 case REG_TYPE_UNKNOWN:
1409 break;
1410 default:
1411 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n",
1412 (int) vstack_ax(stack)->type);
1413 ret = -EINVAL;
1414 goto end;
1415 }
1416
1417 next_pc += sizeof(struct unary_op);
1418 break;
1419 }
1420
1421 case BYTECODE_OP_UNARY_BIT_NOT:
1422 {
1423 /* Pop 1, push 1 */
1424 if (!vstack_ax(stack)) {
1425 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
1426 ret = -EINVAL;
1427 goto end;
1428 }
1429 switch (vstack_ax(stack)->type) {
1430 case REG_S64:
1431 case REG_U64:
1432 case REG_TYPE_UNKNOWN:
1433 break;
1434 case REG_DOUBLE:
1435 default:
1436 printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n",
1437 (int) vstack_ax(stack)->type);
1438 ret = -EINVAL;
1439 goto end;
1440 }
1441
1442 vstack_ax(stack)->type = REG_U64;
1443 next_pc += sizeof(struct unary_op);
1444 break;
1445 }
1446
1447 /* logical */
1448 case BYTECODE_OP_AND:
1449 case BYTECODE_OP_OR:
1450 {
1451 struct logical_op *insn = (struct logical_op *) pc;
1452 int merge_ret;
1453
1454 /* Add merge point to table */
1455 merge_ret = merge_point_add_check(mp_table,
1456 insn->skip_offset, stack);
1457 if (merge_ret) {
1458 ret = merge_ret;
1459 goto end;
1460 }
1461
1462 if (!vstack_ax(stack)) {
1463 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1464 ret = -EINVAL;
1465 goto end;
1466 }
1467 /* There is always a cast-to-s64 operation before a or/and op. */
1468 switch (vstack_ax(stack)->type) {
1469 case REG_S64:
1470 case REG_U64:
1471 break;
1472 default:
1473 printk(KERN_WARNING "LTTng: bytecode: Incorrect register type %d for operation\n",
1474 (int) vstack_ax(stack)->type);
1475 ret = -EINVAL;
1476 goto end;
1477 }
1478
1479 /* Continue to next instruction */
1480 /* Pop 1 when jump not taken */
1481 if (vstack_pop(stack)) {
1482 ret = -EINVAL;
1483 goto end;
1484 }
1485 next_pc += sizeof(struct logical_op);
1486 break;
1487 }
1488
1489 /* load field ref */
1490 case BYTECODE_OP_LOAD_FIELD_REF:
1491 {
1492 printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n");
1493 ret = -EINVAL;
1494 goto end;
1495 }
1496 /* get context ref */
1497 case BYTECODE_OP_GET_CONTEXT_REF:
1498 {
1499 printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n");
1500 ret = -EINVAL;
1501 goto end;
1502 }
1503 case BYTECODE_OP_LOAD_FIELD_REF_STRING:
1504 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE:
1505 case BYTECODE_OP_GET_CONTEXT_REF_STRING:
1506 case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING:
1507 case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE:
1508 {
1509 if (vstack_push(stack)) {
1510 ret = -EINVAL;
1511 goto end;
1512 }
1513 vstack_ax(stack)->type = REG_STRING;
1514 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
1515 break;
1516 }
1517 case BYTECODE_OP_LOAD_FIELD_REF_S64:
1518 case BYTECODE_OP_GET_CONTEXT_REF_S64:
1519 {
1520 if (vstack_push(stack)) {
1521 ret = -EINVAL;
1522 goto end;
1523 }
1524 vstack_ax(stack)->type = REG_S64;
1525 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
1526 break;
1527 }
1528
1529 /* load from immediate operand */
1530 case BYTECODE_OP_LOAD_STRING:
1531 {
1532 struct load_op *insn = (struct load_op *) pc;
1533
1534 if (vstack_push(stack)) {
1535 ret = -EINVAL;
1536 goto end;
1537 }
1538 vstack_ax(stack)->type = REG_STRING;
1539 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
1540 break;
1541 }
1542
1543 case BYTECODE_OP_LOAD_STAR_GLOB_STRING:
1544 {
1545 struct load_op *insn = (struct load_op *) pc;
1546
1547 if (vstack_push(stack)) {
1548 ret = -EINVAL;
1549 goto end;
1550 }
1551 vstack_ax(stack)->type = REG_STAR_GLOB_STRING;
1552 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
1553 break;
1554 }
1555
1556 case BYTECODE_OP_LOAD_S64:
1557 {
1558 if (vstack_push(stack)) {
1559 ret = -EINVAL;
1560 goto end;
1561 }
1562 vstack_ax(stack)->type = REG_S64;
1563 next_pc += sizeof(struct load_op)
1564 + sizeof(struct literal_numeric);
1565 break;
1566 }
1567
1568 case BYTECODE_OP_CAST_TO_S64:
1569 {
1570 /* Pop 1, push 1 */
1571 if (!vstack_ax(stack)) {
1572 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n");
1573 ret = -EINVAL;
1574 goto end;
1575 }
1576 switch (vstack_ax(stack)->type) {
1577 case REG_S64:
1578 case REG_U64:
1579 case REG_DOUBLE:
1580 case REG_TYPE_UNKNOWN:
1581 break;
1582 default:
1583 printk(KERN_WARNING "LTTng: bytecode: Incorrect register type %d for cast\n",
1584 (int) vstack_ax(stack)->type);
1585 ret = -EINVAL;
1586 goto end;
1587 }
1588 vstack_ax(stack)->type = REG_S64;
1589 next_pc += sizeof(struct cast_op);
1590 break;
1591 }
1592 case BYTECODE_OP_CAST_NOP:
1593 {
1594 next_pc += sizeof(struct cast_op);
1595 break;
1596 }
1597
1598 /*
1599 * Instructions for recursive traversal through composed types.
1600 */
1601 case BYTECODE_OP_GET_CONTEXT_ROOT:
1602 case BYTECODE_OP_GET_APP_CONTEXT_ROOT:
1603 case BYTECODE_OP_GET_PAYLOAD_ROOT:
1604 {
1605 if (vstack_push(stack)) {
1606 ret = -EINVAL;
1607 goto end;
1608 }
1609 vstack_ax(stack)->type = REG_PTR;
1610 next_pc += sizeof(struct load_op);
1611 break;
1612 }
1613
1614 case BYTECODE_OP_LOAD_FIELD:
1615 {
1616 /* Pop 1, push 1 */
1617 if (!vstack_ax(stack)) {
1618 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1619 ret = -EINVAL;
1620 goto end;
1621 }
1622 if (vstack_ax(stack)->type != REG_PTR) {
1623 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1624 ret = -EINVAL;
1625 goto end;
1626 }
1627 vstack_ax(stack)->type = REG_TYPE_UNKNOWN;
1628 next_pc += sizeof(struct load_op);
1629 break;
1630 }
1631
1632 case BYTECODE_OP_LOAD_FIELD_S8:
1633 case BYTECODE_OP_LOAD_FIELD_S16:
1634 case BYTECODE_OP_LOAD_FIELD_S32:
1635 case BYTECODE_OP_LOAD_FIELD_S64:
1636 {
1637 /* Pop 1, push 1 */
1638 if (!vstack_ax(stack)) {
1639 printk(KERN_WARNING "Empty stack\n\n");
1640 ret = -EINVAL;
1641 goto end;
1642 }
1643 if (vstack_ax(stack)->type != REG_PTR) {
1644 printk(KERN_WARNING "Expecting pointer on top of stack\n\n");
1645 ret = -EINVAL;
1646 goto end;
1647 }
1648 vstack_ax(stack)->type = REG_S64;
1649 next_pc += sizeof(struct load_op);
1650 break;
1651 }
1652 case BYTECODE_OP_LOAD_FIELD_U8:
1653 case BYTECODE_OP_LOAD_FIELD_U16:
1654 case BYTECODE_OP_LOAD_FIELD_U32:
1655 case BYTECODE_OP_LOAD_FIELD_U64:
1656 {
1657 /* Pop 1, push 1 */
1658 if (!vstack_ax(stack)) {
1659 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1660 ret = -EINVAL;
1661 goto end;
1662 }
1663 if (vstack_ax(stack)->type != REG_PTR) {
1664 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1665 ret = -EINVAL;
1666 goto end;
1667 }
1668 vstack_ax(stack)->type = REG_U64;
1669 next_pc += sizeof(struct load_op);
1670 break;
1671 }
1672 case BYTECODE_OP_LOAD_FIELD_STRING:
1673 case BYTECODE_OP_LOAD_FIELD_SEQUENCE:
1674 {
1675 /* Pop 1, push 1 */
1676 if (!vstack_ax(stack)) {
1677 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1678 ret = -EINVAL;
1679 goto end;
1680 }
1681 if (vstack_ax(stack)->type != REG_PTR) {
1682 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1683 ret = -EINVAL;
1684 goto end;
1685 }
1686 vstack_ax(stack)->type = REG_STRING;
1687 next_pc += sizeof(struct load_op);
1688 break;
1689 }
1690
1691 case BYTECODE_OP_LOAD_FIELD_DOUBLE:
1692 {
1693 /* Pop 1, push 1 */
1694 if (!vstack_ax(stack)) {
1695 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1696 ret = -EINVAL;
1697 goto end;
1698 }
1699 if (vstack_ax(stack)->type != REG_PTR) {
1700 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1701 ret = -EINVAL;
1702 goto end;
1703 }
1704 vstack_ax(stack)->type = REG_DOUBLE;
1705 next_pc += sizeof(struct load_op);
1706 break;
1707 }
1708
1709 case BYTECODE_OP_GET_SYMBOL:
1710 case BYTECODE_OP_GET_SYMBOL_FIELD:
1711 {
1712 /* Pop 1, push 1 */
1713 if (!vstack_ax(stack)) {
1714 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1715 ret = -EINVAL;
1716 goto end;
1717 }
1718 if (vstack_ax(stack)->type != REG_PTR) {
1719 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1720 ret = -EINVAL;
1721 goto end;
1722 }
1723 next_pc += sizeof(struct load_op) + sizeof(struct get_symbol);
1724 break;
1725 }
1726
1727 case BYTECODE_OP_GET_INDEX_U16:
1728 {
1729 /* Pop 1, push 1 */
1730 if (!vstack_ax(stack)) {
1731 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1732 ret = -EINVAL;
1733 goto end;
1734 }
1735 if (vstack_ax(stack)->type != REG_PTR) {
1736 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1737 ret = -EINVAL;
1738 goto end;
1739 }
1740 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
1741 break;
1742 }
1743
1744 case BYTECODE_OP_GET_INDEX_U64:
1745 {
1746 /* Pop 1, push 1 */
1747 if (!vstack_ax(stack)) {
1748 printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n");
1749 ret = -EINVAL;
1750 goto end;
1751 }
1752 if (vstack_ax(stack)->type != REG_PTR) {
1753 printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n");
1754 ret = -EINVAL;
1755 goto end;
1756 }
1757 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
1758 break;
1759 }
1760
1761 }
1762 end:
1763 *_next_pc = next_pc;
1764 return ret;
1765 }
1766
1767 /*
1768 * Never called concurrently (hash seed is shared).
1769 */
1770 int lttng_bytecode_validate(struct bytecode_runtime *bytecode)
1771 {
1772 struct mp_table *mp_table;
1773 char *pc, *next_pc, *start_pc;
1774 int ret = -EINVAL;
1775 struct vstack stack;
1776
1777 vstack_init(&stack);
1778
1779 mp_table = kzalloc(sizeof(*mp_table), GFP_KERNEL);
1780 if (!mp_table) {
1781 printk(KERN_WARNING "LTTng: bytecode: Error allocating hash table for bytecode validation\n");
1782 return -ENOMEM;
1783 }
1784 start_pc = &bytecode->code[0];
1785 for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;
1786 pc = next_pc) {
1787 ret = bytecode_validate_overflow(bytecode, start_pc, pc);
1788 if (ret != 0) {
1789 if (ret == -ERANGE)
1790 printk(KERN_WARNING "LTTng: bytecode: bytecode overflow\n");
1791 goto end;
1792 }
1793 dbg_printk("Validating op %s (%u)\n",
1794 lttng_bytecode_print_op((unsigned int) *(bytecode_opcode_t *) pc),
1795 (unsigned int) *(bytecode_opcode_t *) pc);
1796
1797 /*
1798 * For each instruction, validate the current context
1799 * (traversal of entire execution flow), and validate
1800 * all merge points targeting this instruction.
1801 */
1802 ret = validate_instruction_all_contexts(bytecode, mp_table,
1803 &stack, start_pc, pc);
1804 if (ret)
1805 goto end;
1806 ret = exec_insn(bytecode, mp_table, &stack, &next_pc, pc);
1807 if (ret <= 0)
1808 goto end;
1809 }
1810 end:
1811 if (delete_all_nodes(mp_table)) {
1812 if (!ret) {
1813 printk(KERN_WARNING "LTTng: bytecode: Unexpected merge points\n");
1814 ret = -EINVAL;
1815 }
1816 }
1817 kfree(mp_table);
1818 return ret;
1819 }
LTTng 2.0/0.x modules
This page took 0.086638 seconds and 4 git commands to generate.