4 * LTTng UST filter code.
6 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 #include <urcu/rculist.h>
29 #include "lttng-filter.h"
31 static const char *opnames
[] = {
32 [ FILTER_OP_UNKNOWN
] = "UNKNOWN",
34 [ FILTER_OP_RETURN
] = "RETURN",
37 [ FILTER_OP_MUL
] = "MUL",
38 [ FILTER_OP_DIV
] = "DIV",
39 [ FILTER_OP_MOD
] = "MOD",
40 [ FILTER_OP_PLUS
] = "PLUS",
41 [ FILTER_OP_MINUS
] = "MINUS",
42 [ FILTER_OP_BIT_RSHIFT
] = "BIT_RSHIFT",
43 [ FILTER_OP_BIT_LSHIFT
] = "BIT_LSHIFT",
44 [ FILTER_OP_BIT_AND
] = "BIT_AND",
45 [ FILTER_OP_BIT_OR
] = "BIT_OR",
46 [ FILTER_OP_BIT_XOR
] = "BIT_XOR",
48 /* binary comparators */
49 [ FILTER_OP_EQ
] = "EQ",
50 [ FILTER_OP_NE
] = "NE",
51 [ FILTER_OP_GT
] = "GT",
52 [ FILTER_OP_LT
] = "LT",
53 [ FILTER_OP_GE
] = "GE",
54 [ FILTER_OP_LE
] = "LE",
56 /* string binary comparators */
57 [ FILTER_OP_EQ_STRING
] = "EQ_STRING",
58 [ FILTER_OP_NE_STRING
] = "NE_STRING",
59 [ FILTER_OP_GT_STRING
] = "GT_STRING",
60 [ FILTER_OP_LT_STRING
] = "LT_STRING",
61 [ FILTER_OP_GE_STRING
] = "GE_STRING",
62 [ FILTER_OP_LE_STRING
] = "LE_STRING",
64 /* s64 binary comparators */
65 [ FILTER_OP_EQ_S64
] = "EQ_S64",
66 [ FILTER_OP_NE_S64
] = "NE_S64",
67 [ FILTER_OP_GT_S64
] = "GT_S64",
68 [ FILTER_OP_LT_S64
] = "LT_S64",
69 [ FILTER_OP_GE_S64
] = "GE_S64",
70 [ FILTER_OP_LE_S64
] = "LE_S64",
72 /* double binary comparators */
73 [ FILTER_OP_EQ_DOUBLE
] = "EQ_DOUBLE",
74 [ FILTER_OP_NE_DOUBLE
] = "NE_DOUBLE",
75 [ FILTER_OP_GT_DOUBLE
] = "GT_DOUBLE",
76 [ FILTER_OP_LT_DOUBLE
] = "LT_DOUBLE",
77 [ FILTER_OP_GE_DOUBLE
] = "GE_DOUBLE",
78 [ FILTER_OP_LE_DOUBLE
] = "LE_DOUBLE",
80 /* Mixed S64-double binary comparators */
81 [ FILTER_OP_EQ_DOUBLE_S64
] = "EQ_DOUBLE_S64",
82 [ FILTER_OP_NE_DOUBLE_S64
] = "NE_DOUBLE_S64",
83 [ FILTER_OP_GT_DOUBLE_S64
] = "GT_DOUBLE_S64",
84 [ FILTER_OP_LT_DOUBLE_S64
] = "LT_DOUBLE_S64",
85 [ FILTER_OP_GE_DOUBLE_S64
] = "GE_DOUBLE_S64",
86 [ FILTER_OP_LE_DOUBLE_S64
] = "LE_DOUBLE_S64",
88 [ FILTER_OP_EQ_S64_DOUBLE
] = "EQ_S64_DOUBLE",
89 [ FILTER_OP_NE_S64_DOUBLE
] = "NE_S64_DOUBLE",
90 [ FILTER_OP_GT_S64_DOUBLE
] = "GT_S64_DOUBLE",
91 [ FILTER_OP_LT_S64_DOUBLE
] = "LT_S64_DOUBLE",
92 [ FILTER_OP_GE_S64_DOUBLE
] = "GE_S64_DOUBLE",
93 [ FILTER_OP_LE_S64_DOUBLE
] = "LE_S64_DOUBLE",
96 [ FILTER_OP_UNARY_PLUS
] = "UNARY_PLUS",
97 [ FILTER_OP_UNARY_MINUS
] = "UNARY_MINUS",
98 [ FILTER_OP_UNARY_NOT
] = "UNARY_NOT",
99 [ FILTER_OP_UNARY_PLUS_S64
] = "UNARY_PLUS_S64",
100 [ FILTER_OP_UNARY_MINUS_S64
] = "UNARY_MINUS_S64",
101 [ FILTER_OP_UNARY_NOT_S64
] = "UNARY_NOT_S64",
102 [ FILTER_OP_UNARY_PLUS_DOUBLE
] = "UNARY_PLUS_DOUBLE",
103 [ FILTER_OP_UNARY_MINUS_DOUBLE
] = "UNARY_MINUS_DOUBLE",
104 [ FILTER_OP_UNARY_NOT_DOUBLE
] = "UNARY_NOT_DOUBLE",
107 [ FILTER_OP_AND
] = "AND",
108 [ FILTER_OP_OR
] = "OR",
111 [ FILTER_OP_LOAD_FIELD_REF
] = "LOAD_FIELD_REF",
112 [ FILTER_OP_LOAD_FIELD_REF_STRING
] = "LOAD_FIELD_REF_STRING",
113 [ FILTER_OP_LOAD_FIELD_REF_SEQUENCE
] = "LOAD_FIELD_REF_SEQUENCE",
114 [ FILTER_OP_LOAD_FIELD_REF_S64
] = "LOAD_FIELD_REF_S64",
115 [ FILTER_OP_LOAD_FIELD_REF_DOUBLE
] = "LOAD_FIELD_REF_DOUBLE",
117 /* load from immediate operand */
118 [ FILTER_OP_LOAD_STRING
] = "LOAD_STRING",
119 [ FILTER_OP_LOAD_S64
] = "LOAD_S64",
120 [ FILTER_OP_LOAD_DOUBLE
] = "LOAD_DOUBLE",
123 [ FILTER_OP_CAST_TO_S64
] = "CAST_TO_S64",
124 [ FILTER_OP_CAST_DOUBLE_TO_S64
] = "CAST_DOUBLE_TO_S64",
125 [ FILTER_OP_CAST_NOP
] = "CAST_NOP",
127 /* get context ref */
128 [ FILTER_OP_GET_CONTEXT_REF
] = "GET_CONTEXT_REF",
129 [ FILTER_OP_GET_CONTEXT_REF_STRING
] = "GET_CONTEXT_REF_STRING",
130 [ FILTER_OP_GET_CONTEXT_REF_S64
] = "GET_CONTEXT_REF_S64",
131 [ FILTER_OP_GET_CONTEXT_REF_DOUBLE
] = "GET_CONTEXT_REF_DOUBLE",
133 /* load userspace field ref */
134 [ FILTER_OP_LOAD_FIELD_REF_USER_STRING
] = "LOAD_FIELD_REF_USER_STRING",
135 [ FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE
] = "LOAD_FIELD_REF_USER_SEQUENCE",
138 * load immediate star globbing pattern (literal string)
141 [ FILTER_OP_LOAD_STAR_GLOB_STRING
] = "LOAD_STAR_GLOB_STRING",
143 /* globbing pattern binary operator: apply to */
144 [ FILTER_OP_EQ_STAR_GLOB_STRING
] = "EQ_STAR_GLOB_STRING",
145 [ FILTER_OP_NE_STAR_GLOB_STRING
] = "NE_STAR_GLOB_STRING",
148 * Instructions for recursive traversal through composed types.
150 [ FILTER_OP_GET_CONTEXT_ROOT
] = "GET_CONTEXT_ROOT",
151 [ FILTER_OP_GET_APP_CONTEXT_ROOT
] = "GET_APP_CONTEXT_ROOT",
152 [ FILTER_OP_GET_PAYLOAD_ROOT
] = "GET_PAYLOAD_ROOT",
154 [ FILTER_OP_GET_SYMBOL
] = "GET_SYMBOL",
155 [ FILTER_OP_GET_SYMBOL_FIELD
] = "GET_SYMBOL_FIELD",
156 [ FILTER_OP_GET_INDEX_U16
] = "GET_INDEX_U16",
157 [ FILTER_OP_GET_INDEX_U64
] = "GET_INDEX_U64",
159 [ FILTER_OP_LOAD_FIELD
] = "LOAD_FIELD",
160 [ FILTER_OP_LOAD_FIELD_S8
] = "LOAD_FIELD_S8",
161 [ FILTER_OP_LOAD_FIELD_S16
] = "LOAD_FIELD_S16",
162 [ FILTER_OP_LOAD_FIELD_S32
] = "LOAD_FIELD_S32",
163 [ FILTER_OP_LOAD_FIELD_S64
] = "LOAD_FIELD_S64",
164 [ FILTER_OP_LOAD_FIELD_U8
] = "LOAD_FIELD_U8",
165 [ FILTER_OP_LOAD_FIELD_U16
] = "LOAD_FIELD_U16",
166 [ FILTER_OP_LOAD_FIELD_U32
] = "LOAD_FIELD_U32",
167 [ FILTER_OP_LOAD_FIELD_U64
] = "LOAD_FIELD_U64",
168 [ FILTER_OP_LOAD_FIELD_STRING
] = "LOAD_FIELD_STRING",
169 [ FILTER_OP_LOAD_FIELD_SEQUENCE
] = "LOAD_FIELD_SEQUENCE",
170 [ FILTER_OP_LOAD_FIELD_DOUBLE
] = "LOAD_FIELD_DOUBLE",
172 [ FILTER_OP_UNARY_BIT_NOT
] = "UNARY_BIT_NOT",
174 [ FILTER_OP_RETURN_S64
] = "RETURN_S64",
177 const char *print_op(enum filter_op op
)
179 if (op
>= NR_FILTER_OPS
)
186 int apply_field_reloc(struct lttng_event
*event
,
187 struct bytecode_runtime
*runtime
,
188 uint32_t runtime_len
,
189 uint32_t reloc_offset
,
190 const char *field_name
,
191 enum filter_op filter_op
)
193 const struct lttng_event_desc
*desc
;
194 const struct lttng_event_field
*fields
, *field
= NULL
;
195 unsigned int nr_fields
, i
;
197 uint32_t field_offset
= 0;
199 dbg_printf("Apply field reloc: %u %s\n", reloc_offset
, field_name
);
201 /* Lookup event by name */
205 fields
= desc
->fields
;
208 nr_fields
= desc
->nr_fields
;
209 for (i
= 0; i
< nr_fields
; i
++) {
210 if (!strcmp(fields
[i
].name
, field_name
)) {
214 /* compute field offset */
215 switch (fields
[i
].type
.atype
) {
218 field_offset
+= sizeof(int64_t);
222 field_offset
+= sizeof(unsigned long);
223 field_offset
+= sizeof(void *);
226 field_offset
+= sizeof(void *);
229 field_offset
+= sizeof(double);
238 /* Check if field offset is too large for 16-bit offset */
239 if (field_offset
> FILTER_BYTECODE_MAX_LEN
- 1)
243 op
= (struct load_op
*) &runtime
->code
[reloc_offset
];
246 case FILTER_OP_LOAD_FIELD_REF
:
248 struct field_ref
*field_ref
;
250 field_ref
= (struct field_ref
*) op
->data
;
251 switch (field
->type
.atype
) {
254 op
->op
= FILTER_OP_LOAD_FIELD_REF_S64
;
258 const struct lttng_basic_type
*elem_type
= &field
->type
.u
.array
.elem_type
;
260 if (elem_type
->atype
!= atype_integer
|| elem_type
->u
.basic
.integer
.encoding
== lttng_encode_none
)
262 op
->op
= FILTER_OP_LOAD_FIELD_REF_SEQUENCE
;
267 const struct lttng_basic_type
*elem_type
= &field
->type
.u
.sequence
.elem_type
;
269 if (elem_type
->atype
!= atype_integer
|| elem_type
->u
.basic
.integer
.encoding
== lttng_encode_none
)
271 op
->op
= FILTER_OP_LOAD_FIELD_REF_SEQUENCE
;
275 op
->op
= FILTER_OP_LOAD_FIELD_REF_STRING
;
278 op
->op
= FILTER_OP_LOAD_FIELD_REF_DOUBLE
;
284 field_ref
->offset
= (uint16_t) field_offset
;
294 int apply_context_reloc(struct lttng_event
*event
,
295 struct bytecode_runtime
*runtime
,
296 uint32_t runtime_len
,
297 uint32_t reloc_offset
,
298 const char *context_name
,
299 enum filter_op filter_op
)
302 struct lttng_ctx_field
*ctx_field
;
304 struct lttng_session
*session
= runtime
->p
.session
;
306 dbg_printf("Apply context reloc: %u %s\n", reloc_offset
, context_name
);
308 /* Get context index */
309 idx
= lttng_get_context_index(session
->ctx
, context_name
);
311 if (lttng_context_is_app(context_name
)) {
314 ret
= lttng_ust_add_app_context_to_ctx_rcu(context_name
,
318 idx
= lttng_get_context_index(session
->ctx
,
326 /* Check if idx is too large for 16-bit offset */
327 if (idx
> FILTER_BYTECODE_MAX_LEN
- 1)
330 /* Get context return type */
331 ctx_field
= &session
->ctx
->fields
[idx
];
332 op
= (struct load_op
*) &runtime
->code
[reloc_offset
];
335 case FILTER_OP_GET_CONTEXT_REF
:
337 struct field_ref
*field_ref
;
339 field_ref
= (struct field_ref
*) op
->data
;
340 switch (ctx_field
->event_field
.type
.atype
) {
343 op
->op
= FILTER_OP_GET_CONTEXT_REF_S64
;
345 /* Sequence and array supported as string */
348 const struct lttng_basic_type
*elem_type
= &ctx_field
->event_field
.type
.u
.array
.elem_type
;
350 if (elem_type
->atype
!= atype_integer
|| elem_type
->u
.basic
.integer
.encoding
== lttng_encode_none
)
352 op
->op
= FILTER_OP_GET_CONTEXT_REF_STRING
;
357 const struct lttng_basic_type
*elem_type
= &ctx_field
->event_field
.type
.u
.sequence
.elem_type
;
359 if (elem_type
->atype
!= atype_integer
|| elem_type
->u
.basic
.integer
.encoding
== lttng_encode_none
)
361 op
->op
= FILTER_OP_GET_CONTEXT_REF_STRING
;
365 op
->op
= FILTER_OP_GET_CONTEXT_REF_STRING
;
368 op
->op
= FILTER_OP_GET_CONTEXT_REF_DOUBLE
;
371 op
->op
= FILTER_OP_GET_CONTEXT_REF
;
376 /* set offset to context index within channel contexts */
377 field_ref
->offset
= (uint16_t) idx
;
387 int apply_reloc(struct lttng_event
*event
,
388 struct bytecode_runtime
*runtime
,
389 uint32_t runtime_len
,
390 uint32_t reloc_offset
,
395 dbg_printf("Apply reloc: %u %s\n", reloc_offset
, name
);
397 /* Ensure that the reloc is within the code */
398 if (runtime_len
- reloc_offset
< sizeof(uint16_t))
401 op
= (struct load_op
*) &runtime
->code
[reloc_offset
];
403 case FILTER_OP_LOAD_FIELD_REF
:
404 return apply_field_reloc(event
, runtime
, runtime_len
,
405 reloc_offset
, name
, op
->op
);
406 case FILTER_OP_GET_CONTEXT_REF
:
407 return apply_context_reloc(event
, runtime
, runtime_len
,
408 reloc_offset
, name
, op
->op
);
409 case FILTER_OP_GET_SYMBOL
:
410 case FILTER_OP_GET_SYMBOL_FIELD
:
412 * Will be handled by load specialize phase or
413 * dynamically by interpreter.
417 ERR("Unknown reloc op type %u\n", op
->op
);
424 int bytecode_is_linked(struct lttng_ust_filter_bytecode_node
*filter_bytecode
,
425 struct lttng_event
*event
)
427 struct lttng_bytecode_runtime
*bc_runtime
;
429 cds_list_for_each_entry(bc_runtime
,
430 &event
->bytecode_runtime_head
, node
) {
431 if (bc_runtime
->bc
== filter_bytecode
)
438 * Take a bytecode with reloc table and link it to an event to create a
442 int _lttng_filter_event_link_bytecode(struct lttng_event
*event
,
443 struct lttng_ust_filter_bytecode_node
*filter_bytecode
,
444 struct cds_list_head
*insert_loc
)
446 int ret
, offset
, next_offset
;
447 struct bytecode_runtime
*runtime
= NULL
;
448 size_t runtime_alloc_len
;
450 if (!filter_bytecode
)
452 /* Bytecode already linked */
453 if (bytecode_is_linked(filter_bytecode
, event
))
456 dbg_printf("Linking...\n");
458 /* We don't need the reloc table in the runtime */
459 runtime_alloc_len
= sizeof(*runtime
) + filter_bytecode
->bc
.reloc_offset
;
460 runtime
= zmalloc(runtime_alloc_len
);
465 runtime
->p
.bc
= filter_bytecode
;
466 runtime
->p
.session
= event
->chan
->session
;
467 runtime
->p
.event
= event
;
468 runtime
->len
= filter_bytecode
->bc
.reloc_offset
;
469 /* copy original bytecode */
470 memcpy(runtime
->code
, filter_bytecode
->bc
.data
, runtime
->len
);
472 * apply relocs. Those are a uint16_t (offset in bytecode)
473 * followed by a string (field name).
475 for (offset
= filter_bytecode
->bc
.reloc_offset
;
476 offset
< filter_bytecode
->bc
.len
;
477 offset
= next_offset
) {
478 uint16_t reloc_offset
=
479 *(uint16_t *) &filter_bytecode
->bc
.data
[offset
];
481 (const char *) &filter_bytecode
->bc
.data
[offset
+ sizeof(uint16_t)];
483 ret
= apply_reloc(event
, runtime
, runtime
->len
, reloc_offset
, name
);
487 next_offset
= offset
+ sizeof(uint16_t) + strlen(name
) + 1;
489 /* Validate bytecode */
490 ret
= lttng_filter_validate_bytecode(runtime
);
494 /* Specialize bytecode */
495 ret
= lttng_filter_specialize_bytecode(event
, runtime
);
499 runtime
->p
.filter
= lttng_filter_interpret_bytecode
;
500 runtime
->p
.link_failed
= 0;
501 cds_list_add_rcu(&runtime
->p
.node
, insert_loc
);
502 dbg_printf("Linking successful.\n");
506 runtime
->p
.filter
= lttng_filter_false
;
507 runtime
->p
.link_failed
= 1;
508 cds_list_add_rcu(&runtime
->p
.node
, insert_loc
);
510 dbg_printf("Linking failed.\n");
514 void lttng_filter_sync_state(struct lttng_bytecode_runtime
*runtime
)
516 struct lttng_ust_filter_bytecode_node
*bc
= runtime
->bc
;
518 if (!bc
->enabler
->enabled
|| runtime
->link_failed
)
519 runtime
->filter
= lttng_filter_false
;
521 runtime
->filter
= lttng_filter_interpret_bytecode
;
525 * Link bytecode for all enablers referenced by an event.
527 void lttng_enabler_event_link_bytecode(struct lttng_event
*event
,
528 struct lttng_enabler
*enabler
)
530 struct lttng_ust_filter_bytecode_node
*bc
;
531 struct lttng_bytecode_runtime
*runtime
;
533 /* Can only be called for events with desc attached */
536 /* Link each bytecode. */
537 cds_list_for_each_entry(bc
, &enabler
->filter_bytecode_head
, node
) {
539 struct cds_list_head
*insert_loc
;
541 cds_list_for_each_entry(runtime
,
542 &event
->bytecode_runtime_head
, node
) {
543 if (runtime
->bc
== bc
) {
548 /* Skip bytecode already linked */
553 * Insert at specified priority (seqnum) in increasing
556 cds_list_for_each_entry_reverse(runtime
,
557 &event
->bytecode_runtime_head
, node
) {
558 if (runtime
->bc
->bc
.seqnum
< bc
->bc
.seqnum
) {
560 insert_loc
= &runtime
->node
;
564 /* Add to head to list */
565 insert_loc
= &event
->bytecode_runtime_head
;
567 dbg_printf("linking bytecode\n");
568 ret
= _lttng_filter_event_link_bytecode(event
, bc
,
571 dbg_printf("[lttng filter] warning: cannot link event bytecode\n");
577 * We own the filter_bytecode if we return success.
579 int lttng_filter_enabler_attach_bytecode(struct lttng_enabler
*enabler
,
580 struct lttng_ust_filter_bytecode_node
*filter_bytecode
)
582 cds_list_add(&filter_bytecode
->node
, &enabler
->filter_bytecode_head
);
586 void lttng_free_enabler_filter_bytecode(struct lttng_enabler
*enabler
)
588 struct lttng_ust_filter_bytecode_node
*filter_bytecode
, *tmp
;
590 cds_list_for_each_entry_safe(filter_bytecode
, tmp
,
591 &enabler
->filter_bytecode_head
, node
) {
592 free(filter_bytecode
);
596 void lttng_free_event_filter_runtime(struct lttng_event
*event
)
598 struct bytecode_runtime
*runtime
, *tmp
;
600 cds_list_for_each_entry_safe(runtime
, tmp
,
601 &event
->bytecode_runtime_head
, p
.node
) {