4 * LTTng UST filter code.
6 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; only
11 * version 2.1 of the License.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include <lttng/ust-events.h>
32 #include "filter-bytecode.h"
37 #define min_t(type, a, b) \
38 ((type) (a) < (type) (b) ? (type) (a) : (type) (b))
42 #define likely(x) __builtin_expect(!!(x), 1)
46 #define unlikely(x) __builtin_expect(!!(x), 0)
50 #define dbg_printf(fmt, args...) printf("[debug bytecode] " fmt, ## args)
52 #define dbg_printf(fmt, args...) \
54 /* do nothing but check printf format */ \
56 printf("[debug bytecode] " fmt, ## args); \
61 struct bytecode_runtime
{
77 int literal
; /* is string literal ? */
80 static const char *opnames
[] = {
81 [ FILTER_OP_UNKNOWN
] = "UNKNOWN",
83 [ FILTER_OP_RETURN
] = "RETURN",
86 [ FILTER_OP_MUL
] = "MUL",
87 [ FILTER_OP_DIV
] = "DIV",
88 [ FILTER_OP_MOD
] = "MOD",
89 [ FILTER_OP_PLUS
] = "PLUS",
90 [ FILTER_OP_MINUS
] = "MINUS",
91 [ FILTER_OP_RSHIFT
] = "RSHIFT",
92 [ FILTER_OP_LSHIFT
] = "LSHIFT",
93 [ FILTER_OP_BIN_AND
] = "BIN_AND",
94 [ FILTER_OP_BIN_OR
] = "BIN_OR",
95 [ FILTER_OP_BIN_XOR
] = "BIN_XOR",
96 [ FILTER_OP_EQ
] = "EQ",
97 [ FILTER_OP_NE
] = "NE",
98 [ FILTER_OP_GT
] = "GT",
99 [ FILTER_OP_LT
] = "LT",
100 [ FILTER_OP_GE
] = "GE",
101 [ FILTER_OP_LE
] = "LE",
104 [ FILTER_OP_UNARY_PLUS
] = "UNARY_PLUS",
105 [ FILTER_OP_UNARY_MINUS
] = "UNARY_MINUS",
106 [ FILTER_OP_UNARY_NOT
] = "UNARY_NOT",
109 [ FILTER_OP_AND
] = "AND",
110 [ FILTER_OP_OR
] = "OR",
113 [ FILTER_OP_LOAD_FIELD_REF
] = "LOAD_FIELD_REF",
114 [ FILTER_OP_LOAD_STRING
] = "LOAD_STRING",
115 [ FILTER_OP_LOAD_S64
] = "LOAD_S64",
116 [ FILTER_OP_LOAD_DOUBLE
] = "LOAD_DOUBLE",
120 const char *print_op(enum filter_op op
)
122 if (op
>= NR_FILTER_OPS
)
129 * -1: wildcard found.
130 * -2: unknown escape char.
135 int parse_char(const char **p
)
155 int reg_strcmp(struct reg reg
[NR_REG
], const char *cmp_type
)
157 const char *p
= reg
[REG_R0
].str
, *q
= reg
[REG_R1
].str
;
164 if (unlikely(p
- reg
[REG_R0
].str
> reg
[REG_R0
].seq_len
|| *p
== '\0')) {
165 if (q
- reg
[REG_R1
].str
> reg
[REG_R1
].seq_len
|| *q
== '\0')
171 if (unlikely(q
- reg
[REG_R1
].str
> reg
[REG_R1
].seq_len
|| *q
== '\0')) {
172 if (p
- reg
[REG_R0
].str
> reg
[REG_R0
].seq_len
|| *p
== '\0')
178 if (reg
[REG_R0
].literal
) {
179 ret
= parse_char(&p
);
182 } else if (ret
== -2) {
185 /* else compare both char */
187 if (reg
[REG_R1
].literal
) {
188 ret
= parse_char(&q
);
191 } else if (ret
== -2) {
212 int lttng_filter_false(void *filter_data
,
213 const char *filter_stack_data
)
219 int lttng_filter_interpret_bytecode(void *filter_data
,
220 const char *filter_stack_data
)
222 struct bytecode_runtime
*bytecode
= filter_data
;
223 void *pc
, *next_pc
, *start_pc
;
226 struct reg reg
[NR_REG
];
229 for (i
= 0; i
< NR_REG
; i
++) {
230 reg
[i
].type
= REG_S64
;
238 start_pc
= &bytecode
->data
[0];
239 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
241 if (unlikely(pc
>= start_pc
+ bytecode
->len
)) {
242 fprintf(stderr
, "[error] filter bytecode overflow\n");
246 dbg_printf("Executing op %s (%u)\n",
247 print_op((unsigned int) *(filter_opcode_t
*) pc
),
248 (unsigned int) *(filter_opcode_t
*) pc
);
249 switch (*(filter_opcode_t
*) pc
) {
250 case FILTER_OP_UNKNOWN
:
252 fprintf(stderr
, "[error] unknown bytecode op %u\n",
253 (unsigned int) *(filter_opcode_t
*) pc
);
257 case FILTER_OP_RETURN
:
267 case FILTER_OP_MINUS
:
268 case FILTER_OP_RSHIFT
:
269 case FILTER_OP_LSHIFT
:
270 case FILTER_OP_BIN_AND
:
271 case FILTER_OP_BIN_OR
:
272 case FILTER_OP_BIN_XOR
:
273 fprintf(stderr
, "[error] unsupported bytecode op %u\n",
274 (unsigned int) *(filter_opcode_t
*) pc
);
280 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
281 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
282 fprintf(stderr
, "[error] type mismatch for '==' binary operator\n");
286 switch (reg
[REG_R0
].type
) {
288 fprintf(stderr
, "[error] unknown register type\n");
293 reg
[REG_R0
].v
= (reg_strcmp(reg
, "==") == 0);
296 switch (reg
[REG_R1
].type
) {
298 fprintf(stderr
, "[error] unknown register type\n");
303 reg
[REG_R0
].v
= (reg
[REG_R0
].v
== reg
[REG_R1
].v
);
306 reg
[REG_R0
].v
= (reg
[REG_R0
].v
== reg
[REG_R1
].d
);
311 switch (reg
[REG_R1
].type
) {
313 fprintf(stderr
, "[error] unknown register type\n");
318 reg
[REG_R0
].v
= (reg
[REG_R0
].d
== reg
[REG_R1
].v
);
321 reg
[REG_R0
].v
= (reg
[REG_R0
].d
== reg
[REG_R1
].d
);
326 reg
[REG_R0
].type
= REG_S64
;
327 next_pc
+= sizeof(struct binary_op
);
332 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
333 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
334 fprintf(stderr
, "[error] type mismatch for '!=' binary operator\n");
338 switch (reg
[REG_R0
].type
) {
340 fprintf(stderr
, "[error] unknown register type\n");
345 reg
[REG_R0
].v
= (reg_strcmp(reg
, "!=") != 0);
348 switch (reg
[REG_R1
].type
) {
350 fprintf(stderr
, "[error] unknown register type\n");
355 reg
[REG_R0
].v
= (reg
[REG_R0
].v
!= reg
[REG_R1
].v
);
358 reg
[REG_R0
].v
= (reg
[REG_R0
].v
!= reg
[REG_R1
].d
);
363 switch (reg
[REG_R1
].type
) {
365 fprintf(stderr
, "[error] unknown register type\n");
370 reg
[REG_R0
].v
= (reg
[REG_R0
].d
!= reg
[REG_R1
].v
);
373 reg
[REG_R0
].v
= (reg
[REG_R0
].d
!= reg
[REG_R1
].d
);
378 reg
[REG_R0
].type
= REG_S64
;
379 next_pc
+= sizeof(struct binary_op
);
384 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
385 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
386 fprintf(stderr
, "[error] type mismatch for '>' binary operator\n");
390 switch (reg
[REG_R0
].type
) {
392 fprintf(stderr
, "[error] unknown register type\n");
397 reg
[REG_R0
].v
= (reg_strcmp(reg
, ">") > 0);
400 switch (reg
[REG_R1
].type
) {
402 fprintf(stderr
, "[error] unknown register type\n");
407 reg
[REG_R0
].v
= (reg
[REG_R0
].v
> reg
[REG_R1
].v
);
410 reg
[REG_R0
].v
= (reg
[REG_R0
].v
> reg
[REG_R1
].d
);
415 switch (reg
[REG_R1
].type
) {
417 fprintf(stderr
, "[error] unknown register type\n");
422 reg
[REG_R0
].v
= (reg
[REG_R0
].d
> reg
[REG_R1
].v
);
425 reg
[REG_R0
].v
= (reg
[REG_R0
].d
> reg
[REG_R1
].d
);
430 reg
[REG_R0
].type
= REG_S64
;
431 next_pc
+= sizeof(struct binary_op
);
436 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
437 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
438 fprintf(stderr
, "[error] type mismatch for '<' binary operator\n");
442 switch (reg
[REG_R0
].type
) {
444 fprintf(stderr
, "[error] unknown register type\n");
449 reg
[REG_R0
].v
= (reg_strcmp(reg
, "<") < 0);
452 switch (reg
[REG_R1
].type
) {
454 fprintf(stderr
, "[error] unknown register type\n");
459 reg
[REG_R0
].v
= (reg
[REG_R0
].v
< reg
[REG_R1
].v
);
462 reg
[REG_R0
].v
= (reg
[REG_R0
].v
< reg
[REG_R1
].d
);
467 switch (reg
[REG_R1
].type
) {
469 fprintf(stderr
, "[error] unknown register type\n");
474 reg
[REG_R0
].v
= (reg
[REG_R0
].d
< reg
[REG_R1
].v
);
477 reg
[REG_R0
].v
= (reg
[REG_R0
].d
< reg
[REG_R1
].d
);
482 reg
[REG_R0
].type
= REG_S64
;
483 next_pc
+= sizeof(struct binary_op
);
488 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
489 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
490 fprintf(stderr
, "[error] type mismatch for '>=' binary operator\n");
494 switch (reg
[REG_R0
].type
) {
496 fprintf(stderr
, "[error] unknown register type\n");
501 reg
[REG_R0
].v
= (reg_strcmp(reg
, ">=") >= 0);
504 switch (reg
[REG_R1
].type
) {
506 fprintf(stderr
, "[error] unknown register type\n");
511 reg
[REG_R0
].v
= (reg
[REG_R0
].v
>= reg
[REG_R1
].v
);
514 reg
[REG_R0
].v
= (reg
[REG_R0
].v
>= reg
[REG_R1
].d
);
519 switch (reg
[REG_R1
].type
) {
521 fprintf(stderr
, "[error] unknown register type\n");
526 reg
[REG_R0
].v
= (reg
[REG_R0
].d
>= reg
[REG_R1
].v
);
529 reg
[REG_R0
].v
= (reg
[REG_R0
].d
>= reg
[REG_R1
].d
);
534 reg
[REG_R0
].type
= REG_S64
;
535 next_pc
+= sizeof(struct binary_op
);
540 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
541 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
542 fprintf(stderr
, "[error] type mismatch for '<=' binary operator\n");
546 switch (reg
[REG_R0
].type
) {
548 fprintf(stderr
, "[error] unknown register type\n");
553 reg
[REG_R0
].v
= (reg_strcmp(reg
, "<=") <= 0);
556 switch (reg
[REG_R1
].type
) {
558 fprintf(stderr
, "[error] unknown register type\n");
563 reg
[REG_R0
].v
= (reg
[REG_R0
].v
<= reg
[REG_R1
].v
);
566 reg
[REG_R0
].v
= (reg
[REG_R0
].v
<= reg
[REG_R1
].d
);
571 switch (reg
[REG_R1
].type
) {
573 fprintf(stderr
, "[error] unknown register type\n");
578 reg
[REG_R0
].v
= (reg
[REG_R0
].d
<= reg
[REG_R1
].v
);
581 reg
[REG_R0
].v
= (reg
[REG_R0
].d
<= reg
[REG_R1
].d
);
586 reg
[REG_R0
].type
= REG_S64
;
587 next_pc
+= sizeof(struct binary_op
);
592 case FILTER_OP_UNARY_PLUS
:
594 struct unary_op
*insn
= (struct unary_op
*) pc
;
596 if (unlikely(insn
->reg
>= REG_ERROR
)) {
597 fprintf(stderr
, "[error] invalid register %u\n",
598 (unsigned int) insn
->reg
);
602 switch (reg
[insn
->reg
].type
) {
604 fprintf(stderr
, "[error] unknown register type\n");
609 fprintf(stderr
, "[error] Unary plus can only be applied to numeric or floating point registers\n");
617 next_pc
+= sizeof(struct unary_op
);
620 case FILTER_OP_UNARY_MINUS
:
622 struct unary_op
*insn
= (struct unary_op
*) pc
;
624 if (unlikely(insn
->reg
>= REG_ERROR
)) {
625 fprintf(stderr
, "[error] invalid register %u\n",
626 (unsigned int) insn
->reg
);
630 switch (reg
[insn
->reg
].type
) {
632 fprintf(stderr
, "[error] unknown register type\n");
637 fprintf(stderr
, "[error] Unary minus can only be applied to numeric or floating point registers\n");
641 reg
[insn
->reg
].v
= -reg
[insn
->reg
].v
;
644 reg
[insn
->reg
].d
= -reg
[insn
->reg
].d
;
647 next_pc
+= sizeof(struct unary_op
);
650 case FILTER_OP_UNARY_NOT
:
652 struct unary_op
*insn
= (struct unary_op
*) pc
;
654 if (unlikely(insn
->reg
>= REG_ERROR
)) {
655 fprintf(stderr
, "[error] invalid register %u\n",
656 (unsigned int) insn
->reg
);
660 switch (reg
[insn
->reg
].type
) {
662 fprintf(stderr
, "[error] unknown register type\n");
667 fprintf(stderr
, "[error] Unary not can only be applied to numeric or floating point registers\n");
671 reg
[insn
->reg
].v
= !reg
[insn
->reg
].v
;
674 reg
[insn
->reg
].d
= !reg
[insn
->reg
].d
;
677 if (unlikely(reg
[insn
->reg
].type
!= REG_S64
)) {
678 fprintf(stderr
, "[error] Unary not can only be applied to numeric register\n");
682 reg
[insn
->reg
].v
= !reg
[insn
->reg
].v
;
683 next_pc
+= sizeof(struct unary_op
);
689 struct logical_op
*insn
= (struct logical_op
*) pc
;
691 if (unlikely(reg
[REG_R0
].type
== REG_STRING
)) {
692 fprintf(stderr
, "[error] Logical operator 'and' can only be applied to numeric and floating point registers\n");
697 /* If REG_R0 is 0, skip and evaluate to 0 */
698 if ((reg
[REG_R0
].type
== REG_S64
&& reg
[REG_R0
].v
== 0)
699 || (reg
[REG_R0
].type
== REG_DOUBLE
&& reg
[REG_R0
].d
== 0.0)) {
700 dbg_printf("Jumping to bytecode offset %u\n",
701 (unsigned int) insn
->skip_offset
);
702 next_pc
= start_pc
+ insn
->skip_offset
;
703 if (unlikely(next_pc
<= pc
)) {
704 fprintf(stderr
, "[error] Loops are not allowed in bytecode\n");
709 next_pc
+= sizeof(struct logical_op
);
715 struct logical_op
*insn
= (struct logical_op
*) pc
;
717 if (unlikely(reg
[REG_R0
].type
== REG_STRING
)) {
718 fprintf(stderr
, "[error] Logical operator 'or' can only be applied to numeric and floating point registers\n");
723 /* If REG_R0 is nonzero, skip and evaluate to 1 */
725 if ((reg
[REG_R0
].type
== REG_S64
&& reg
[REG_R0
].v
!= 0)
726 || (reg
[REG_R0
].type
== REG_DOUBLE
&& reg
[REG_R0
].d
!= 0.0)) {
728 dbg_printf("Jumping to bytecode offset %u\n",
729 (unsigned int) insn
->skip_offset
);
730 next_pc
= start_pc
+ insn
->skip_offset
;
731 if (unlikely(next_pc
<= pc
)) {
732 fprintf(stderr
, "[error] Loops are not allowed in bytecode\n");
737 next_pc
+= sizeof(struct logical_op
);
743 case FILTER_OP_LOAD_FIELD_REF
:
745 struct load_op
*insn
= (struct load_op
*) pc
;
746 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
748 if (unlikely(insn
->reg
>= REG_ERROR
)) {
749 fprintf(stderr
, "[error] invalid register %u\n",
750 (unsigned int) insn
->reg
);
754 dbg_printf("load field ref offset %u type %u\n",
755 ref
->offset
, ref
->type
);
757 case FIELD_REF_UNKNOWN
:
759 fprintf(stderr
, "[error] unknown field ref type\n");
763 case FIELD_REF_STRING
:
765 *(const char * const *) &filter_stack_data
[ref
->offset
];
766 reg
[insn
->reg
].type
= REG_STRING
;
767 reg
[insn
->reg
].seq_len
= UINT_MAX
;
768 reg
[insn
->reg
].literal
= 0;
769 dbg_printf("ref load string %s\n", reg
[insn
->reg
].str
);
771 case FIELD_REF_SEQUENCE
:
772 reg
[insn
->reg
].seq_len
=
773 *(unsigned long *) &filter_stack_data
[ref
->offset
];
775 *(const char **) (&filter_stack_data
[ref
->offset
776 + sizeof(unsigned long)]);
777 reg
[insn
->reg
].type
= REG_STRING
;
778 reg
[insn
->reg
].literal
= 0;
781 memcpy(®
[insn
->reg
].v
, &filter_stack_data
[ref
->offset
],
782 sizeof(struct literal_numeric
));
783 reg
[insn
->reg
].type
= REG_S64
;
784 reg
[insn
->reg
].literal
= 0;
785 dbg_printf("ref load s64 %" PRIi64
"\n", reg
[insn
->reg
].v
);
787 case FIELD_REF_DOUBLE
:
788 memcpy(®
[insn
->reg
].d
, &filter_stack_data
[ref
->offset
],
789 sizeof(struct literal_double
));
790 reg
[insn
->reg
].type
= REG_DOUBLE
;
791 reg
[insn
->reg
].literal
= 0;
792 dbg_printf("ref load double %g\n", reg
[insn
->reg
].d
);
796 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
800 case FILTER_OP_LOAD_STRING
:
802 struct load_op
*insn
= (struct load_op
*) pc
;
804 if (unlikely(insn
->reg
>= REG_ERROR
)) {
805 fprintf(stderr
, "[error] invalid register %u\n",
806 (unsigned int) insn
->reg
);
810 dbg_printf("load string %s\n", insn
->data
);
811 reg
[insn
->reg
].str
= insn
->data
;
812 reg
[insn
->reg
].type
= REG_STRING
;
813 reg
[insn
->reg
].seq_len
= UINT_MAX
;
814 reg
[insn
->reg
].literal
= 1;
815 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
819 case FILTER_OP_LOAD_S64
:
821 struct load_op
*insn
= (struct load_op
*) pc
;
823 if (unlikely(insn
->reg
>= REG_ERROR
)) {
824 fprintf(stderr
, "[error] invalid register %u\n",
825 (unsigned int) insn
->reg
);
829 memcpy(®
[insn
->reg
].v
, insn
->data
,
830 sizeof(struct literal_numeric
));
831 dbg_printf("load s64 %" PRIi64
"\n", reg
[insn
->reg
].v
);
832 reg
[insn
->reg
].type
= REG_S64
;
833 next_pc
+= sizeof(struct load_op
)
834 + sizeof(struct literal_numeric
);
838 case FILTER_OP_LOAD_DOUBLE
:
840 struct load_op
*insn
= (struct load_op
*) pc
;
842 if (unlikely(insn
->reg
>= REG_ERROR
)) {
843 fprintf(stderr
, "[error] invalid register %u\n",
844 (unsigned int) insn
->reg
);
848 memcpy(®
[insn
->reg
].d
, insn
->data
,
849 sizeof(struct literal_double
));
850 dbg_printf("load s64 %g\n", reg
[insn
->reg
].d
);
851 reg
[insn
->reg
].type
= REG_DOUBLE
;
852 next_pc
+= sizeof(struct load_op
)
853 + sizeof(struct literal_double
);
859 /* return 0 (discard) on error */
866 int apply_field_reloc(struct ltt_event
*event
,
867 struct bytecode_runtime
*runtime
,
868 uint32_t runtime_len
,
869 uint32_t reloc_offset
,
870 const char *field_name
)
872 const struct lttng_event_desc
*desc
;
873 const struct lttng_event_field
*fields
, *field
= NULL
;
874 unsigned int nr_fields
, i
;
875 struct field_ref
*field_ref
;
876 uint32_t field_offset
= 0;
878 dbg_printf("Apply reloc: %u %s\n", reloc_offset
, field_name
);
880 /* Ensure that the reloc is within the code */
881 if (runtime_len
- reloc_offset
< sizeof(uint16_t))
884 /* Lookup event by name */
888 fields
= desc
->fields
;
891 nr_fields
= desc
->nr_fields
;
892 for (i
= 0; i
< nr_fields
; i
++) {
893 if (!strcmp(fields
[i
].name
, field_name
)) {
897 /* compute field offset */
898 switch (fields
[i
].type
.atype
) {
901 field_offset
+= sizeof(int64_t);
905 field_offset
+= sizeof(unsigned long);
906 field_offset
+= sizeof(void *);
909 field_offset
+= sizeof(void *);
912 field_offset
+= sizeof(double);
921 /* Check if field offset is too large for 16-bit offset */
922 if (field_offset
> FILTER_BYTECODE_MAX_LEN
)
926 field_ref
= (struct field_ref
*) &runtime
->data
[reloc_offset
];
927 switch (field
->type
.atype
) {
930 field_ref
->type
= FIELD_REF_S64
;
931 field_ref
->type
= FIELD_REF_S64
;
935 field_ref
->type
= FIELD_REF_SEQUENCE
;
938 field_ref
->type
= FIELD_REF_STRING
;
941 field_ref
->type
= FIELD_REF_DOUBLE
;
947 field_ref
->offset
= (uint16_t) field_offset
;
952 * Take a bytecode with reloc table and link it to an event to create a
956 int _lttng_filter_event_link_bytecode(struct ltt_event
*event
,
957 struct lttng_ust_filter_bytecode
*filter_bytecode
)
959 int ret
, offset
, next_offset
;
960 struct bytecode_runtime
*runtime
= NULL
;
961 size_t runtime_alloc_len
;
963 if (!filter_bytecode
)
965 /* Even is not connected to any description */
968 /* Bytecode already linked */
969 if (event
->filter
|| event
->filter_data
)
972 dbg_printf("Linking\n");
974 /* We don't need the reloc table in the runtime */
975 runtime_alloc_len
= sizeof(*runtime
) + filter_bytecode
->reloc_offset
;
976 runtime
= zmalloc(runtime_alloc_len
);
981 runtime
->len
= filter_bytecode
->reloc_offset
;
982 /* copy original bytecode */
983 memcpy(runtime
->data
, filter_bytecode
->data
, runtime
->len
);
985 * apply relocs. Those are a uint16_t (offset in bytecode)
986 * followed by a string (field name).
988 for (offset
= filter_bytecode
->reloc_offset
;
989 offset
< filter_bytecode
->len
;
990 offset
= next_offset
) {
991 uint16_t reloc_offset
=
992 *(uint16_t *) &filter_bytecode
->data
[offset
];
993 const char *field_name
=
994 (const char *) &filter_bytecode
->data
[offset
+ sizeof(uint16_t)];
996 ret
= apply_field_reloc(event
, runtime
, runtime
->len
, reloc_offset
, field_name
);
1000 next_offset
= offset
+ sizeof(uint16_t) + strlen(field_name
) + 1;
1002 event
->filter_data
= runtime
;
1003 event
->filter
= lttng_filter_interpret_bytecode
;
1007 event
->filter
= lttng_filter_false
;
1012 void lttng_filter_event_link_bytecode(struct ltt_event
*event
,
1013 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1017 ret
= _lttng_filter_event_link_bytecode(event
, filter_bytecode
);
1019 fprintf(stderr
, "[lttng filter] error linking event bytecode\n");
1024 * Link bytecode to all events for a wildcard. Skips events that already
1025 * have a bytecode linked.
1026 * We do not set each event's filter_bytecode field, because they do not
1027 * own the filter_bytecode: the wildcard owns it.
1029 void lttng_filter_wildcard_link_bytecode(struct session_wildcard
*wildcard
)
1031 struct ltt_event
*event
;
1034 if (!wildcard
->filter_bytecode
)
1037 cds_list_for_each_entry(event
, &wildcard
->events
, wildcard_list
) {
1040 ret
= _lttng_filter_event_link_bytecode(event
,
1041 wildcard
->filter_bytecode
);
1043 fprintf(stderr
, "[lttng filter] error linking wildcard bytecode\n");
1051 * Need to attach filter to an event before starting tracing for the
1052 * session. We own the filter_bytecode if we return success.
1054 int lttng_filter_event_attach_bytecode(struct ltt_event
*event
,
1055 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1057 if (event
->chan
->session
->been_active
)
1059 if (event
->filter_bytecode
)
1061 event
->filter_bytecode
= filter_bytecode
;
1066 * Need to attach filter to a wildcard before starting tracing for the
1067 * session. We own the filter_bytecode if we return success.
1069 int lttng_filter_wildcard_attach_bytecode(struct session_wildcard
*wildcard
,
1070 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1072 if (wildcard
->chan
->session
->been_active
)
1074 if (wildcard
->filter_bytecode
)
1076 wildcard
->filter_bytecode
= filter_bytecode
;