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 <usterr-signal-safe.h>
33 #include "filter-bytecode.h"
38 #define min_t(type, a, b) \
39 ((type) (a) < (type) (b) ? (type) (a) : (type) (b))
43 #define likely(x) __builtin_expect(!!(x), 1)
47 #define unlikely(x) __builtin_expect(!!(x), 0)
51 #define dbg_printf(fmt, args...) printf("[debug bytecode] " fmt, ## args)
53 #define dbg_printf(fmt, args...) \
55 /* do nothing but check printf format */ \
57 printf("[debug bytecode] " fmt, ## args); \
62 struct bytecode_runtime
{
78 int literal
; /* is string literal ? */
81 static const char *opnames
[] = {
82 [ FILTER_OP_UNKNOWN
] = "UNKNOWN",
84 [ FILTER_OP_RETURN
] = "RETURN",
87 [ FILTER_OP_MUL
] = "MUL",
88 [ FILTER_OP_DIV
] = "DIV",
89 [ FILTER_OP_MOD
] = "MOD",
90 [ FILTER_OP_PLUS
] = "PLUS",
91 [ FILTER_OP_MINUS
] = "MINUS",
92 [ FILTER_OP_RSHIFT
] = "RSHIFT",
93 [ FILTER_OP_LSHIFT
] = "LSHIFT",
94 [ FILTER_OP_BIN_AND
] = "BIN_AND",
95 [ FILTER_OP_BIN_OR
] = "BIN_OR",
96 [ FILTER_OP_BIN_XOR
] = "BIN_XOR",
97 [ FILTER_OP_EQ
] = "EQ",
98 [ FILTER_OP_NE
] = "NE",
99 [ FILTER_OP_GT
] = "GT",
100 [ FILTER_OP_LT
] = "LT",
101 [ FILTER_OP_GE
] = "GE",
102 [ FILTER_OP_LE
] = "LE",
105 [ FILTER_OP_UNARY_PLUS
] = "UNARY_PLUS",
106 [ FILTER_OP_UNARY_MINUS
] = "UNARY_MINUS",
107 [ FILTER_OP_UNARY_NOT
] = "UNARY_NOT",
110 [ FILTER_OP_AND
] = "AND",
111 [ FILTER_OP_OR
] = "OR",
114 [ FILTER_OP_LOAD_FIELD_REF
] = "LOAD_FIELD_REF",
115 [ FILTER_OP_LOAD_STRING
] = "LOAD_STRING",
116 [ FILTER_OP_LOAD_S64
] = "LOAD_S64",
117 [ FILTER_OP_LOAD_DOUBLE
] = "LOAD_DOUBLE",
121 const char *print_op(enum filter_op op
)
123 if (op
>= NR_FILTER_OPS
)
130 * -1: wildcard found.
131 * -2: unknown escape char.
136 int parse_char(const char **p
)
156 int reg_strcmp(struct reg reg
[NR_REG
], const char *cmp_type
)
158 const char *p
= reg
[REG_R0
].str
, *q
= reg
[REG_R1
].str
;
165 if (unlikely(p
- reg
[REG_R0
].str
> reg
[REG_R0
].seq_len
|| *p
== '\0')) {
166 if (q
- reg
[REG_R1
].str
> reg
[REG_R1
].seq_len
|| *q
== '\0')
172 if (unlikely(q
- reg
[REG_R1
].str
> reg
[REG_R1
].seq_len
|| *q
== '\0')) {
173 if (p
- reg
[REG_R0
].str
> reg
[REG_R0
].seq_len
|| *p
== '\0')
179 if (reg
[REG_R0
].literal
) {
180 ret
= parse_char(&p
);
183 } else if (ret
== -2) {
186 /* else compare both char */
188 if (reg
[REG_R1
].literal
) {
189 ret
= parse_char(&q
);
192 } else if (ret
== -2) {
213 int lttng_filter_false(void *filter_data
,
214 const char *filter_stack_data
)
220 int lttng_filter_interpret_bytecode(void *filter_data
,
221 const char *filter_stack_data
)
223 struct bytecode_runtime
*bytecode
= filter_data
;
224 void *pc
, *next_pc
, *start_pc
;
227 struct reg reg
[NR_REG
];
230 for (i
= 0; i
< NR_REG
; i
++) {
231 reg
[i
].type
= REG_S64
;
239 start_pc
= &bytecode
->data
[0];
240 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
242 if (unlikely(pc
>= start_pc
+ bytecode
->len
)) {
243 ERR("filter bytecode overflow\n");
247 dbg_printf("Executing op %s (%u)\n",
248 print_op((unsigned int) *(filter_opcode_t
*) pc
),
249 (unsigned int) *(filter_opcode_t
*) pc
);
250 switch (*(filter_opcode_t
*) pc
) {
251 case FILTER_OP_UNKNOWN
:
253 ERR("unknown bytecode op %u\n",
254 (unsigned int) *(filter_opcode_t
*) pc
);
258 case FILTER_OP_RETURN
:
268 case FILTER_OP_MINUS
:
269 case FILTER_OP_RSHIFT
:
270 case FILTER_OP_LSHIFT
:
271 case FILTER_OP_BIN_AND
:
272 case FILTER_OP_BIN_OR
:
273 case FILTER_OP_BIN_XOR
:
274 ERR("unsupported bytecode op %u\n",
275 (unsigned int) *(filter_opcode_t
*) pc
);
281 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
282 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
283 ERR("type mismatch for '==' binary operator\n");
287 switch (reg
[REG_R0
].type
) {
289 ERR("unknown register type\n");
294 reg
[REG_R0
].v
= (reg_strcmp(reg
, "==") == 0);
297 switch (reg
[REG_R1
].type
) {
299 ERR("unknown register type\n");
304 reg
[REG_R0
].v
= (reg
[REG_R0
].v
== reg
[REG_R1
].v
);
307 reg
[REG_R0
].v
= (reg
[REG_R0
].v
== reg
[REG_R1
].d
);
312 switch (reg
[REG_R1
].type
) {
314 ERR("unknown register type\n");
319 reg
[REG_R0
].v
= (reg
[REG_R0
].d
== reg
[REG_R1
].v
);
322 reg
[REG_R0
].v
= (reg
[REG_R0
].d
== reg
[REG_R1
].d
);
327 reg
[REG_R0
].type
= REG_S64
;
328 next_pc
+= sizeof(struct binary_op
);
333 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
334 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
335 ERR("type mismatch for '!=' binary operator\n");
339 switch (reg
[REG_R0
].type
) {
341 ERR("unknown register type\n");
346 reg
[REG_R0
].v
= (reg_strcmp(reg
, "!=") != 0);
349 switch (reg
[REG_R1
].type
) {
351 ERR("unknown register type\n");
356 reg
[REG_R0
].v
= (reg
[REG_R0
].v
!= reg
[REG_R1
].v
);
359 reg
[REG_R0
].v
= (reg
[REG_R0
].v
!= reg
[REG_R1
].d
);
364 switch (reg
[REG_R1
].type
) {
366 ERR("unknown register type\n");
371 reg
[REG_R0
].v
= (reg
[REG_R0
].d
!= reg
[REG_R1
].v
);
374 reg
[REG_R0
].v
= (reg
[REG_R0
].d
!= reg
[REG_R1
].d
);
379 reg
[REG_R0
].type
= REG_S64
;
380 next_pc
+= sizeof(struct binary_op
);
385 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
386 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
387 ERR("type mismatch for '>' binary operator\n");
391 switch (reg
[REG_R0
].type
) {
393 ERR("unknown register type\n");
398 reg
[REG_R0
].v
= (reg_strcmp(reg
, ">") > 0);
401 switch (reg
[REG_R1
].type
) {
403 ERR("unknown register type\n");
408 reg
[REG_R0
].v
= (reg
[REG_R0
].v
> reg
[REG_R1
].v
);
411 reg
[REG_R0
].v
= (reg
[REG_R0
].v
> reg
[REG_R1
].d
);
416 switch (reg
[REG_R1
].type
) {
418 ERR("unknown register type\n");
423 reg
[REG_R0
].v
= (reg
[REG_R0
].d
> reg
[REG_R1
].v
);
426 reg
[REG_R0
].v
= (reg
[REG_R0
].d
> reg
[REG_R1
].d
);
431 reg
[REG_R0
].type
= REG_S64
;
432 next_pc
+= sizeof(struct binary_op
);
437 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
438 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
439 ERR("type mismatch for '<' binary operator\n");
443 switch (reg
[REG_R0
].type
) {
445 ERR("unknown register type\n");
450 reg
[REG_R0
].v
= (reg_strcmp(reg
, "<") < 0);
453 switch (reg
[REG_R1
].type
) {
455 ERR("unknown register type\n");
460 reg
[REG_R0
].v
= (reg
[REG_R0
].v
< reg
[REG_R1
].v
);
463 reg
[REG_R0
].v
= (reg
[REG_R0
].v
< reg
[REG_R1
].d
);
468 switch (reg
[REG_R1
].type
) {
470 ERR("unknown register type\n");
475 reg
[REG_R0
].v
= (reg
[REG_R0
].d
< reg
[REG_R1
].v
);
478 reg
[REG_R0
].v
= (reg
[REG_R0
].d
< reg
[REG_R1
].d
);
483 reg
[REG_R0
].type
= REG_S64
;
484 next_pc
+= sizeof(struct binary_op
);
489 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
490 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
491 ERR("type mismatch for '>=' binary operator\n");
495 switch (reg
[REG_R0
].type
) {
497 ERR("unknown register type\n");
502 reg
[REG_R0
].v
= (reg_strcmp(reg
, ">=") >= 0);
505 switch (reg
[REG_R1
].type
) {
507 ERR("unknown register type\n");
512 reg
[REG_R0
].v
= (reg
[REG_R0
].v
>= reg
[REG_R1
].v
);
515 reg
[REG_R0
].v
= (reg
[REG_R0
].v
>= reg
[REG_R1
].d
);
520 switch (reg
[REG_R1
].type
) {
522 ERR("unknown register type\n");
527 reg
[REG_R0
].v
= (reg
[REG_R0
].d
>= reg
[REG_R1
].v
);
530 reg
[REG_R0
].v
= (reg
[REG_R0
].d
>= reg
[REG_R1
].d
);
535 reg
[REG_R0
].type
= REG_S64
;
536 next_pc
+= sizeof(struct binary_op
);
541 if (unlikely((reg
[REG_R0
].type
== REG_STRING
&& reg
[REG_R1
].type
!= REG_STRING
)
542 || (reg
[REG_R0
].type
!= REG_STRING
&& reg
[REG_R1
].type
== REG_STRING
))) {
543 ERR("type mismatch for '<=' binary operator\n");
547 switch (reg
[REG_R0
].type
) {
549 ERR("unknown register type\n");
554 reg
[REG_R0
].v
= (reg_strcmp(reg
, "<=") <= 0);
557 switch (reg
[REG_R1
].type
) {
559 ERR("unknown register type\n");
564 reg
[REG_R0
].v
= (reg
[REG_R0
].v
<= reg
[REG_R1
].v
);
567 reg
[REG_R0
].v
= (reg
[REG_R0
].v
<= reg
[REG_R1
].d
);
572 switch (reg
[REG_R1
].type
) {
574 ERR("unknown register type\n");
579 reg
[REG_R0
].v
= (reg
[REG_R0
].d
<= reg
[REG_R1
].v
);
582 reg
[REG_R0
].v
= (reg
[REG_R0
].d
<= reg
[REG_R1
].d
);
587 reg
[REG_R0
].type
= REG_S64
;
588 next_pc
+= sizeof(struct binary_op
);
593 case FILTER_OP_UNARY_PLUS
:
595 struct unary_op
*insn
= (struct unary_op
*) pc
;
597 if (unlikely(insn
->reg
>= REG_ERROR
)) {
598 ERR("invalid register %u\n",
599 (unsigned int) insn
->reg
);
603 switch (reg
[insn
->reg
].type
) {
605 ERR("unknown register type\n");
610 ERR("Unary plus can only be applied to numeric or floating point registers\n");
618 next_pc
+= sizeof(struct unary_op
);
621 case FILTER_OP_UNARY_MINUS
:
623 struct unary_op
*insn
= (struct unary_op
*) pc
;
625 if (unlikely(insn
->reg
>= REG_ERROR
)) {
626 ERR("invalid register %u\n",
627 (unsigned int) insn
->reg
);
631 switch (reg
[insn
->reg
].type
) {
633 ERR("unknown register type\n");
638 ERR("Unary minus can only be applied to numeric or floating point registers\n");
642 reg
[insn
->reg
].v
= -reg
[insn
->reg
].v
;
645 reg
[insn
->reg
].d
= -reg
[insn
->reg
].d
;
648 next_pc
+= sizeof(struct unary_op
);
651 case FILTER_OP_UNARY_NOT
:
653 struct unary_op
*insn
= (struct unary_op
*) pc
;
655 if (unlikely(insn
->reg
>= REG_ERROR
)) {
656 ERR("invalid register %u\n",
657 (unsigned int) insn
->reg
);
661 switch (reg
[insn
->reg
].type
) {
663 ERR("unknown register type\n");
668 ERR("Unary not can only be applied to numeric or floating point registers\n");
672 reg
[insn
->reg
].v
= !reg
[insn
->reg
].v
;
675 reg
[insn
->reg
].d
= !reg
[insn
->reg
].d
;
678 if (unlikely(reg
[insn
->reg
].type
!= REG_S64
)) {
679 ERR("Unary not can only be applied to numeric register\n");
683 reg
[insn
->reg
].v
= !reg
[insn
->reg
].v
;
684 next_pc
+= sizeof(struct unary_op
);
690 struct logical_op
*insn
= (struct logical_op
*) pc
;
692 if (unlikely(reg
[REG_R0
].type
== REG_STRING
)) {
693 ERR("Logical operator 'and' can only be applied to numeric and floating point registers\n");
698 /* If REG_R0 is 0, skip and evaluate to 0 */
699 if ((reg
[REG_R0
].type
== REG_S64
&& reg
[REG_R0
].v
== 0)
700 || (reg
[REG_R0
].type
== REG_DOUBLE
&& reg
[REG_R0
].d
== 0.0)) {
701 dbg_printf("Jumping to bytecode offset %u\n",
702 (unsigned int) insn
->skip_offset
);
703 next_pc
= start_pc
+ insn
->skip_offset
;
704 if (unlikely(next_pc
<= pc
)) {
705 ERR("Loops are not allowed in bytecode\n");
710 next_pc
+= sizeof(struct logical_op
);
716 struct logical_op
*insn
= (struct logical_op
*) pc
;
718 if (unlikely(reg
[REG_R0
].type
== REG_STRING
)) {
719 ERR("Logical operator 'or' can only be applied to numeric and floating point registers\n");
724 /* If REG_R0 is nonzero, skip and evaluate to 1 */
726 if ((reg
[REG_R0
].type
== REG_S64
&& reg
[REG_R0
].v
!= 0)
727 || (reg
[REG_R0
].type
== REG_DOUBLE
&& reg
[REG_R0
].d
!= 0.0)) {
729 dbg_printf("Jumping to bytecode offset %u\n",
730 (unsigned int) insn
->skip_offset
);
731 next_pc
= start_pc
+ insn
->skip_offset
;
732 if (unlikely(next_pc
<= pc
)) {
733 ERR("Loops are not allowed in bytecode\n");
738 next_pc
+= sizeof(struct logical_op
);
744 case FILTER_OP_LOAD_FIELD_REF
:
746 struct load_op
*insn
= (struct load_op
*) pc
;
747 struct field_ref
*ref
= (struct field_ref
*) insn
->data
;
749 if (unlikely(insn
->reg
>= REG_ERROR
)) {
750 ERR("invalid register %u\n",
751 (unsigned int) insn
->reg
);
755 dbg_printf("load field ref offset %u type %u\n",
756 ref
->offset
, ref
->type
);
758 case FIELD_REF_UNKNOWN
:
760 ERR("unknown field ref type\n");
764 case FIELD_REF_STRING
:
766 *(const char * const *) &filter_stack_data
[ref
->offset
];
767 reg
[insn
->reg
].type
= REG_STRING
;
768 reg
[insn
->reg
].seq_len
= UINT_MAX
;
769 reg
[insn
->reg
].literal
= 0;
770 dbg_printf("ref load string %s\n", reg
[insn
->reg
].str
);
772 case FIELD_REF_SEQUENCE
:
773 reg
[insn
->reg
].seq_len
=
774 *(unsigned long *) &filter_stack_data
[ref
->offset
];
776 *(const char **) (&filter_stack_data
[ref
->offset
777 + sizeof(unsigned long)]);
778 reg
[insn
->reg
].type
= REG_STRING
;
779 reg
[insn
->reg
].literal
= 0;
782 memcpy(®
[insn
->reg
].v
, &filter_stack_data
[ref
->offset
],
783 sizeof(struct literal_numeric
));
784 reg
[insn
->reg
].type
= REG_S64
;
785 reg
[insn
->reg
].literal
= 0;
786 dbg_printf("ref load s64 %" PRIi64
"\n", reg
[insn
->reg
].v
);
788 case FIELD_REF_DOUBLE
:
789 memcpy(®
[insn
->reg
].d
, &filter_stack_data
[ref
->offset
],
790 sizeof(struct literal_double
));
791 reg
[insn
->reg
].type
= REG_DOUBLE
;
792 reg
[insn
->reg
].literal
= 0;
793 dbg_printf("ref load double %g\n", reg
[insn
->reg
].d
);
797 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
801 case FILTER_OP_LOAD_STRING
:
803 struct load_op
*insn
= (struct load_op
*) pc
;
805 if (unlikely(insn
->reg
>= REG_ERROR
)) {
806 ERR("invalid register %u\n",
807 (unsigned int) insn
->reg
);
811 dbg_printf("load string %s\n", insn
->data
);
812 reg
[insn
->reg
].str
= insn
->data
;
813 reg
[insn
->reg
].type
= REG_STRING
;
814 reg
[insn
->reg
].seq_len
= UINT_MAX
;
815 reg
[insn
->reg
].literal
= 1;
816 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
820 case FILTER_OP_LOAD_S64
:
822 struct load_op
*insn
= (struct load_op
*) pc
;
824 if (unlikely(insn
->reg
>= REG_ERROR
)) {
825 ERR("invalid register %u\n",
826 (unsigned int) insn
->reg
);
830 memcpy(®
[insn
->reg
].v
, insn
->data
,
831 sizeof(struct literal_numeric
));
832 dbg_printf("load s64 %" PRIi64
"\n", reg
[insn
->reg
].v
);
833 reg
[insn
->reg
].type
= REG_S64
;
834 next_pc
+= sizeof(struct load_op
)
835 + sizeof(struct literal_numeric
);
839 case FILTER_OP_LOAD_DOUBLE
:
841 struct load_op
*insn
= (struct load_op
*) pc
;
843 if (unlikely(insn
->reg
>= REG_ERROR
)) {
844 ERR("invalid register %u\n",
845 (unsigned int) insn
->reg
);
849 memcpy(®
[insn
->reg
].d
, insn
->data
,
850 sizeof(struct literal_double
));
851 dbg_printf("load s64 %g\n", reg
[insn
->reg
].d
);
852 reg
[insn
->reg
].type
= REG_DOUBLE
;
853 next_pc
+= sizeof(struct load_op
)
854 + sizeof(struct literal_double
);
860 /* return 0 (discard) on error */
867 int apply_field_reloc(struct ltt_event
*event
,
868 struct bytecode_runtime
*runtime
,
869 uint32_t runtime_len
,
870 uint32_t reloc_offset
,
871 const char *field_name
)
873 const struct lttng_event_desc
*desc
;
874 const struct lttng_event_field
*fields
, *field
= NULL
;
875 unsigned int nr_fields
, i
;
876 struct field_ref
*field_ref
;
877 uint32_t field_offset
= 0;
879 dbg_printf("Apply reloc: %u %s\n", reloc_offset
, field_name
);
881 /* Ensure that the reloc is within the code */
882 if (runtime_len
- reloc_offset
< sizeof(uint16_t))
885 /* Lookup event by name */
889 fields
= desc
->fields
;
892 nr_fields
= desc
->nr_fields
;
893 for (i
= 0; i
< nr_fields
; i
++) {
894 if (!strcmp(fields
[i
].name
, field_name
)) {
898 /* compute field offset */
899 switch (fields
[i
].type
.atype
) {
902 field_offset
+= sizeof(int64_t);
906 field_offset
+= sizeof(unsigned long);
907 field_offset
+= sizeof(void *);
910 field_offset
+= sizeof(void *);
913 field_offset
+= sizeof(double);
922 /* Check if field offset is too large for 16-bit offset */
923 if (field_offset
> FILTER_BYTECODE_MAX_LEN
)
927 field_ref
= (struct field_ref
*) &runtime
->data
[reloc_offset
];
928 switch (field
->type
.atype
) {
931 field_ref
->type
= FIELD_REF_S64
;
932 field_ref
->type
= FIELD_REF_S64
;
936 field_ref
->type
= FIELD_REF_SEQUENCE
;
939 field_ref
->type
= FIELD_REF_STRING
;
942 field_ref
->type
= FIELD_REF_DOUBLE
;
948 field_ref
->offset
= (uint16_t) field_offset
;
953 * Take a bytecode with reloc table and link it to an event to create a
957 int _lttng_filter_event_link_bytecode(struct ltt_event
*event
,
958 struct lttng_ust_filter_bytecode
*filter_bytecode
)
960 int ret
, offset
, next_offset
;
961 struct bytecode_runtime
*runtime
= NULL
;
962 size_t runtime_alloc_len
;
964 if (!filter_bytecode
)
966 /* Even is not connected to any description */
969 /* Bytecode already linked */
970 if (event
->filter
|| event
->filter_data
)
973 dbg_printf("Linking\n");
975 /* We don't need the reloc table in the runtime */
976 runtime_alloc_len
= sizeof(*runtime
) + filter_bytecode
->reloc_offset
;
977 runtime
= zmalloc(runtime_alloc_len
);
982 runtime
->len
= filter_bytecode
->reloc_offset
;
983 /* copy original bytecode */
984 memcpy(runtime
->data
, filter_bytecode
->data
, runtime
->len
);
986 * apply relocs. Those are a uint16_t (offset in bytecode)
987 * followed by a string (field name).
989 for (offset
= filter_bytecode
->reloc_offset
;
990 offset
< filter_bytecode
->len
;
991 offset
= next_offset
) {
992 uint16_t reloc_offset
=
993 *(uint16_t *) &filter_bytecode
->data
[offset
];
994 const char *field_name
=
995 (const char *) &filter_bytecode
->data
[offset
+ sizeof(uint16_t)];
997 ret
= apply_field_reloc(event
, runtime
, runtime
->len
, reloc_offset
, field_name
);
1001 next_offset
= offset
+ sizeof(uint16_t) + strlen(field_name
) + 1;
1003 event
->filter_data
= runtime
;
1004 event
->filter
= lttng_filter_interpret_bytecode
;
1008 event
->filter
= lttng_filter_false
;
1013 void lttng_filter_event_link_bytecode(struct ltt_event
*event
,
1014 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1018 ret
= _lttng_filter_event_link_bytecode(event
, filter_bytecode
);
1020 fprintf(stderr
, "[lttng filter] error linking event bytecode\n");
1025 * Link bytecode to all events for a wildcard. Skips events that already
1026 * have a bytecode linked.
1027 * We do not set each event's filter_bytecode field, because they do not
1028 * own the filter_bytecode: the wildcard owns it.
1030 void lttng_filter_wildcard_link_bytecode(struct session_wildcard
*wildcard
)
1032 struct ltt_event
*event
;
1035 if (!wildcard
->filter_bytecode
)
1038 cds_list_for_each_entry(event
, &wildcard
->events
, wildcard_list
) {
1041 ret
= _lttng_filter_event_link_bytecode(event
,
1042 wildcard
->filter_bytecode
);
1044 fprintf(stderr
, "[lttng filter] error linking wildcard bytecode\n");
1052 * Need to attach filter to an event before starting tracing for the
1053 * session. We own the filter_bytecode if we return success.
1055 int lttng_filter_event_attach_bytecode(struct ltt_event
*event
,
1056 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1058 if (event
->chan
->session
->been_active
)
1060 if (event
->filter_bytecode
)
1062 event
->filter_bytecode
= filter_bytecode
;
1067 * Need to attach filter to a wildcard before starting tracing for the
1068 * session. We own the filter_bytecode if we return success.
1070 int lttng_filter_wildcard_attach_bytecode(struct session_wildcard
*wildcard
,
1071 struct lttng_ust_filter_bytecode
*filter_bytecode
)
1073 if (wildcard
->chan
->session
->been_active
)
1075 if (wildcard
->filter_bytecode
)
1077 wildcard
->filter_bytecode
= filter_bytecode
;