From 80c2a69a8298768c9010052e6c3668914191b9e7 Mon Sep 17 00:00:00 2001 From: Francis Deslauriers Date: Tue, 12 May 2020 16:10:04 -0400 Subject: [PATCH] Rename filter bytecode types and files File renames: - filter-bytecode.h -> bytecode.h - lttng-filter-interpreter.c -> lttng-bytecode-interpreter.c - lttng-filter-specialize.c -> lttng-bytecode-specialize.c - lttng-filter-validator.c -> lttng-bytecode-validator.c - lttng-filter.c -> lttng-bytecode.c - lttng-filter.h -> lttng-bytecode.h Function renames: - `lttng_filter_interpret_bytecode_false()` -> `lttng_bytecode_filter_interpret_false()` - `lttng_filter_interpret_bytecode()` -> `lttng_bytecode_filter_interpret()` - `lttng_filter_specialize_bytecode()` -> `lttng_bytecode_specialize()` - `lttng_filter_validate_bytecode()` -> `lttng_bytecode_validate()` Type renames - `filter_opcode_t` to `bytecode_opcode_t` Enum renames: - `enum filter_op` to `enum bytecode_op` - `FILTER_OP_*` to `BYTECODE_OP_*` - `enum lttng_filter_ret` -> `enum lttng_bytecode_interpreter_ret` - `LTTNG_FILTER_DISCARD` -> `LTTNG_INTERPRETER_DISCARD` - `LTTNG_FILTER_RECORD_FLAG` -> `LTTNG_INTERPRETER_RECORD_FLAG` Define renames: - `FILTER_STACK_EMPTY` -> `INTERPRETER_STACK_EMPTY` - `FILTER_STACK_LEN`-> `INTERPRETER_STACK_LEN` - `FILTER_MAX_DATA_LEN` -> `BYTECODE_MAX_DATA_LEN` Signed-off-by: Francis Deslauriers Signed-off-by: Mathieu Desnoyers Change-Id: I8cd3a15c8ba19aa1d66e611913a1b08e51d94a43 --- include/lttng/bytecode.h | 225 +++++ include/lttng/events.h | 8 +- include/lttng/filter-bytecode.h | 225 ----- include/lttng/{filter.h => lttng-bytecode.h} | 45 +- include/lttng/tracepoint-event-impl.h | 8 +- src/Kbuild | 6 +- ...rpreter.c => lttng-bytecode-interpreter.c} | 508 +++++------ ...ecialize.c => lttng-bytecode-specialize.c} | 390 ++++----- ...validator.c => lttng-bytecode-validator.c} | 808 +++++++++--------- src/{lttng-filter.c => lttng-bytecode.c} | 270 +++--- 10 files changed, 1246 insertions(+), 1247 deletions(-) create mode 100644 include/lttng/bytecode.h delete mode 100644 include/lttng/filter-bytecode.h rename include/lttng/{filter.h => lttng-bytecode.h} (84%) rename src/{lttng-filter-interpreter.c => lttng-bytecode-interpreter.c} (73%) rename src/{lttng-filter-specialize.c => lttng-bytecode-specialize.c} (72%) rename src/{lttng-filter-validator.c => lttng-bytecode-validator.c} (60%) rename src/{lttng-filter.c => lttng-bytecode.c} (62%) diff --git a/include/lttng/bytecode.h b/include/lttng/bytecode.h new file mode 100644 index 00000000..6bb20b83 --- /dev/null +++ b/include/lttng/bytecode.h @@ -0,0 +1,225 @@ +/* SPDX-License-Identifier: MIT + * + * lttng/filter-bytecode.h + * + * LTTng filter bytecode + * + * Copyright 2012-2016 - Mathieu Desnoyers + */ + +#ifndef _FILTER_BYTECODE_H +#define _FILTER_BYTECODE_H + +/* + * offsets are absolute from start of bytecode. + */ + +struct field_ref { + /* Initially, symbol offset. After link, field offset. */ + uint16_t offset; +} __attribute__((packed)); + +struct get_symbol { + /* Symbol offset. */ + uint16_t offset; +} __attribute__((packed)); + +struct get_index_u16 { + uint16_t index; +} __attribute__((packed)); + +struct get_index_u64 { + uint64_t index; +} __attribute__((packed)); + +struct literal_numeric { + int64_t v; +} __attribute__((packed)); + +struct literal_double { + double v; +} __attribute__((packed)); + +struct literal_string { + char string[0]; +} __attribute__((packed)); + +enum bytecode_op { + BYTECODE_OP_UNKNOWN = 0, + + BYTECODE_OP_RETURN = 1, + + /* binary */ + BYTECODE_OP_MUL = 2, + BYTECODE_OP_DIV = 3, + BYTECODE_OP_MOD = 4, + BYTECODE_OP_PLUS = 5, + BYTECODE_OP_MINUS = 6, + BYTECODE_OP_BIT_RSHIFT = 7, + BYTECODE_OP_BIT_LSHIFT = 8, + BYTECODE_OP_BIT_AND = 9, + BYTECODE_OP_BIT_OR = 10, + BYTECODE_OP_BIT_XOR = 11, + + /* binary comparators */ + BYTECODE_OP_EQ = 12, + BYTECODE_OP_NE = 13, + BYTECODE_OP_GT = 14, + BYTECODE_OP_LT = 15, + BYTECODE_OP_GE = 16, + BYTECODE_OP_LE = 17, + + /* string binary comparator: apply to */ + BYTECODE_OP_EQ_STRING = 18, + BYTECODE_OP_NE_STRING = 19, + BYTECODE_OP_GT_STRING = 20, + BYTECODE_OP_LT_STRING = 21, + BYTECODE_OP_GE_STRING = 22, + BYTECODE_OP_LE_STRING = 23, + + /* s64 binary comparator */ + BYTECODE_OP_EQ_S64 = 24, + BYTECODE_OP_NE_S64 = 25, + BYTECODE_OP_GT_S64 = 26, + BYTECODE_OP_LT_S64 = 27, + BYTECODE_OP_GE_S64 = 28, + BYTECODE_OP_LE_S64 = 29, + + /* double binary comparator */ + BYTECODE_OP_EQ_DOUBLE = 30, + BYTECODE_OP_NE_DOUBLE = 31, + BYTECODE_OP_GT_DOUBLE = 32, + BYTECODE_OP_LT_DOUBLE = 33, + BYTECODE_OP_GE_DOUBLE = 34, + BYTECODE_OP_LE_DOUBLE = 35, + + /* Mixed S64-double binary comparators */ + BYTECODE_OP_EQ_DOUBLE_S64 = 36, + BYTECODE_OP_NE_DOUBLE_S64 = 37, + BYTECODE_OP_GT_DOUBLE_S64 = 38, + BYTECODE_OP_LT_DOUBLE_S64 = 39, + BYTECODE_OP_GE_DOUBLE_S64 = 40, + BYTECODE_OP_LE_DOUBLE_S64 = 41, + + BYTECODE_OP_EQ_S64_DOUBLE = 42, + BYTECODE_OP_NE_S64_DOUBLE = 43, + BYTECODE_OP_GT_S64_DOUBLE = 44, + BYTECODE_OP_LT_S64_DOUBLE = 45, + BYTECODE_OP_GE_S64_DOUBLE = 46, + BYTECODE_OP_LE_S64_DOUBLE = 47, + + /* unary */ + BYTECODE_OP_UNARY_PLUS = 48, + BYTECODE_OP_UNARY_MINUS = 49, + BYTECODE_OP_UNARY_NOT = 50, + BYTECODE_OP_UNARY_PLUS_S64 = 51, + BYTECODE_OP_UNARY_MINUS_S64 = 52, + BYTECODE_OP_UNARY_NOT_S64 = 53, + BYTECODE_OP_UNARY_PLUS_DOUBLE = 54, + BYTECODE_OP_UNARY_MINUS_DOUBLE = 55, + BYTECODE_OP_UNARY_NOT_DOUBLE = 56, + + /* logical */ + BYTECODE_OP_AND = 57, + BYTECODE_OP_OR = 58, + + /* load field ref */ + BYTECODE_OP_LOAD_FIELD_REF = 59, + BYTECODE_OP_LOAD_FIELD_REF_STRING = 60, + BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE = 61, + BYTECODE_OP_LOAD_FIELD_REF_S64 = 62, + BYTECODE_OP_LOAD_FIELD_REF_DOUBLE = 63, + + /* load immediate from operand */ + BYTECODE_OP_LOAD_STRING = 64, + BYTECODE_OP_LOAD_S64 = 65, + BYTECODE_OP_LOAD_DOUBLE = 66, + + /* cast */ + BYTECODE_OP_CAST_TO_S64 = 67, + BYTECODE_OP_CAST_DOUBLE_TO_S64 = 68, + BYTECODE_OP_CAST_NOP = 69, + + /* get context ref */ + BYTECODE_OP_GET_CONTEXT_REF = 70, + BYTECODE_OP_GET_CONTEXT_REF_STRING = 71, + BYTECODE_OP_GET_CONTEXT_REF_S64 = 72, + BYTECODE_OP_GET_CONTEXT_REF_DOUBLE = 73, + + /* load userspace field ref */ + BYTECODE_OP_LOAD_FIELD_REF_USER_STRING = 74, + BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75, + + /* + * load immediate star globbing pattern (literal string) + * from immediate + */ + BYTECODE_OP_LOAD_STAR_GLOB_STRING = 76, + + /* globbing pattern binary operator: apply to */ + BYTECODE_OP_EQ_STAR_GLOB_STRING = 77, + BYTECODE_OP_NE_STAR_GLOB_STRING = 78, + + /* + * Instructions for recursive traversal through composed types. + */ + BYTECODE_OP_GET_CONTEXT_ROOT = 79, + BYTECODE_OP_GET_APP_CONTEXT_ROOT = 80, + BYTECODE_OP_GET_PAYLOAD_ROOT = 81, + + BYTECODE_OP_GET_SYMBOL = 82, + BYTECODE_OP_GET_SYMBOL_FIELD = 83, + BYTECODE_OP_GET_INDEX_U16 = 84, + BYTECODE_OP_GET_INDEX_U64 = 85, + + BYTECODE_OP_LOAD_FIELD = 86, + BYTECODE_OP_LOAD_FIELD_S8 = 87, + BYTECODE_OP_LOAD_FIELD_S16 = 88, + BYTECODE_OP_LOAD_FIELD_S32 = 89, + BYTECODE_OP_LOAD_FIELD_S64 = 90, + BYTECODE_OP_LOAD_FIELD_U8 = 91, + BYTECODE_OP_LOAD_FIELD_U16 = 92, + BYTECODE_OP_LOAD_FIELD_U32 = 93, + BYTECODE_OP_LOAD_FIELD_U64 = 94, + BYTECODE_OP_LOAD_FIELD_STRING = 95, + BYTECODE_OP_LOAD_FIELD_SEQUENCE = 96, + BYTECODE_OP_LOAD_FIELD_DOUBLE = 97, + + BYTECODE_OP_UNARY_BIT_NOT = 98, + + BYTECODE_OP_RETURN_S64 = 99, + + NR_BYTECODE_OPS, +}; + +typedef uint8_t bytecode_opcode_t; + +struct load_op { + bytecode_opcode_t op; + char data[0]; + /* data to load. Size known by enum filter_opcode and null-term char. */ +} __attribute__((packed)); + +struct binary_op { + bytecode_opcode_t op; +} __attribute__((packed)); + +struct unary_op { + bytecode_opcode_t op; +} __attribute__((packed)); + +/* skip_offset is absolute from start of bytecode */ +struct logical_op { + bytecode_opcode_t op; + uint16_t skip_offset; /* bytecode insn, if skip second test */ +} __attribute__((packed)); + +struct cast_op { + bytecode_opcode_t op; +} __attribute__((packed)); + +struct return_op { + bytecode_opcode_t op; +} __attribute__((packed)); + +#endif /* _FILTER_BYTECODE_H */ diff --git a/include/lttng/events.h b/include/lttng/events.h index 517d689b..20c08cf8 100644 --- a/include/lttng/events.h +++ b/include/lttng/events.h @@ -249,11 +249,11 @@ struct lttng_bytecode_node { }; /* - * Filter return value masks. + * Bytecode interpreter return value masks. */ -enum lttng_filter_ret { - LTTNG_FILTER_DISCARD = 0, - LTTNG_FILTER_RECORD_FLAG = (1ULL << 0), +enum lttng_bytecode_interpreter_ret { + LTTNG_INTERPRETER_DISCARD = 0, + LTTNG_INTERPRETER_RECORD_FLAG = (1ULL << 0), /* Other bits are kept for future use. */ }; diff --git a/include/lttng/filter-bytecode.h b/include/lttng/filter-bytecode.h deleted file mode 100644 index cc1a8412..00000000 --- a/include/lttng/filter-bytecode.h +++ /dev/null @@ -1,225 +0,0 @@ -/* SPDX-License-Identifier: MIT - * - * lttng/filter-bytecode.h - * - * LTTng filter bytecode - * - * Copyright 2012-2016 - Mathieu Desnoyers - */ - -#ifndef _FILTER_BYTECODE_H -#define _FILTER_BYTECODE_H - -/* - * offsets are absolute from start of bytecode. - */ - -struct field_ref { - /* Initially, symbol offset. After link, field offset. */ - uint16_t offset; -} __attribute__((packed)); - -struct get_symbol { - /* Symbol offset. */ - uint16_t offset; -} __attribute__((packed)); - -struct get_index_u16 { - uint16_t index; -} __attribute__((packed)); - -struct get_index_u64 { - uint64_t index; -} __attribute__((packed)); - -struct literal_numeric { - int64_t v; -} __attribute__((packed)); - -struct literal_double { - double v; -} __attribute__((packed)); - -struct literal_string { - char string[0]; -} __attribute__((packed)); - -enum filter_op { - FILTER_OP_UNKNOWN = 0, - - FILTER_OP_RETURN = 1, - - /* binary */ - FILTER_OP_MUL = 2, - FILTER_OP_DIV = 3, - FILTER_OP_MOD = 4, - FILTER_OP_PLUS = 5, - FILTER_OP_MINUS = 6, - FILTER_OP_BIT_RSHIFT = 7, - FILTER_OP_BIT_LSHIFT = 8, - FILTER_OP_BIT_AND = 9, - FILTER_OP_BIT_OR = 10, - FILTER_OP_BIT_XOR = 11, - - /* binary comparators */ - FILTER_OP_EQ = 12, - FILTER_OP_NE = 13, - FILTER_OP_GT = 14, - FILTER_OP_LT = 15, - FILTER_OP_GE = 16, - FILTER_OP_LE = 17, - - /* string binary comparator: apply to */ - FILTER_OP_EQ_STRING = 18, - FILTER_OP_NE_STRING = 19, - FILTER_OP_GT_STRING = 20, - FILTER_OP_LT_STRING = 21, - FILTER_OP_GE_STRING = 22, - FILTER_OP_LE_STRING = 23, - - /* s64 binary comparator */ - FILTER_OP_EQ_S64 = 24, - FILTER_OP_NE_S64 = 25, - FILTER_OP_GT_S64 = 26, - FILTER_OP_LT_S64 = 27, - FILTER_OP_GE_S64 = 28, - FILTER_OP_LE_S64 = 29, - - /* double binary comparator */ - FILTER_OP_EQ_DOUBLE = 30, - FILTER_OP_NE_DOUBLE = 31, - FILTER_OP_GT_DOUBLE = 32, - FILTER_OP_LT_DOUBLE = 33, - FILTER_OP_GE_DOUBLE = 34, - FILTER_OP_LE_DOUBLE = 35, - - /* Mixed S64-double binary comparators */ - FILTER_OP_EQ_DOUBLE_S64 = 36, - FILTER_OP_NE_DOUBLE_S64 = 37, - FILTER_OP_GT_DOUBLE_S64 = 38, - FILTER_OP_LT_DOUBLE_S64 = 39, - FILTER_OP_GE_DOUBLE_S64 = 40, - FILTER_OP_LE_DOUBLE_S64 = 41, - - FILTER_OP_EQ_S64_DOUBLE = 42, - FILTER_OP_NE_S64_DOUBLE = 43, - FILTER_OP_GT_S64_DOUBLE = 44, - FILTER_OP_LT_S64_DOUBLE = 45, - FILTER_OP_GE_S64_DOUBLE = 46, - FILTER_OP_LE_S64_DOUBLE = 47, - - /* unary */ - FILTER_OP_UNARY_PLUS = 48, - FILTER_OP_UNARY_MINUS = 49, - FILTER_OP_UNARY_NOT = 50, - FILTER_OP_UNARY_PLUS_S64 = 51, - FILTER_OP_UNARY_MINUS_S64 = 52, - FILTER_OP_UNARY_NOT_S64 = 53, - FILTER_OP_UNARY_PLUS_DOUBLE = 54, - FILTER_OP_UNARY_MINUS_DOUBLE = 55, - FILTER_OP_UNARY_NOT_DOUBLE = 56, - - /* logical */ - FILTER_OP_AND = 57, - FILTER_OP_OR = 58, - - /* load field ref */ - FILTER_OP_LOAD_FIELD_REF = 59, - FILTER_OP_LOAD_FIELD_REF_STRING = 60, - FILTER_OP_LOAD_FIELD_REF_SEQUENCE = 61, - FILTER_OP_LOAD_FIELD_REF_S64 = 62, - FILTER_OP_LOAD_FIELD_REF_DOUBLE = 63, - - /* load immediate from operand */ - FILTER_OP_LOAD_STRING = 64, - FILTER_OP_LOAD_S64 = 65, - FILTER_OP_LOAD_DOUBLE = 66, - - /* cast */ - FILTER_OP_CAST_TO_S64 = 67, - FILTER_OP_CAST_DOUBLE_TO_S64 = 68, - FILTER_OP_CAST_NOP = 69, - - /* get context ref */ - FILTER_OP_GET_CONTEXT_REF = 70, - FILTER_OP_GET_CONTEXT_REF_STRING = 71, - FILTER_OP_GET_CONTEXT_REF_S64 = 72, - FILTER_OP_GET_CONTEXT_REF_DOUBLE = 73, - - /* load userspace field ref */ - FILTER_OP_LOAD_FIELD_REF_USER_STRING = 74, - FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75, - - /* - * load immediate star globbing pattern (literal string) - * from immediate - */ - FILTER_OP_LOAD_STAR_GLOB_STRING = 76, - - /* globbing pattern binary operator: apply to */ - FILTER_OP_EQ_STAR_GLOB_STRING = 77, - FILTER_OP_NE_STAR_GLOB_STRING = 78, - - /* - * Instructions for recursive traversal through composed types. - */ - FILTER_OP_GET_CONTEXT_ROOT = 79, - FILTER_OP_GET_APP_CONTEXT_ROOT = 80, - FILTER_OP_GET_PAYLOAD_ROOT = 81, - - FILTER_OP_GET_SYMBOL = 82, - FILTER_OP_GET_SYMBOL_FIELD = 83, - FILTER_OP_GET_INDEX_U16 = 84, - FILTER_OP_GET_INDEX_U64 = 85, - - FILTER_OP_LOAD_FIELD = 86, - FILTER_OP_LOAD_FIELD_S8 = 87, - FILTER_OP_LOAD_FIELD_S16 = 88, - FILTER_OP_LOAD_FIELD_S32 = 89, - FILTER_OP_LOAD_FIELD_S64 = 90, - FILTER_OP_LOAD_FIELD_U8 = 91, - FILTER_OP_LOAD_FIELD_U16 = 92, - FILTER_OP_LOAD_FIELD_U32 = 93, - FILTER_OP_LOAD_FIELD_U64 = 94, - FILTER_OP_LOAD_FIELD_STRING = 95, - FILTER_OP_LOAD_FIELD_SEQUENCE = 96, - FILTER_OP_LOAD_FIELD_DOUBLE = 97, - - FILTER_OP_UNARY_BIT_NOT = 98, - - FILTER_OP_RETURN_S64 = 99, - - NR_FILTER_OPS, -}; - -typedef uint8_t filter_opcode_t; - -struct load_op { - filter_opcode_t op; - char data[0]; - /* data to load. Size known by enum filter_opcode and null-term char. */ -} __attribute__((packed)); - -struct binary_op { - filter_opcode_t op; -} __attribute__((packed)); - -struct unary_op { - filter_opcode_t op; -} __attribute__((packed)); - -/* skip_offset is absolute from start of bytecode */ -struct logical_op { - filter_opcode_t op; - uint16_t skip_offset; /* bytecode insn, if skip second test */ -} __attribute__((packed)); - -struct cast_op { - filter_opcode_t op; -} __attribute__((packed)); - -struct return_op { - filter_opcode_t op; -} __attribute__((packed)); - -#endif /* _FILTER_BYTECODE_H */ diff --git a/include/lttng/filter.h b/include/lttng/lttng-bytecode.h similarity index 84% rename from include/lttng/filter.h rename to include/lttng/lttng-bytecode.h index 12833992..3cbb7b10 100644 --- a/include/lttng/filter.h +++ b/include/lttng/lttng-bytecode.h @@ -1,25 +1,24 @@ /* SPDX-License-Identifier: MIT * - * lttng/filter.h + * lttng/lttng-bytecode.h * - * LTTng modules filter header. + * LTTng modules bytecode header. * * Copyright (C) 2010-2016 Mathieu Desnoyers */ -#ifndef _LTTNG_FILTER_H -#define _LTTNG_FILTER_H +#ifndef _LTTNG_BYTECODE_H +#define _LTTNG_BYTECODE_H #include #include -#include +#include -/* Filter stack length, in number of entries */ -#define FILTER_STACK_LEN 10 /* includes 2 dummy */ -#define FILTER_STACK_EMPTY 1 - -#define FILTER_MAX_DATA_LEN 65536 +/* Interpreter stack length, in number of entries */ +#define INTERPRETER_STACK_LEN 10 /* includes 2 dummy */ +#define INTERPRETER_STACK_EMPTY 1 +#define INTERPRETER_MAX_DATA_LEN 65536 #ifdef DEBUG #define dbg_printk(fmt, args...) \ @@ -84,7 +83,7 @@ enum object_type { OBJECT_TYPE_DYNAMIC, }; -struct filter_get_index_data { +struct bytecode_get_index_data { uint64_t offset; /* in bytes */ size_t ctx_index; size_t array_len; @@ -117,7 +116,7 @@ struct vstack_entry { struct vstack { int top; /* top of stack */ - struct vstack_entry e[FILTER_STACK_LEN]; + struct vstack_entry e[INTERPRETER_STACK_LEN]; }; static inline @@ -145,7 +144,7 @@ struct vstack_entry *vstack_bx(struct vstack *stack) static inline int vstack_push(struct vstack *stack) { - if (stack->top >= FILTER_STACK_LEN - 1) { + if (stack->top >= INTERPRETER_STACK_LEN - 1) { printk(KERN_WARNING "LTTng: filter: Stack full\n"); return -EINVAL; } @@ -204,7 +203,7 @@ struct estack_entry { struct estack { int top; /* top of stack */ - struct estack_entry e[FILTER_STACK_LEN]; + struct estack_entry e[INTERPRETER_STACK_LEN]; }; #define estack_ax_v ax @@ -215,19 +214,19 @@ struct estack { #define estack_ax(stack, top) \ ({ \ - BUG_ON((top) <= FILTER_STACK_EMPTY); \ + BUG_ON((top) <= INTERPRETER_STACK_EMPTY); \ &(stack)->e[top]; \ }) #define estack_bx(stack, top) \ ({ \ - BUG_ON((top) <= FILTER_STACK_EMPTY + 1); \ + BUG_ON((top) <= INTERPRETER_STACK_EMPTY + 1); \ &(stack)->e[(top) - 1]; \ }) #define estack_push(stack, top, ax, bx, ax_t, bx_t) \ do { \ - BUG_ON((top) >= FILTER_STACK_LEN - 1); \ + BUG_ON((top) >= INTERPRETER_STACK_LEN - 1); \ (stack)->e[(top) - 1].u.v = (bx); \ (stack)->e[(top) - 1].type = (bx_t); \ (bx) = (ax); \ @@ -237,7 +236,7 @@ struct estack { #define estack_pop(stack, top, ax, bx, ax_t, bx_t) \ do { \ - BUG_ON((top) <= FILTER_STACK_EMPTY); \ + BUG_ON((top) <= INTERPRETER_STACK_EMPTY); \ (ax) = (bx); \ (ax_t) = (bx_t); \ (bx) = (stack)->e[(top) - 2].u.v; \ @@ -280,16 +279,16 @@ struct lttng_interpreter_output { } u; }; -const char *lttng_filter_print_op(enum filter_op op); +const char *lttng_bytecode_print_op(enum bytecode_op op); -int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode); -int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, +int lttng_bytecode_validate(struct bytecode_runtime *bytecode); +int lttng_bytecode_specialize(const struct lttng_event_desc *event_desc, struct bytecode_runtime *bytecode); -uint64_t lttng_filter_interpret_bytecode_false(void *filter_data, +uint64_t lttng_bytecode_filter_interpret_false(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, const char *filter_stack_data); -uint64_t lttng_filter_interpret_bytecode(void *filter_data, +uint64_t lttng_bytecode_filter_interpret(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, const char *filter_stack_data); diff --git a/include/lttng/tracepoint-event-impl.h b/include/lttng/tracepoint-event-impl.h index 1a51cb39..d5bb7ed7 100644 --- a/include/lttng/tracepoint-event-impl.h +++ b/include/lttng/tracepoint-event-impl.h @@ -1250,7 +1250,7 @@ static void __event_probe__##_name(void *__data, _proto) \ tp_locvar, _args); \ lttng_list_for_each_entry_rcu(bc_runtime, &__event->filter_bytecode_runtime_head, node) { \ if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \ __filter_record = 1; \ break; \ } \ @@ -1346,7 +1346,7 @@ static void __event_probe__##_name(void *__data) \ tp_locvar); \ lttng_list_for_each_entry_rcu(bc_runtime, &__event->filter_bytecode_runtime_head, node) { \ if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \ __filter_record = 1; \ break; \ } \ @@ -1442,7 +1442,7 @@ static void __event_notifier_probe__##_name(void *__data, _proto) \ tp_locvar, _args); \ lttng_list_for_each_entry_rcu(bc_runtime, &__event_notifier->filter_bytecode_runtime_head, node) { \ if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) \ __filter_record = 1; \ } \ if (likely(!__filter_record)) \ @@ -1485,7 +1485,7 @@ static void __event_notifier_probe__##_name(void *__data) \ tp_locvar); \ lttng_list_for_each_entry_rcu(bc_runtime, &__event_notifier->filter_bytecode_runtime_head, node) { \ if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) \ __filter_record = 1; \ } \ if (likely(!__filter_record)) \ diff --git a/src/Kbuild b/src/Kbuild index e9b50d57..7f67791a 100644 --- a/src/Kbuild +++ b/src/Kbuild @@ -45,9 +45,9 @@ lttng-tracer-objs := lib/msgpack/msgpack.o \ lttng-context-hostname.o \ probes/lttng.o \ lttng-tracker-id.o \ - lttng-filter.o lttng-filter-interpreter.o \ - lttng-filter-specialize.o \ - lttng-filter-validator.o \ + lttng-bytecode.o lttng-bytecode-interpreter.o \ + lttng-bytecode-specialize.o \ + lttng-bytecode-validator.o \ probes/lttng-probe-user.o \ lttng-tp-mempool.o \ lttng-event-notifier-notification.o diff --git a/src/lttng-filter-interpreter.c b/src/lttng-bytecode-interpreter.c similarity index 73% rename from src/lttng-filter-interpreter.c rename to src/lttng-bytecode-interpreter.c index 403a712f..950c0ba0 100644 --- a/src/lttng-filter-interpreter.c +++ b/src/lttng-bytecode-interpreter.c @@ -1,8 +1,8 @@ /* SPDX-License-Identifier: MIT * - * lttng-filter-interpreter.c + * lttng-bytecode-interpreter.c * - * LTTng modules filter interpreter. + * LTTng modules bytecode interpreter. * * Copyright (C) 2010-2016 Mathieu Desnoyers */ @@ -12,7 +12,7 @@ #include #include -#include +#include #include /* @@ -207,11 +207,11 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type) return diff; } -uint64_t lttng_filter_interpret_bytecode_false(void *filter_data, +uint64_t lttng_bytecode_filter_interpret_false(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, const char *filter_stack_data) { - return LTTNG_FILTER_DISCARD; + return LTTNG_INTERPRETER_DISCARD; } #ifdef INTERPRETER_USE_SWITCH @@ -225,9 +225,9 @@ uint64_t lttng_filter_interpret_bytecode_false(void *filter_data, for (pc = next_pc = start_pc; pc - start_pc < bytecode->len; \ pc = next_pc) { \ dbg_printk("LTTng: Executing op %s (%u)\n", \ - lttng_filter_print_op((unsigned int) *(filter_opcode_t *) pc), \ - (unsigned int) *(filter_opcode_t *) pc); \ - switch (*(filter_opcode_t *) pc) { + lttng_bytecode_print_op((unsigned int) *(bytecode_opcode_t *) pc), \ + (unsigned int) *(bytecode_opcode_t *) pc); \ + switch (*(bytecode_opcode_t *) pc) { #define OP(name) case name @@ -247,14 +247,14 @@ uint64_t lttng_filter_interpret_bytecode_false(void *filter_data, pc = next_pc = start_pc; \ if (unlikely(pc - start_pc >= bytecode->len)) \ goto end; \ - goto *dispatch[*(filter_opcode_t *) pc]; + goto *dispatch[*(bytecode_opcode_t *) pc]; #define OP(name) \ LABEL_##name #define PO \ pc = next_pc; \ - goto *dispatch[*(filter_opcode_t *) pc]; + goto *dispatch[*(bytecode_opcode_t *) pc]; #define END_OP @@ -310,11 +310,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, } case atype_array_nestable: if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { - printk(KERN_WARNING "LTTng: filter: Array nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: bytecode: Array nesting only supports integer types.\n"); return -EINVAL; } if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) { - printk(KERN_WARNING "LTTng: filter: Only string arrays are supported for contexts.\n"); + printk(KERN_WARNING "LTTng: bytecode: Only string arrays are supported for contexts.\n"); return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; @@ -323,11 +323,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, break; case atype_sequence_nestable: if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { - printk(KERN_WARNING "LTTng: filter: Sequence nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: bytecode: Sequence nesting only supports integer types.\n"); return -EINVAL; } if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) { - printk(KERN_WARNING "LTTng: filter: Only string sequences are supported for contexts.\n"); + printk(KERN_WARNING "LTTng: bytecode: Only string sequences are supported for contexts.\n"); return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; @@ -340,13 +340,13 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, ptr->ptr = v.str; break; case atype_struct_nestable: - printk(KERN_WARNING "LTTng: filter: Structure type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n"); return -EINVAL; case atype_variant_nestable: - printk(KERN_WARNING "LTTng: filter: Variant type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: bytecode: Variant type cannot be loaded.\n"); return -EINVAL; default: - printk(KERN_WARNING "LTTng: filter: Unknown type: %d", (int) field->type.atype); + printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type.atype); return -EINVAL; } return 0; @@ -357,9 +357,9 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, uint64_t index, struct estack_entry *stack_top) { int ret; - const struct filter_get_index_data *gid; + const struct bytecode_get_index_data *gid; - gid = (const struct filter_get_index_data *) &runtime->data[index]; + gid = (const struct bytecode_get_index_data *) &runtime->data[index]; switch (stack_top->u.ptr.type) { case LOAD_OBJECT: switch (stack_top->u.ptr.object_type) { @@ -398,12 +398,12 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, break; } case OBJECT_TYPE_STRUCT: - printk(KERN_WARNING "LTTng: filter: Nested structures are not supported yet.\n"); + printk(KERN_WARNING "LTTng: bytecode: Nested structures are not supported yet.\n"); ret = -EINVAL; goto end; case OBJECT_TYPE_VARIANT: default: - printk(KERN_WARNING "LTTng: filter: Unexpected get index type %d", + printk(KERN_WARNING "LTTng: bytecode: Unexpected get index type %d", (int) stack_top->u.ptr.object_type); ret = -EINVAL; goto end; @@ -450,7 +450,7 @@ static int dynamic_load_field(struct estack_entry *stack_top) case LOAD_ROOT_APP_CONTEXT: case LOAD_ROOT_PAYLOAD: default: - dbg_printk("Filter warning: cannot load root, missing field name.\n"); + dbg_printk("Bytecode warning: cannot load root, missing field name.\n"); ret = -EINVAL; goto end; } @@ -545,7 +545,7 @@ static int dynamic_load_field(struct estack_entry *stack_top) str = (const char *) stack_top->u.ptr.ptr; stack_top->u.s.str = str; if (unlikely(!stack_top->u.s.str)) { - dbg_printk("Filter warning: loading a NULL string.\n"); + dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; goto end; } @@ -564,7 +564,7 @@ static int dynamic_load_field(struct estack_entry *stack_top) stack_top->u.s.seq_len = *(unsigned long *) ptr; stack_top->u.s.str = *(const char **) (ptr + sizeof(unsigned long)); if (unlikely(!stack_top->u.s.str)) { - dbg_printk("Filter warning: loading a NULL sequence.\n"); + dbg_printk("Bytecode warning: loading a NULL sequence.\n"); ret = -EINVAL; goto end; } @@ -587,7 +587,7 @@ static int dynamic_load_field(struct estack_entry *stack_top) case OBJECT_TYPE_ARRAY: case OBJECT_TYPE_STRUCT: case OBJECT_TYPE_VARIANT: - printk(KERN_WARNING "LTTng: filter: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); + printk(KERN_WARNING "LTTng: bytecode: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); ret = -EINVAL; goto end; } @@ -662,7 +662,7 @@ again: return -EINVAL; } - return LTTNG_FILTER_RECORD_FLAG; + return LTTNG_INTERPRETER_RECORD_FLAG; } /* @@ -684,164 +684,164 @@ uint64_t bytecode_interpret(void *interpreter_data, struct estack *stack = &_stack; register int64_t ax = 0, bx = 0; register enum entry_type ax_t = REG_TYPE_UNKNOWN, bx_t = REG_TYPE_UNKNOWN; - register int top = FILTER_STACK_EMPTY; + register int top = INTERPRETER_STACK_EMPTY; #ifndef INTERPRETER_USE_SWITCH - static void *dispatch[NR_FILTER_OPS] = { - [ FILTER_OP_UNKNOWN ] = &&LABEL_FILTER_OP_UNKNOWN, + static void *dispatch[NR_BYTECODE_OPS] = { + [ BYTECODE_OP_UNKNOWN ] = &&LABEL_BYTECODE_OP_UNKNOWN, - [ FILTER_OP_RETURN ] = &&LABEL_FILTER_OP_RETURN, + [ BYTECODE_OP_RETURN ] = &&LABEL_BYTECODE_OP_RETURN, /* binary */ - [ FILTER_OP_MUL ] = &&LABEL_FILTER_OP_MUL, - [ FILTER_OP_DIV ] = &&LABEL_FILTER_OP_DIV, - [ FILTER_OP_MOD ] = &&LABEL_FILTER_OP_MOD, - [ FILTER_OP_PLUS ] = &&LABEL_FILTER_OP_PLUS, - [ FILTER_OP_MINUS ] = &&LABEL_FILTER_OP_MINUS, - [ FILTER_OP_BIT_RSHIFT ] = &&LABEL_FILTER_OP_BIT_RSHIFT, - [ FILTER_OP_BIT_LSHIFT ] = &&LABEL_FILTER_OP_BIT_LSHIFT, - [ FILTER_OP_BIT_AND ] = &&LABEL_FILTER_OP_BIT_AND, - [ FILTER_OP_BIT_OR ] = &&LABEL_FILTER_OP_BIT_OR, - [ FILTER_OP_BIT_XOR ] = &&LABEL_FILTER_OP_BIT_XOR, + [ BYTECODE_OP_MUL ] = &&LABEL_BYTECODE_OP_MUL, + [ BYTECODE_OP_DIV ] = &&LABEL_BYTECODE_OP_DIV, + [ BYTECODE_OP_MOD ] = &&LABEL_BYTECODE_OP_MOD, + [ BYTECODE_OP_PLUS ] = &&LABEL_BYTECODE_OP_PLUS, + [ BYTECODE_OP_MINUS ] = &&LABEL_BYTECODE_OP_MINUS, + [ BYTECODE_OP_BIT_RSHIFT ] = &&LABEL_BYTECODE_OP_BIT_RSHIFT, + [ BYTECODE_OP_BIT_LSHIFT ] = &&LABEL_BYTECODE_OP_BIT_LSHIFT, + [ BYTECODE_OP_BIT_AND ] = &&LABEL_BYTECODE_OP_BIT_AND, + [ BYTECODE_OP_BIT_OR ] = &&LABEL_BYTECODE_OP_BIT_OR, + [ BYTECODE_OP_BIT_XOR ] = &&LABEL_BYTECODE_OP_BIT_XOR, /* binary comparators */ - [ FILTER_OP_EQ ] = &&LABEL_FILTER_OP_EQ, - [ FILTER_OP_NE ] = &&LABEL_FILTER_OP_NE, - [ FILTER_OP_GT ] = &&LABEL_FILTER_OP_GT, - [ FILTER_OP_LT ] = &&LABEL_FILTER_OP_LT, - [ FILTER_OP_GE ] = &&LABEL_FILTER_OP_GE, - [ FILTER_OP_LE ] = &&LABEL_FILTER_OP_LE, + [ BYTECODE_OP_EQ ] = &&LABEL_BYTECODE_OP_EQ, + [ BYTECODE_OP_NE ] = &&LABEL_BYTECODE_OP_NE, + [ BYTECODE_OP_GT ] = &&LABEL_BYTECODE_OP_GT, + [ BYTECODE_OP_LT ] = &&LABEL_BYTECODE_OP_LT, + [ BYTECODE_OP_GE ] = &&LABEL_BYTECODE_OP_GE, + [ BYTECODE_OP_LE ] = &&LABEL_BYTECODE_OP_LE, /* string binary comparator */ - [ FILTER_OP_EQ_STRING ] = &&LABEL_FILTER_OP_EQ_STRING, - [ FILTER_OP_NE_STRING ] = &&LABEL_FILTER_OP_NE_STRING, - [ FILTER_OP_GT_STRING ] = &&LABEL_FILTER_OP_GT_STRING, - [ FILTER_OP_LT_STRING ] = &&LABEL_FILTER_OP_LT_STRING, - [ FILTER_OP_GE_STRING ] = &&LABEL_FILTER_OP_GE_STRING, - [ FILTER_OP_LE_STRING ] = &&LABEL_FILTER_OP_LE_STRING, + [ BYTECODE_OP_EQ_STRING ] = &&LABEL_BYTECODE_OP_EQ_STRING, + [ BYTECODE_OP_NE_STRING ] = &&LABEL_BYTECODE_OP_NE_STRING, + [ BYTECODE_OP_GT_STRING ] = &&LABEL_BYTECODE_OP_GT_STRING, + [ BYTECODE_OP_LT_STRING ] = &&LABEL_BYTECODE_OP_LT_STRING, + [ BYTECODE_OP_GE_STRING ] = &&LABEL_BYTECODE_OP_GE_STRING, + [ BYTECODE_OP_LE_STRING ] = &&LABEL_BYTECODE_OP_LE_STRING, /* globbing pattern binary comparator */ - [ FILTER_OP_EQ_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_EQ_STAR_GLOB_STRING, - [ FILTER_OP_NE_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_NE_STAR_GLOB_STRING, + [ BYTECODE_OP_EQ_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_EQ_STAR_GLOB_STRING, + [ BYTECODE_OP_NE_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_NE_STAR_GLOB_STRING, /* s64 binary comparator */ - [ FILTER_OP_EQ_S64 ] = &&LABEL_FILTER_OP_EQ_S64, - [ FILTER_OP_NE_S64 ] = &&LABEL_FILTER_OP_NE_S64, - [ FILTER_OP_GT_S64 ] = &&LABEL_FILTER_OP_GT_S64, - [ FILTER_OP_LT_S64 ] = &&LABEL_FILTER_OP_LT_S64, - [ FILTER_OP_GE_S64 ] = &&LABEL_FILTER_OP_GE_S64, - [ FILTER_OP_LE_S64 ] = &&LABEL_FILTER_OP_LE_S64, + [ BYTECODE_OP_EQ_S64 ] = &&LABEL_BYTECODE_OP_EQ_S64, + [ BYTECODE_OP_NE_S64 ] = &&LABEL_BYTECODE_OP_NE_S64, + [ BYTECODE_OP_GT_S64 ] = &&LABEL_BYTECODE_OP_GT_S64, + [ BYTECODE_OP_LT_S64 ] = &&LABEL_BYTECODE_OP_LT_S64, + [ BYTECODE_OP_GE_S64 ] = &&LABEL_BYTECODE_OP_GE_S64, + [ BYTECODE_OP_LE_S64 ] = &&LABEL_BYTECODE_OP_LE_S64, /* double binary comparator */ - [ FILTER_OP_EQ_DOUBLE ] = &&LABEL_FILTER_OP_EQ_DOUBLE, - [ FILTER_OP_NE_DOUBLE ] = &&LABEL_FILTER_OP_NE_DOUBLE, - [ FILTER_OP_GT_DOUBLE ] = &&LABEL_FILTER_OP_GT_DOUBLE, - [ FILTER_OP_LT_DOUBLE ] = &&LABEL_FILTER_OP_LT_DOUBLE, - [ FILTER_OP_GE_DOUBLE ] = &&LABEL_FILTER_OP_GE_DOUBLE, - [ FILTER_OP_LE_DOUBLE ] = &&LABEL_FILTER_OP_LE_DOUBLE, + [ BYTECODE_OP_EQ_DOUBLE ] = &&LABEL_BYTECODE_OP_EQ_DOUBLE, + [ BYTECODE_OP_NE_DOUBLE ] = &&LABEL_BYTECODE_OP_NE_DOUBLE, + [ BYTECODE_OP_GT_DOUBLE ] = &&LABEL_BYTECODE_OP_GT_DOUBLE, + [ BYTECODE_OP_LT_DOUBLE ] = &&LABEL_BYTECODE_OP_LT_DOUBLE, + [ BYTECODE_OP_GE_DOUBLE ] = &&LABEL_BYTECODE_OP_GE_DOUBLE, + [ BYTECODE_OP_LE_DOUBLE ] = &&LABEL_BYTECODE_OP_LE_DOUBLE, /* Mixed S64-double binary comparators */ - [ FILTER_OP_EQ_DOUBLE_S64 ] = &&LABEL_FILTER_OP_EQ_DOUBLE_S64, - [ FILTER_OP_NE_DOUBLE_S64 ] = &&LABEL_FILTER_OP_NE_DOUBLE_S64, - [ FILTER_OP_GT_DOUBLE_S64 ] = &&LABEL_FILTER_OP_GT_DOUBLE_S64, - [ FILTER_OP_LT_DOUBLE_S64 ] = &&LABEL_FILTER_OP_LT_DOUBLE_S64, - [ FILTER_OP_GE_DOUBLE_S64 ] = &&LABEL_FILTER_OP_GE_DOUBLE_S64, - [ FILTER_OP_LE_DOUBLE_S64 ] = &&LABEL_FILTER_OP_LE_DOUBLE_S64, - - [ FILTER_OP_EQ_S64_DOUBLE ] = &&LABEL_FILTER_OP_EQ_S64_DOUBLE, - [ FILTER_OP_NE_S64_DOUBLE ] = &&LABEL_FILTER_OP_NE_S64_DOUBLE, - [ FILTER_OP_GT_S64_DOUBLE ] = &&LABEL_FILTER_OP_GT_S64_DOUBLE, - [ FILTER_OP_LT_S64_DOUBLE ] = &&LABEL_FILTER_OP_LT_S64_DOUBLE, - [ FILTER_OP_GE_S64_DOUBLE ] = &&LABEL_FILTER_OP_GE_S64_DOUBLE, - [ FILTER_OP_LE_S64_DOUBLE ] = &&LABEL_FILTER_OP_LE_S64_DOUBLE, + [ BYTECODE_OP_EQ_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_EQ_DOUBLE_S64, + [ BYTECODE_OP_NE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_NE_DOUBLE_S64, + [ BYTECODE_OP_GT_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_GT_DOUBLE_S64, + [ BYTECODE_OP_LT_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_LT_DOUBLE_S64, + [ BYTECODE_OP_GE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_GE_DOUBLE_S64, + [ BYTECODE_OP_LE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_LE_DOUBLE_S64, + + [ BYTECODE_OP_EQ_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_EQ_S64_DOUBLE, + [ BYTECODE_OP_NE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_NE_S64_DOUBLE, + [ BYTECODE_OP_GT_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_GT_S64_DOUBLE, + [ BYTECODE_OP_LT_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_LT_S64_DOUBLE, + [ BYTECODE_OP_GE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_GE_S64_DOUBLE, + [ BYTECODE_OP_LE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_LE_S64_DOUBLE, /* unary */ - [ FILTER_OP_UNARY_PLUS ] = &&LABEL_FILTER_OP_UNARY_PLUS, - [ FILTER_OP_UNARY_MINUS ] = &&LABEL_FILTER_OP_UNARY_MINUS, - [ FILTER_OP_UNARY_NOT ] = &&LABEL_FILTER_OP_UNARY_NOT, - [ FILTER_OP_UNARY_PLUS_S64 ] = &&LABEL_FILTER_OP_UNARY_PLUS_S64, - [ FILTER_OP_UNARY_MINUS_S64 ] = &&LABEL_FILTER_OP_UNARY_MINUS_S64, - [ FILTER_OP_UNARY_NOT_S64 ] = &&LABEL_FILTER_OP_UNARY_NOT_S64, - [ FILTER_OP_UNARY_PLUS_DOUBLE ] = &&LABEL_FILTER_OP_UNARY_PLUS_DOUBLE, - [ FILTER_OP_UNARY_MINUS_DOUBLE ] = &&LABEL_FILTER_OP_UNARY_MINUS_DOUBLE, - [ FILTER_OP_UNARY_NOT_DOUBLE ] = &&LABEL_FILTER_OP_UNARY_NOT_DOUBLE, + [ BYTECODE_OP_UNARY_PLUS ] = &&LABEL_BYTECODE_OP_UNARY_PLUS, + [ BYTECODE_OP_UNARY_MINUS ] = &&LABEL_BYTECODE_OP_UNARY_MINUS, + [ BYTECODE_OP_UNARY_NOT ] = &&LABEL_BYTECODE_OP_UNARY_NOT, + [ BYTECODE_OP_UNARY_PLUS_S64 ] = &&LABEL_BYTECODE_OP_UNARY_PLUS_S64, + [ BYTECODE_OP_UNARY_MINUS_S64 ] = &&LABEL_BYTECODE_OP_UNARY_MINUS_S64, + [ BYTECODE_OP_UNARY_NOT_S64 ] = &&LABEL_BYTECODE_OP_UNARY_NOT_S64, + [ BYTECODE_OP_UNARY_PLUS_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_PLUS_DOUBLE, + [ BYTECODE_OP_UNARY_MINUS_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_MINUS_DOUBLE, + [ BYTECODE_OP_UNARY_NOT_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_NOT_DOUBLE, /* logical */ - [ FILTER_OP_AND ] = &&LABEL_FILTER_OP_AND, - [ FILTER_OP_OR ] = &&LABEL_FILTER_OP_OR, + [ BYTECODE_OP_AND ] = &&LABEL_BYTECODE_OP_AND, + [ BYTECODE_OP_OR ] = &&LABEL_BYTECODE_OP_OR, /* load field ref */ - [ FILTER_OP_LOAD_FIELD_REF ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF, - [ FILTER_OP_LOAD_FIELD_REF_STRING ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_STRING, - [ FILTER_OP_LOAD_FIELD_REF_SEQUENCE ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_SEQUENCE, - [ FILTER_OP_LOAD_FIELD_REF_S64 ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_S64, - [ FILTER_OP_LOAD_FIELD_REF_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_DOUBLE, + [ BYTECODE_OP_LOAD_FIELD_REF ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF, + [ BYTECODE_OP_LOAD_FIELD_REF_STRING ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_STRING, + [ BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE, + [ BYTECODE_OP_LOAD_FIELD_REF_S64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_S64, + [ BYTECODE_OP_LOAD_FIELD_REF_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_DOUBLE, /* load from immediate operand */ - [ FILTER_OP_LOAD_STRING ] = &&LABEL_FILTER_OP_LOAD_STRING, - [ FILTER_OP_LOAD_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_LOAD_STAR_GLOB_STRING, - [ FILTER_OP_LOAD_S64 ] = &&LABEL_FILTER_OP_LOAD_S64, - [ FILTER_OP_LOAD_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_DOUBLE, + [ BYTECODE_OP_LOAD_STRING ] = &&LABEL_BYTECODE_OP_LOAD_STRING, + [ BYTECODE_OP_LOAD_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_LOAD_STAR_GLOB_STRING, + [ BYTECODE_OP_LOAD_S64 ] = &&LABEL_BYTECODE_OP_LOAD_S64, + [ BYTECODE_OP_LOAD_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_DOUBLE, /* cast */ - [ FILTER_OP_CAST_TO_S64 ] = &&LABEL_FILTER_OP_CAST_TO_S64, - [ FILTER_OP_CAST_DOUBLE_TO_S64 ] = &&LABEL_FILTER_OP_CAST_DOUBLE_TO_S64, - [ FILTER_OP_CAST_NOP ] = &&LABEL_FILTER_OP_CAST_NOP, + [ BYTECODE_OP_CAST_TO_S64 ] = &&LABEL_BYTECODE_OP_CAST_TO_S64, + [ BYTECODE_OP_CAST_DOUBLE_TO_S64 ] = &&LABEL_BYTECODE_OP_CAST_DOUBLE_TO_S64, + [ BYTECODE_OP_CAST_NOP ] = &&LABEL_BYTECODE_OP_CAST_NOP, /* get context ref */ - [ FILTER_OP_GET_CONTEXT_REF ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF, - [ FILTER_OP_GET_CONTEXT_REF_STRING ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_STRING, - [ FILTER_OP_GET_CONTEXT_REF_S64 ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_S64, - [ FILTER_OP_GET_CONTEXT_REF_DOUBLE ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_DOUBLE, + [ BYTECODE_OP_GET_CONTEXT_REF ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF, + [ BYTECODE_OP_GET_CONTEXT_REF_STRING ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_STRING, + [ BYTECODE_OP_GET_CONTEXT_REF_S64 ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_S64, + [ BYTECODE_OP_GET_CONTEXT_REF_DOUBLE ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_DOUBLE, /* load userspace field ref */ - [ FILTER_OP_LOAD_FIELD_REF_USER_STRING ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_USER_STRING, - [ FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE, + [ BYTECODE_OP_LOAD_FIELD_REF_USER_STRING ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_USER_STRING, + [ BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE, /* Instructions for recursive traversal through composed types. */ - [ FILTER_OP_GET_CONTEXT_ROOT ] = &&LABEL_FILTER_OP_GET_CONTEXT_ROOT, - [ FILTER_OP_GET_APP_CONTEXT_ROOT ] = &&LABEL_FILTER_OP_GET_APP_CONTEXT_ROOT, - [ FILTER_OP_GET_PAYLOAD_ROOT ] = &&LABEL_FILTER_OP_GET_PAYLOAD_ROOT, - - [ FILTER_OP_GET_SYMBOL ] = &&LABEL_FILTER_OP_GET_SYMBOL, - [ FILTER_OP_GET_SYMBOL_FIELD ] = &&LABEL_FILTER_OP_GET_SYMBOL_FIELD, - [ FILTER_OP_GET_INDEX_U16 ] = &&LABEL_FILTER_OP_GET_INDEX_U16, - [ FILTER_OP_GET_INDEX_U64 ] = &&LABEL_FILTER_OP_GET_INDEX_U64, - - [ FILTER_OP_LOAD_FIELD ] = &&LABEL_FILTER_OP_LOAD_FIELD, - [ FILTER_OP_LOAD_FIELD_S8 ] = &&LABEL_FILTER_OP_LOAD_FIELD_S8, - [ FILTER_OP_LOAD_FIELD_S16 ] = &&LABEL_FILTER_OP_LOAD_FIELD_S16, - [ FILTER_OP_LOAD_FIELD_S32 ] = &&LABEL_FILTER_OP_LOAD_FIELD_S32, - [ FILTER_OP_LOAD_FIELD_S64 ] = &&LABEL_FILTER_OP_LOAD_FIELD_S64, - [ FILTER_OP_LOAD_FIELD_U8 ] = &&LABEL_FILTER_OP_LOAD_FIELD_U8, - [ FILTER_OP_LOAD_FIELD_U16 ] = &&LABEL_FILTER_OP_LOAD_FIELD_U16, - [ FILTER_OP_LOAD_FIELD_U32 ] = &&LABEL_FILTER_OP_LOAD_FIELD_U32, - [ FILTER_OP_LOAD_FIELD_U64 ] = &&LABEL_FILTER_OP_LOAD_FIELD_U64, - [ FILTER_OP_LOAD_FIELD_STRING ] = &&LABEL_FILTER_OP_LOAD_FIELD_STRING, - [ FILTER_OP_LOAD_FIELD_SEQUENCE ] = &&LABEL_FILTER_OP_LOAD_FIELD_SEQUENCE, - [ FILTER_OP_LOAD_FIELD_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_FIELD_DOUBLE, - - [ FILTER_OP_UNARY_BIT_NOT ] = &&LABEL_FILTER_OP_UNARY_BIT_NOT, - - [ FILTER_OP_RETURN_S64 ] = &&LABEL_FILTER_OP_RETURN_S64, + [ BYTECODE_OP_GET_CONTEXT_ROOT ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_ROOT, + [ BYTECODE_OP_GET_APP_CONTEXT_ROOT ] = &&LABEL_BYTECODE_OP_GET_APP_CONTEXT_ROOT, + [ BYTECODE_OP_GET_PAYLOAD_ROOT ] = &&LABEL_BYTECODE_OP_GET_PAYLOAD_ROOT, + + [ BYTECODE_OP_GET_SYMBOL ] = &&LABEL_BYTECODE_OP_GET_SYMBOL, + [ BYTECODE_OP_GET_SYMBOL_FIELD ] = &&LABEL_BYTECODE_OP_GET_SYMBOL_FIELD, + [ BYTECODE_OP_GET_INDEX_U16 ] = &&LABEL_BYTECODE_OP_GET_INDEX_U16, + [ BYTECODE_OP_GET_INDEX_U64 ] = &&LABEL_BYTECODE_OP_GET_INDEX_U64, + + [ BYTECODE_OP_LOAD_FIELD ] = &&LABEL_BYTECODE_OP_LOAD_FIELD, + [ BYTECODE_OP_LOAD_FIELD_S8 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S8, + [ BYTECODE_OP_LOAD_FIELD_S16 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S16, + [ BYTECODE_OP_LOAD_FIELD_S32 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S32, + [ BYTECODE_OP_LOAD_FIELD_S64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S64, + [ BYTECODE_OP_LOAD_FIELD_U8 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U8, + [ BYTECODE_OP_LOAD_FIELD_U16 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U16, + [ BYTECODE_OP_LOAD_FIELD_U32 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U32, + [ BYTECODE_OP_LOAD_FIELD_U64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U64, + [ BYTECODE_OP_LOAD_FIELD_STRING ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_STRING, + [ BYTECODE_OP_LOAD_FIELD_SEQUENCE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_SEQUENCE, + [ BYTECODE_OP_LOAD_FIELD_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_DOUBLE, + + [ BYTECODE_OP_UNARY_BIT_NOT ] = &&LABEL_BYTECODE_OP_UNARY_BIT_NOT, + + [ BYTECODE_OP_RETURN_S64 ] = &&LABEL_BYTECODE_OP_RETURN_S64, }; #endif /* #ifndef INTERPRETER_USE_SWITCH */ START_OP - OP(FILTER_OP_UNKNOWN): - OP(FILTER_OP_LOAD_FIELD_REF): - OP(FILTER_OP_GET_CONTEXT_REF): + OP(BYTECODE_OP_UNKNOWN): + OP(BYTECODE_OP_LOAD_FIELD_REF): + OP(BYTECODE_OP_GET_CONTEXT_REF): #ifdef INTERPRETER_USE_SWITCH default: #endif /* INTERPRETER_USE_SWITCH */ - printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - OP(FILTER_OP_RETURN): - OP(FILTER_OP_RETURN_S64): - /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */ + OP(BYTECODE_OP_RETURN): + OP(BYTECODE_OP_RETURN_S64): + /* LTTNG_INTERPRETER_DISCARD or LTTNG_INTERPRETER_RECORD_FLAG */ switch (estack_ax_t) { case REG_S64: case REG_U64: @@ -865,28 +865,28 @@ uint64_t bytecode_interpret(void *interpreter_data, goto end; /* binary */ - OP(FILTER_OP_MUL): - OP(FILTER_OP_DIV): - OP(FILTER_OP_MOD): - OP(FILTER_OP_PLUS): - OP(FILTER_OP_MINUS): - printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + OP(BYTECODE_OP_MUL): + OP(BYTECODE_OP_DIV): + OP(BYTECODE_OP_MOD): + OP(BYTECODE_OP_PLUS): + OP(BYTECODE_OP_MINUS): + printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - OP(FILTER_OP_EQ): - OP(FILTER_OP_NE): - OP(FILTER_OP_GT): - OP(FILTER_OP_LT): - OP(FILTER_OP_GE): - OP(FILTER_OP_LE): - printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + OP(BYTECODE_OP_EQ): + OP(BYTECODE_OP_NE): + OP(BYTECODE_OP_GT): + OP(BYTECODE_OP_LT): + OP(BYTECODE_OP_GE): + OP(BYTECODE_OP_LE): + printk(KERN_WARNING "LTTng: bytecode: unsupported non-specialized bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - OP(FILTER_OP_EQ_STRING): + OP(BYTECODE_OP_EQ_STRING): { int res; @@ -897,7 +897,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_NE_STRING): + OP(BYTECODE_OP_NE_STRING): { int res; @@ -908,7 +908,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_GT_STRING): + OP(BYTECODE_OP_GT_STRING): { int res; @@ -919,7 +919,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_LT_STRING): + OP(BYTECODE_OP_LT_STRING): { int res; @@ -930,7 +930,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_GE_STRING): + OP(BYTECODE_OP_GE_STRING): { int res; @@ -941,7 +941,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_LE_STRING): + OP(BYTECODE_OP_LE_STRING): { int res; @@ -953,7 +953,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_EQ_STAR_GLOB_STRING): + OP(BYTECODE_OP_EQ_STAR_GLOB_STRING): { int res; @@ -964,7 +964,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_NE_STAR_GLOB_STRING): + OP(BYTECODE_OP_NE_STAR_GLOB_STRING): { int res; @@ -976,7 +976,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_EQ_S64): + OP(BYTECODE_OP_EQ_S64): { int res; @@ -987,7 +987,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_NE_S64): + OP(BYTECODE_OP_NE_S64): { int res; @@ -998,7 +998,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_GT_S64): + OP(BYTECODE_OP_GT_S64): { int res; @@ -1009,7 +1009,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_LT_S64): + OP(BYTECODE_OP_LT_S64): { int res; @@ -1020,7 +1020,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_GE_S64): + OP(BYTECODE_OP_GE_S64): { int res; @@ -1031,7 +1031,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_LE_S64): + OP(BYTECODE_OP_LE_S64): { int res; @@ -1043,35 +1043,35 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_EQ_DOUBLE): - OP(FILTER_OP_NE_DOUBLE): - OP(FILTER_OP_GT_DOUBLE): - OP(FILTER_OP_LT_DOUBLE): - OP(FILTER_OP_GE_DOUBLE): - OP(FILTER_OP_LE_DOUBLE): + OP(BYTECODE_OP_EQ_DOUBLE): + OP(BYTECODE_OP_NE_DOUBLE): + OP(BYTECODE_OP_GT_DOUBLE): + OP(BYTECODE_OP_LT_DOUBLE): + OP(BYTECODE_OP_GE_DOUBLE): + OP(BYTECODE_OP_LE_DOUBLE): { BUG_ON(1); PO; } /* Mixed S64-double binary comparators */ - OP(FILTER_OP_EQ_DOUBLE_S64): - OP(FILTER_OP_NE_DOUBLE_S64): - OP(FILTER_OP_GT_DOUBLE_S64): - OP(FILTER_OP_LT_DOUBLE_S64): - OP(FILTER_OP_GE_DOUBLE_S64): - OP(FILTER_OP_LE_DOUBLE_S64): - OP(FILTER_OP_EQ_S64_DOUBLE): - OP(FILTER_OP_NE_S64_DOUBLE): - OP(FILTER_OP_GT_S64_DOUBLE): - OP(FILTER_OP_LT_S64_DOUBLE): - OP(FILTER_OP_GE_S64_DOUBLE): - OP(FILTER_OP_LE_S64_DOUBLE): + OP(BYTECODE_OP_EQ_DOUBLE_S64): + OP(BYTECODE_OP_NE_DOUBLE_S64): + OP(BYTECODE_OP_GT_DOUBLE_S64): + OP(BYTECODE_OP_LT_DOUBLE_S64): + OP(BYTECODE_OP_GE_DOUBLE_S64): + OP(BYTECODE_OP_LE_DOUBLE_S64): + OP(BYTECODE_OP_EQ_S64_DOUBLE): + OP(BYTECODE_OP_NE_S64_DOUBLE): + OP(BYTECODE_OP_GT_S64_DOUBLE): + OP(BYTECODE_OP_LT_S64_DOUBLE): + OP(BYTECODE_OP_GE_S64_DOUBLE): + OP(BYTECODE_OP_LE_S64_DOUBLE): { BUG_ON(1); PO; } - OP(FILTER_OP_BIT_RSHIFT): + OP(BYTECODE_OP_BIT_RSHIFT): { int64_t res; @@ -1092,7 +1092,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_BIT_LSHIFT): + OP(BYTECODE_OP_BIT_LSHIFT): { int64_t res; @@ -1113,7 +1113,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_BIT_AND): + OP(BYTECODE_OP_BIT_AND): { int64_t res; @@ -1129,7 +1129,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_BIT_OR): + OP(BYTECODE_OP_BIT_OR): { int64_t res; @@ -1145,7 +1145,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct binary_op); PO; } - OP(FILTER_OP_BIT_XOR): + OP(BYTECODE_OP_BIT_XOR): { int64_t res; @@ -1163,16 +1163,16 @@ uint64_t bytecode_interpret(void *interpreter_data, } /* unary */ - OP(FILTER_OP_UNARY_PLUS): - OP(FILTER_OP_UNARY_MINUS): - OP(FILTER_OP_UNARY_NOT): - printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + OP(BYTECODE_OP_UNARY_PLUS): + OP(BYTECODE_OP_UNARY_MINUS): + OP(BYTECODE_OP_UNARY_NOT): + printk(KERN_WARNING "LTTng: bytecode: unsupported non-specialized bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - OP(FILTER_OP_UNARY_BIT_NOT): + OP(BYTECODE_OP_UNARY_BIT_NOT): { estack_ax_v = ~(uint64_t) estack_ax_v; estack_ax_t = REG_S64; @@ -1180,39 +1180,39 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_UNARY_PLUS_S64): + OP(BYTECODE_OP_UNARY_PLUS_S64): { next_pc += sizeof(struct unary_op); PO; } - OP(FILTER_OP_UNARY_MINUS_S64): + OP(BYTECODE_OP_UNARY_MINUS_S64): { estack_ax_v = -estack_ax_v; estack_ax_t = REG_S64; next_pc += sizeof(struct unary_op); PO; } - OP(FILTER_OP_UNARY_PLUS_DOUBLE): - OP(FILTER_OP_UNARY_MINUS_DOUBLE): + OP(BYTECODE_OP_UNARY_PLUS_DOUBLE): + OP(BYTECODE_OP_UNARY_MINUS_DOUBLE): { BUG_ON(1); PO; } - OP(FILTER_OP_UNARY_NOT_S64): + OP(BYTECODE_OP_UNARY_NOT_S64): { estack_ax_v = !estack_ax_v; estack_ax_t = REG_S64; next_pc += sizeof(struct unary_op); PO; } - OP(FILTER_OP_UNARY_NOT_DOUBLE): + OP(BYTECODE_OP_UNARY_NOT_DOUBLE): { BUG_ON(1); PO; } /* logical */ - OP(FILTER_OP_AND): + OP(BYTECODE_OP_AND): { struct logical_op *insn = (struct logical_op *) pc; @@ -1228,7 +1228,7 @@ uint64_t bytecode_interpret(void *interpreter_data, } PO; } - OP(FILTER_OP_OR): + OP(BYTECODE_OP_OR): { struct logical_op *insn = (struct logical_op *) pc; @@ -1249,7 +1249,7 @@ uint64_t bytecode_interpret(void *interpreter_data, /* load field ref */ - OP(FILTER_OP_LOAD_FIELD_REF_STRING): + OP(BYTECODE_OP_LOAD_FIELD_REF_STRING): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1260,7 +1260,7 @@ uint64_t bytecode_interpret(void *interpreter_data, estack_ax(stack, top)->u.s.str = *(const char * const *) &interpreter_stack_data[ref->offset]; if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL string.\n"); + dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; goto end; } @@ -1274,7 +1274,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_REF_SEQUENCE): + OP(BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1288,7 +1288,7 @@ uint64_t bytecode_interpret(void *interpreter_data, *(const char **) (&interpreter_stack_data[ref->offset + sizeof(unsigned long)]); if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL sequence.\n"); + dbg_printk("Bytecode warning: loading a NULL sequence.\n"); ret = -EINVAL; goto end; } @@ -1299,7 +1299,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_REF_S64): + OP(BYTECODE_OP_LOAD_FIELD_REF_S64): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1316,14 +1316,14 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_REF_DOUBLE): + OP(BYTECODE_OP_LOAD_FIELD_REF_DOUBLE): { BUG_ON(1); PO; } /* load from immediate operand */ - OP(FILTER_OP_LOAD_STRING): + OP(BYTECODE_OP_LOAD_STRING): { struct load_op *insn = (struct load_op *) pc; @@ -1338,7 +1338,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_STAR_GLOB_STRING): + OP(BYTECODE_OP_LOAD_STAR_GLOB_STRING): { struct load_op *insn = (struct load_op *) pc; @@ -1353,7 +1353,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_S64): + OP(BYTECODE_OP_LOAD_S64): { struct load_op *insn = (struct load_op *) pc; @@ -1367,33 +1367,33 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_DOUBLE): + OP(BYTECODE_OP_LOAD_DOUBLE): { BUG_ON(1); PO; } /* cast */ - OP(FILTER_OP_CAST_TO_S64): - printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + OP(BYTECODE_OP_CAST_TO_S64): + printk(KERN_WARNING "LTTng: bytecode: unsupported non-specialized bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - OP(FILTER_OP_CAST_DOUBLE_TO_S64): + OP(BYTECODE_OP_CAST_DOUBLE_TO_S64): { BUG_ON(1); PO; } - OP(FILTER_OP_CAST_NOP): + OP(BYTECODE_OP_CAST_NOP): { next_pc += sizeof(struct cast_op); PO; } /* get context ref */ - OP(FILTER_OP_GET_CONTEXT_REF_STRING): + OP(BYTECODE_OP_GET_CONTEXT_REF_STRING): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1407,7 +1407,7 @@ uint64_t bytecode_interpret(void *interpreter_data, estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax(stack, top)->u.s.str = v.str; if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL string.\n"); + dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; goto end; } @@ -1421,7 +1421,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_CONTEXT_REF_S64): + OP(BYTECODE_OP_GET_CONTEXT_REF_S64): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1441,14 +1441,14 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_CONTEXT_REF_DOUBLE): + OP(BYTECODE_OP_GET_CONTEXT_REF_DOUBLE): { BUG_ON(1); PO; } /* load userspace field ref */ - OP(FILTER_OP_LOAD_FIELD_REF_USER_STRING): + OP(BYTECODE_OP_LOAD_FIELD_REF_USER_STRING): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1459,7 +1459,7 @@ uint64_t bytecode_interpret(void *interpreter_data, estack_ax(stack, top)->u.s.user_str = *(const char * const *) &interpreter_stack_data[ref->offset]; if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL string.\n"); + dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; goto end; } @@ -1473,7 +1473,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE): + OP(BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE): { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -1487,7 +1487,7 @@ uint64_t bytecode_interpret(void *interpreter_data, *(const char **) (&interpreter_stack_data[ref->offset + sizeof(unsigned long)]); if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL sequence.\n"); + dbg_printk("Bytecode warning: loading a NULL sequence.\n"); ret = -EINVAL; goto end; } @@ -1498,7 +1498,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_CONTEXT_ROOT): + OP(BYTECODE_OP_GET_CONTEXT_ROOT): { dbg_printk("op get context root\n"); estack_push(stack, top, ax, bx, ax_t, bx_t); @@ -1510,13 +1510,13 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_APP_CONTEXT_ROOT): + OP(BYTECODE_OP_GET_APP_CONTEXT_ROOT): { BUG_ON(1); PO; } - OP(FILTER_OP_GET_PAYLOAD_ROOT): + OP(BYTECODE_OP_GET_PAYLOAD_ROOT): { dbg_printk("op get app payload root\n"); estack_push(stack, top, ax, bx, ax_t, bx_t); @@ -1529,12 +1529,12 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_SYMBOL): + OP(BYTECODE_OP_GET_SYMBOL): { dbg_printk("op get symbol\n"); switch (estack_ax(stack, top)->u.ptr.type) { case LOAD_OBJECT: - printk(KERN_WARNING "LTTng: filter: Nested fields not implemented yet.\n"); + printk(KERN_WARNING "LTTng: bytecode: Nested fields not implemented yet.\n"); ret = -EINVAL; goto end; case LOAD_ROOT_CONTEXT: @@ -1551,7 +1551,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_SYMBOL_FIELD): + OP(BYTECODE_OP_GET_SYMBOL_FIELD): { /* * Used for first variant encountered in a @@ -1561,7 +1561,7 @@ uint64_t bytecode_interpret(void *interpreter_data, goto end; } - OP(FILTER_OP_GET_INDEX_U16): + OP(BYTECODE_OP_GET_INDEX_U16): { struct load_op *insn = (struct load_op *) pc; struct get_index_u16 *index = (struct get_index_u16 *) insn->data; @@ -1576,7 +1576,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_GET_INDEX_U64): + OP(BYTECODE_OP_GET_INDEX_U64): { struct load_op *insn = (struct load_op *) pc; struct get_index_u64 *index = (struct get_index_u64 *) insn->data; @@ -1591,7 +1591,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD): + OP(BYTECODE_OP_LOAD_FIELD): { dbg_printk("op load field\n"); ret = dynamic_load_field(estack_ax(stack, top)); @@ -1603,7 +1603,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_S8): + OP(BYTECODE_OP_LOAD_FIELD_S8): { dbg_printk("op load field s8\n"); @@ -1612,7 +1612,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_S16): + OP(BYTECODE_OP_LOAD_FIELD_S16): { dbg_printk("op load field s16\n"); @@ -1621,7 +1621,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_S32): + OP(BYTECODE_OP_LOAD_FIELD_S32): { dbg_printk("op load field s32\n"); @@ -1630,7 +1630,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_S64): + OP(BYTECODE_OP_LOAD_FIELD_S64): { dbg_printk("op load field s64\n"); @@ -1639,7 +1639,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_U8): + OP(BYTECODE_OP_LOAD_FIELD_U8): { dbg_printk("op load field u8\n"); @@ -1648,7 +1648,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_U16): + OP(BYTECODE_OP_LOAD_FIELD_U16): { dbg_printk("op load field u16\n"); @@ -1657,7 +1657,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_U32): + OP(BYTECODE_OP_LOAD_FIELD_U32): { dbg_printk("op load field u32\n"); @@ -1666,7 +1666,7 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_U64): + OP(BYTECODE_OP_LOAD_FIELD_U64): { dbg_printk("op load field u64\n"); @@ -1675,13 +1675,13 @@ uint64_t bytecode_interpret(void *interpreter_data, next_pc += sizeof(struct load_op); PO; } - OP(FILTER_OP_LOAD_FIELD_DOUBLE): + OP(BYTECODE_OP_LOAD_FIELD_DOUBLE): { ret = -EINVAL; goto end; } - OP(FILTER_OP_LOAD_FIELD_STRING): + OP(BYTECODE_OP_LOAD_FIELD_STRING): { const char *str; @@ -1689,7 +1689,7 @@ uint64_t bytecode_interpret(void *interpreter_data, str = (const char *) estack_ax(stack, top)->u.ptr.ptr; estack_ax(stack, top)->u.s.str = str; if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL string.\n"); + dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; goto end; } @@ -1701,7 +1701,7 @@ uint64_t bytecode_interpret(void *interpreter_data, PO; } - OP(FILTER_OP_LOAD_FIELD_SEQUENCE): + OP(BYTECODE_OP_LOAD_FIELD_SEQUENCE): { const char *ptr; @@ -1710,7 +1710,7 @@ uint64_t bytecode_interpret(void *interpreter_data, estack_ax(stack, top)->u.s.seq_len = *(unsigned long *) ptr; estack_ax(stack, top)->u.s.str = *(const char **) (ptr + sizeof(unsigned long)); if (unlikely(!estack_ax(stack, top)->u.s.str)) { - dbg_printk("Filter warning: loading a NULL sequence.\n"); + dbg_printk("Bytecode warning: loading a NULL sequence.\n"); ret = -EINVAL; goto end; } @@ -1725,7 +1725,7 @@ uint64_t bytecode_interpret(void *interpreter_data, end: /* Return _DISCARD on error. */ if (ret) - return LTTNG_FILTER_DISCARD; + return LTTNG_INTERPRETER_DISCARD; if (output) { return lttng_bytecode_interpret_format_output( @@ -1736,7 +1736,7 @@ end: } LTTNG_STACK_FRAME_NON_STANDARD(bytecode_interpret); -uint64_t lttng_filter_interpret_bytecode(void *filter_data, +uint64_t lttng_bytecode_filter_interpret(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, const char *filter_stack_data) { diff --git a/src/lttng-filter-specialize.c b/src/lttng-bytecode-specialize.c similarity index 72% rename from src/lttng-filter-specialize.c rename to src/lttng-bytecode-specialize.c index 32591d19..83ba6f55 100644 --- a/src/lttng-filter-specialize.c +++ b/src/lttng-bytecode-specialize.c @@ -1,14 +1,14 @@ /* SPDX-License-Identifier: MIT * - * lttng-filter-specialize.c + * lttng-bytecode-specialize.c * - * LTTng modules filter code specializer. + * LTTng modules bytecode code specializer. * * Copyright (C) 2010-2016 Mathieu Desnoyers */ #include -#include +#include #include static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime, @@ -20,7 +20,7 @@ static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime, size_t new_alloc_len = new_len; size_t old_alloc_len = runtime->data_alloc_len; - if (new_len > FILTER_MAX_DATA_LEN) + if (new_len > INTERPRETER_MAX_DATA_LEN) return -EINVAL; if (new_alloc_len > old_alloc_len) { @@ -66,7 +66,7 @@ static int specialize_load_field(struct vstack_entry *stack_top, case LOAD_ROOT_APP_CONTEXT: case LOAD_ROOT_PAYLOAD: default: - dbg_printk("Filter warning: cannot load root, missing field name.\n"); + dbg_printk("Bytecode warning: cannot load root, missing field name.\n"); ret = -EINVAL; goto end; } @@ -75,62 +75,62 @@ static int specialize_load_field(struct vstack_entry *stack_top, dbg_printk("op load field s8\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_S8; + insn->op = BYTECODE_OP_LOAD_FIELD_S8; break; case OBJECT_TYPE_S16: dbg_printk("op load field s16\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_S16; + insn->op = BYTECODE_OP_LOAD_FIELD_S16; break; case OBJECT_TYPE_S32: dbg_printk("op load field s32\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_S32; + insn->op = BYTECODE_OP_LOAD_FIELD_S32; break; case OBJECT_TYPE_S64: dbg_printk("op load field s64\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_S64; + insn->op = BYTECODE_OP_LOAD_FIELD_S64; break; case OBJECT_TYPE_U8: dbg_printk("op load field u8\n"); stack_top->type = REG_S64; - insn->op = FILTER_OP_LOAD_FIELD_U8; + insn->op = BYTECODE_OP_LOAD_FIELD_U8; break; case OBJECT_TYPE_U16: dbg_printk("op load field u16\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_U16; + insn->op = BYTECODE_OP_LOAD_FIELD_U16; break; case OBJECT_TYPE_U32: dbg_printk("op load field u32\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_U32; + insn->op = BYTECODE_OP_LOAD_FIELD_U32; break; case OBJECT_TYPE_U64: dbg_printk("op load field u64\n"); stack_top->type = REG_S64; if (!stack_top->load.rev_bo) - insn->op = FILTER_OP_LOAD_FIELD_U64; + insn->op = BYTECODE_OP_LOAD_FIELD_U64; break; case OBJECT_TYPE_DOUBLE: - printk(KERN_WARNING "LTTng: filter: Double type unsupported\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Double type unsupported\n\n"); ret = -EINVAL; goto end; case OBJECT_TYPE_STRING: dbg_printk("op load field string\n"); stack_top->type = REG_STRING; - insn->op = FILTER_OP_LOAD_FIELD_STRING; + insn->op = BYTECODE_OP_LOAD_FIELD_STRING; break; case OBJECT_TYPE_STRING_SEQUENCE: dbg_printk("op load field string sequence\n"); stack_top->type = REG_STRING; - insn->op = FILTER_OP_LOAD_FIELD_SEQUENCE; + insn->op = BYTECODE_OP_LOAD_FIELD_SEQUENCE; break; case OBJECT_TYPE_DYNAMIC: ret = -EINVAL; @@ -139,7 +139,7 @@ static int specialize_load_field(struct vstack_entry *stack_top, case OBJECT_TYPE_ARRAY: case OBJECT_TYPE_STRUCT: case OBJECT_TYPE_VARIANT: - printk(KERN_WARNING "LTTng: filter: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); + printk(KERN_WARNING "LTTng: bytecode: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); ret = -EINVAL; goto end; } @@ -189,7 +189,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime, int idx_len) { int ret; - struct filter_get_index_data gid; + struct bytecode_get_index_data gid; ssize_t data_offset; memset(&gid, 0, sizeof(gid)); @@ -260,7 +260,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime, /* Only generated by the specialize phase. */ case OBJECT_TYPE_VARIANT: /* Fall-through */ default: - printk(KERN_WARNING "LTTng: filter: Unexpected get index type %d", + printk(KERN_WARNING "LTTng: bytecode: Unexpected get index type %d", (int) stack_top->load.object_type); ret = -EINVAL; goto end; @@ -269,7 +269,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime, case LOAD_ROOT_CONTEXT: case LOAD_ROOT_APP_CONTEXT: case LOAD_ROOT_PAYLOAD: - printk(KERN_WARNING "LTTng: filter: Index lookup for root field not implemented yet.\n"); + printk(KERN_WARNING "LTTng: bytecode: Index lookup for root field not implemented yet.\n"); ret = -EINVAL; goto end; } @@ -336,7 +336,7 @@ static int specialize_load_object(const struct lttng_event_field *field, } case atype_array_nestable: if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { - printk(KERN_WARNING "LTTng: filter Array nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: bytecode: Array nesting only supports integer types.\n"); return -EINVAL; } if (is_context) { @@ -352,7 +352,7 @@ static int specialize_load_object(const struct lttng_event_field *field, break; case atype_sequence_nestable: if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { - printk(KERN_WARNING "LTTng: filter Sequence nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: bytecode: Sequence nesting only supports integer types.\n"); return -EINVAL; } if (is_context) { @@ -370,13 +370,13 @@ static int specialize_load_object(const struct lttng_event_field *field, load->object_type = OBJECT_TYPE_STRING; break; case atype_struct_nestable: - printk(KERN_WARNING "LTTng: filter: Structure type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n"); return -EINVAL; case atype_variant_nestable: - printk(KERN_WARNING "LTTng: filter: Variant type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: bytecode: Variant type cannot be loaded.\n"); return -EINVAL; default: - printk(KERN_WARNING "LTTng: filter: Unknown type: %d", (int) field->type.atype); + printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type.atype); return -EINVAL; } return 0; @@ -390,7 +390,7 @@ static int specialize_context_lookup(struct lttng_ctx *ctx, int idx, ret; struct lttng_ctx_field *ctx_field; struct lttng_event_field *field; - struct filter_get_index_data gid; + struct bytecode_get_index_data gid; ssize_t data_offset; idx = specialize_context_lookup_name(ctx, runtime, insn); @@ -403,7 +403,7 @@ static int specialize_context_lookup(struct lttng_ctx *ctx, if (ret) return ret; /* Specialize each get_symbol into a get_index. */ - insn->op = FILTER_OP_GET_INDEX_U16; + insn->op = BYTECODE_OP_GET_INDEX_U16; memset(&gid, 0, sizeof(gid)); gid.ctx_index = idx; gid.elem.type = load->object_type; @@ -430,7 +430,7 @@ static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, uint32_t field_offset = 0; const struct lttng_event_field *field; int ret; - struct filter_get_index_data gid; + struct bytecode_get_index_data gid; ssize_t data_offset; nr_fields = event_desc->nr_fields; @@ -474,7 +474,7 @@ static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, goto end; /* Specialize each get_symbol into a get_index. */ - insn->op = FILTER_OP_GET_INDEX_U16; + insn->op = BYTECODE_OP_GET_INDEX_U16; memset(&gid, 0, sizeof(gid)); gid.offset = field_offset; gid.elem.type = load->object_type; @@ -492,7 +492,7 @@ end: return ret; } -int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, +int lttng_bytecode_specialize(const struct lttng_event_desc *event_desc, struct bytecode_runtime *bytecode) { void *pc, *next_pc, *start_pc; @@ -506,60 +506,60 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, start_pc = &bytecode->code[0]; for (pc = next_pc = start_pc; pc - start_pc < bytecode->len; pc = next_pc) { - switch (*(filter_opcode_t *) pc) { - case FILTER_OP_UNKNOWN: + switch (*(bytecode_opcode_t *) pc) { + case BYTECODE_OP_UNKNOWN: default: - printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - case FILTER_OP_RETURN: - case FILTER_OP_RETURN_S64: + case BYTECODE_OP_RETURN: + case BYTECODE_OP_RETURN_S64: ret = 0; goto end; /* binary */ - case FILTER_OP_MUL: - case FILTER_OP_DIV: - case FILTER_OP_MOD: - case FILTER_OP_PLUS: - case FILTER_OP_MINUS: - printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + case BYTECODE_OP_MUL: + case BYTECODE_OP_DIV: + case BYTECODE_OP_MOD: + case BYTECODE_OP_PLUS: + case BYTECODE_OP_MINUS: + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; - case FILTER_OP_EQ: + case BYTECODE_OP_EQ: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING) - insn->op = FILTER_OP_EQ_STAR_GLOB_STRING; + insn->op = BYTECODE_OP_EQ_STAR_GLOB_STRING; else - insn->op = FILTER_OP_EQ_STRING; + insn->op = BYTECODE_OP_EQ_STRING; break; case REG_STAR_GLOB_STRING: - insn->op = FILTER_OP_EQ_STAR_GLOB_STRING; + insn->op = BYTECODE_OP_EQ_STAR_GLOB_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_EQ_S64; + insn->op = BYTECODE_OP_EQ_S64; else - insn->op = FILTER_OP_EQ_DOUBLE_S64; + insn->op = BYTECODE_OP_EQ_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_EQ_S64_DOUBLE; + insn->op = BYTECODE_OP_EQ_S64_DOUBLE; else - insn->op = FILTER_OP_EQ_DOUBLE; + insn->op = BYTECODE_OP_EQ_DOUBLE; break; } /* Pop 2, push 1 */ @@ -572,36 +572,36 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_NE: + case BYTECODE_OP_NE: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING) - insn->op = FILTER_OP_NE_STAR_GLOB_STRING; + insn->op = BYTECODE_OP_NE_STAR_GLOB_STRING; else - insn->op = FILTER_OP_NE_STRING; + insn->op = BYTECODE_OP_NE_STRING; break; case REG_STAR_GLOB_STRING: - insn->op = FILTER_OP_NE_STAR_GLOB_STRING; + insn->op = BYTECODE_OP_NE_STAR_GLOB_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_NE_S64; + insn->op = BYTECODE_OP_NE_S64; else - insn->op = FILTER_OP_NE_DOUBLE_S64; + insn->op = BYTECODE_OP_NE_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_NE_S64_DOUBLE; + insn->op = BYTECODE_OP_NE_S64_DOUBLE; else - insn->op = FILTER_OP_NE_DOUBLE; + insn->op = BYTECODE_OP_NE_DOUBLE; break; } /* Pop 2, push 1 */ @@ -614,34 +614,34 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_GT: + case BYTECODE_OP_GT: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: invalid register type for '>' binary operator\n"); + printk(KERN_WARNING "LTTng: bytecode: invalid register type for '>' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: - insn->op = FILTER_OP_GT_STRING; + insn->op = BYTECODE_OP_GT_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_GT_S64; + insn->op = BYTECODE_OP_GT_S64; else - insn->op = FILTER_OP_GT_DOUBLE_S64; + insn->op = BYTECODE_OP_GT_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_GT_S64_DOUBLE; + insn->op = BYTECODE_OP_GT_S64_DOUBLE; else - insn->op = FILTER_OP_GT_DOUBLE; + insn->op = BYTECODE_OP_GT_DOUBLE; break; } /* Pop 2, push 1 */ @@ -654,34 +654,34 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LT: + case BYTECODE_OP_LT: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: invalid register type for '<' binary operator\n"); + printk(KERN_WARNING "LTTng: bytecode: invalid register type for '<' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: - insn->op = FILTER_OP_LT_STRING; + insn->op = BYTECODE_OP_LT_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_LT_S64; + insn->op = BYTECODE_OP_LT_S64; else - insn->op = FILTER_OP_LT_DOUBLE_S64; + insn->op = BYTECODE_OP_LT_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_LT_S64_DOUBLE; + insn->op = BYTECODE_OP_LT_S64_DOUBLE; else - insn->op = FILTER_OP_LT_DOUBLE; + insn->op = BYTECODE_OP_LT_DOUBLE; break; } /* Pop 2, push 1 */ @@ -694,34 +694,34 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_GE: + case BYTECODE_OP_GE: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: invalid register type for '>=' binary operator\n"); + printk(KERN_WARNING "LTTng: bytecode: invalid register type for '>=' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: - insn->op = FILTER_OP_GE_STRING; + insn->op = BYTECODE_OP_GE_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_GE_S64; + insn->op = BYTECODE_OP_GE_S64; else - insn->op = FILTER_OP_GE_DOUBLE_S64; + insn->op = BYTECODE_OP_GE_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_GE_S64_DOUBLE; + insn->op = BYTECODE_OP_GE_S64_DOUBLE; else - insn->op = FILTER_OP_GE_DOUBLE; + insn->op = BYTECODE_OP_GE_DOUBLE; break; } /* Pop 2, push 1 */ @@ -733,34 +733,34 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct binary_op); break; } - case FILTER_OP_LE: + case BYTECODE_OP_LE: { struct binary_op *insn = (struct binary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: invalid register type for '<=' binary operator\n"); + printk(KERN_WARNING "LTTng: bytecode: invalid register type for '<=' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: - insn->op = FILTER_OP_LE_STRING; + insn->op = BYTECODE_OP_LE_STRING; break; case REG_S64: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_LE_S64; + insn->op = BYTECODE_OP_LE_S64; else - insn->op = FILTER_OP_LE_DOUBLE_S64; + insn->op = BYTECODE_OP_LE_DOUBLE_S64; break; case REG_DOUBLE: if (vstack_bx(stack)->type == REG_S64) - insn->op = FILTER_OP_LE_S64_DOUBLE; + insn->op = BYTECODE_OP_LE_S64_DOUBLE; else - insn->op = FILTER_OP_LE_DOUBLE; + insn->op = BYTECODE_OP_LE_DOUBLE; break; } vstack_ax(stack)->type = REG_S64; @@ -768,43 +768,43 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_EQ_STRING: - case FILTER_OP_NE_STRING: - case FILTER_OP_GT_STRING: - case FILTER_OP_LT_STRING: - case FILTER_OP_GE_STRING: - case FILTER_OP_LE_STRING: - case FILTER_OP_EQ_STAR_GLOB_STRING: - case FILTER_OP_NE_STAR_GLOB_STRING: - case FILTER_OP_EQ_S64: - case FILTER_OP_NE_S64: - case FILTER_OP_GT_S64: - case FILTER_OP_LT_S64: - case FILTER_OP_GE_S64: - case FILTER_OP_LE_S64: - case FILTER_OP_EQ_DOUBLE: - case FILTER_OP_NE_DOUBLE: - case FILTER_OP_GT_DOUBLE: - case FILTER_OP_LT_DOUBLE: - case FILTER_OP_GE_DOUBLE: - case FILTER_OP_LE_DOUBLE: - case FILTER_OP_EQ_DOUBLE_S64: - case FILTER_OP_NE_DOUBLE_S64: - case FILTER_OP_GT_DOUBLE_S64: - case FILTER_OP_LT_DOUBLE_S64: - case FILTER_OP_GE_DOUBLE_S64: - case FILTER_OP_LE_DOUBLE_S64: - case FILTER_OP_EQ_S64_DOUBLE: - case FILTER_OP_NE_S64_DOUBLE: - case FILTER_OP_GT_S64_DOUBLE: - case FILTER_OP_LT_S64_DOUBLE: - case FILTER_OP_GE_S64_DOUBLE: - case FILTER_OP_LE_S64_DOUBLE: - case FILTER_OP_BIT_RSHIFT: - case FILTER_OP_BIT_LSHIFT: - case FILTER_OP_BIT_AND: - case FILTER_OP_BIT_OR: - case FILTER_OP_BIT_XOR: + case BYTECODE_OP_EQ_STRING: + case BYTECODE_OP_NE_STRING: + case BYTECODE_OP_GT_STRING: + case BYTECODE_OP_LT_STRING: + case BYTECODE_OP_GE_STRING: + case BYTECODE_OP_LE_STRING: + case BYTECODE_OP_EQ_STAR_GLOB_STRING: + case BYTECODE_OP_NE_STAR_GLOB_STRING: + case BYTECODE_OP_EQ_S64: + case BYTECODE_OP_NE_S64: + case BYTECODE_OP_GT_S64: + case BYTECODE_OP_LT_S64: + case BYTECODE_OP_GE_S64: + case BYTECODE_OP_LE_S64: + case BYTECODE_OP_EQ_DOUBLE: + case BYTECODE_OP_NE_DOUBLE: + case BYTECODE_OP_GT_DOUBLE: + case BYTECODE_OP_LT_DOUBLE: + case BYTECODE_OP_GE_DOUBLE: + case BYTECODE_OP_LE_DOUBLE: + case BYTECODE_OP_EQ_DOUBLE_S64: + case BYTECODE_OP_NE_DOUBLE_S64: + case BYTECODE_OP_GT_DOUBLE_S64: + case BYTECODE_OP_LT_DOUBLE_S64: + case BYTECODE_OP_GE_DOUBLE_S64: + case BYTECODE_OP_LE_DOUBLE_S64: + case BYTECODE_OP_EQ_S64_DOUBLE: + case BYTECODE_OP_NE_S64_DOUBLE: + case BYTECODE_OP_GT_S64_DOUBLE: + case BYTECODE_OP_LT_S64_DOUBLE: + case BYTECODE_OP_GE_S64_DOUBLE: + case BYTECODE_OP_LE_S64_DOUBLE: + case BYTECODE_OP_BIT_RSHIFT: + case BYTECODE_OP_BIT_LSHIFT: + case BYTECODE_OP_BIT_AND: + case BYTECODE_OP_BIT_OR: + case BYTECODE_OP_BIT_XOR: { /* Pop 2, push 1 */ if (vstack_pop(stack)) { @@ -817,21 +817,21 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, } /* unary */ - case FILTER_OP_UNARY_PLUS: + case BYTECODE_OP_UNARY_PLUS: { struct unary_op *insn = (struct unary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_S64: - insn->op = FILTER_OP_UNARY_PLUS_S64; + insn->op = BYTECODE_OP_UNARY_PLUS_S64; break; case REG_DOUBLE: - insn->op = FILTER_OP_UNARY_PLUS_DOUBLE; + insn->op = BYTECODE_OP_UNARY_PLUS_DOUBLE; break; } /* Pop 1, push 1 */ @@ -839,21 +839,21 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_UNARY_MINUS: + case BYTECODE_OP_UNARY_MINUS: { struct unary_op *insn = (struct unary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_S64: - insn->op = FILTER_OP_UNARY_MINUS_S64; + insn->op = BYTECODE_OP_UNARY_MINUS_S64; break; case REG_DOUBLE: - insn->op = FILTER_OP_UNARY_MINUS_DOUBLE; + insn->op = BYTECODE_OP_UNARY_MINUS_DOUBLE; break; } /* Pop 1, push 1 */ @@ -861,21 +861,21 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_UNARY_NOT: + case BYTECODE_OP_UNARY_NOT: { struct unary_op *insn = (struct unary_op *) pc; switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_S64: - insn->op = FILTER_OP_UNARY_NOT_S64; + insn->op = BYTECODE_OP_UNARY_NOT_S64; break; case REG_DOUBLE: - insn->op = FILTER_OP_UNARY_NOT_DOUBLE; + insn->op = BYTECODE_OP_UNARY_NOT_DOUBLE; break; } /* Pop 1, push 1 */ @@ -883,19 +883,19 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_UNARY_BIT_NOT: + case BYTECODE_OP_UNARY_BIT_NOT: { /* Pop 1, push 1 */ next_pc += sizeof(struct unary_op); break; } - case FILTER_OP_UNARY_PLUS_S64: - case FILTER_OP_UNARY_MINUS_S64: - case FILTER_OP_UNARY_NOT_S64: - case FILTER_OP_UNARY_PLUS_DOUBLE: - case FILTER_OP_UNARY_MINUS_DOUBLE: - case FILTER_OP_UNARY_NOT_DOUBLE: + case BYTECODE_OP_UNARY_PLUS_S64: + case BYTECODE_OP_UNARY_MINUS_S64: + case BYTECODE_OP_UNARY_NOT_S64: + case BYTECODE_OP_UNARY_PLUS_DOUBLE: + case BYTECODE_OP_UNARY_MINUS_DOUBLE: + case BYTECODE_OP_UNARY_NOT_DOUBLE: { /* Pop 1, push 1 */ next_pc += sizeof(struct unary_op); @@ -903,8 +903,8 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, } /* logical */ - case FILTER_OP_AND: - case FILTER_OP_OR: + case BYTECODE_OP_AND: + case BYTECODE_OP_OR: { /* Continue to next instruction */ /* Pop 1 when jump not taken */ @@ -917,24 +917,24 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, } /* load field ref */ - case FILTER_OP_LOAD_FIELD_REF: + case BYTECODE_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n"); ret = -EINVAL; goto end; } /* get context ref */ - case FILTER_OP_GET_CONTEXT_REF: + case BYTECODE_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n"); ret = -EINVAL; goto end; } - case FILTER_OP_LOAD_FIELD_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: - case FILTER_OP_GET_CONTEXT_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE: + case BYTECODE_OP_GET_CONTEXT_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE: { if (vstack_push(stack)) { ret = -EINVAL; @@ -944,8 +944,8 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct load_op) + sizeof(struct field_ref); break; } - case FILTER_OP_LOAD_FIELD_REF_S64: - case FILTER_OP_GET_CONTEXT_REF_S64: + case BYTECODE_OP_LOAD_FIELD_REF_S64: + case BYTECODE_OP_GET_CONTEXT_REF_S64: { if (vstack_push(stack)) { ret = -EINVAL; @@ -955,8 +955,8 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct load_op) + sizeof(struct field_ref); break; } - case FILTER_OP_LOAD_FIELD_REF_DOUBLE: - case FILTER_OP_GET_CONTEXT_REF_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE: + case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE: { if (vstack_push(stack)) { ret = -EINVAL; @@ -968,7 +968,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, } /* load from immediate operand */ - case FILTER_OP_LOAD_STRING: + case BYTECODE_OP_LOAD_STRING: { struct load_op *insn = (struct load_op *) pc; @@ -981,7 +981,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_STAR_GLOB_STRING: + case BYTECODE_OP_LOAD_STAR_GLOB_STRING: { struct load_op *insn = (struct load_op *) pc; @@ -994,7 +994,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_S64: + case BYTECODE_OP_LOAD_S64: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1006,7 +1006,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_DOUBLE: + case BYTECODE_OP_LOAD_DOUBLE: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1019,26 +1019,26 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, } /* cast */ - case FILTER_OP_CAST_TO_S64: + case BYTECODE_OP_CAST_TO_S64: { struct cast_op *insn = (struct cast_op *) pc; switch (vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: Cast op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: bytecode: Cast op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: - insn->op = FILTER_OP_CAST_NOP; + insn->op = BYTECODE_OP_CAST_NOP; break; case REG_DOUBLE: - insn->op = FILTER_OP_CAST_DOUBLE_TO_S64; + insn->op = BYTECODE_OP_CAST_DOUBLE_TO_S64; break; } /* Pop 1, push 1 */ @@ -1046,14 +1046,14 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct cast_op); break; } - case FILTER_OP_CAST_DOUBLE_TO_S64: + case BYTECODE_OP_CAST_DOUBLE_TO_S64: { /* Pop 1, push 1 */ vstack_ax(stack)->type = REG_S64; next_pc += sizeof(struct cast_op); break; } - case FILTER_OP_CAST_NOP: + case BYTECODE_OP_CAST_NOP: { next_pc += sizeof(struct cast_op); break; @@ -1062,7 +1062,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, /* * Instructions for recursive traversal through composed types. */ - case FILTER_OP_GET_CONTEXT_ROOT: + case BYTECODE_OP_GET_CONTEXT_ROOT: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1073,7 +1073,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct load_op); break; } - case FILTER_OP_GET_APP_CONTEXT_ROOT: + case BYTECODE_OP_GET_APP_CONTEXT_ROOT: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1084,7 +1084,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, next_pc += sizeof(struct load_op); break; } - case FILTER_OP_GET_PAYLOAD_ROOT: + case BYTECODE_OP_GET_PAYLOAD_ROOT: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1096,7 +1096,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_FIELD: + case BYTECODE_OP_LOAD_FIELD: { struct load_op *insn = (struct load_op *) pc; @@ -1110,14 +1110,14 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_FIELD_S8: - case FILTER_OP_LOAD_FIELD_S16: - case FILTER_OP_LOAD_FIELD_S32: - case FILTER_OP_LOAD_FIELD_S64: - case FILTER_OP_LOAD_FIELD_U8: - case FILTER_OP_LOAD_FIELD_U16: - case FILTER_OP_LOAD_FIELD_U32: - case FILTER_OP_LOAD_FIELD_U64: + case BYTECODE_OP_LOAD_FIELD_S8: + case BYTECODE_OP_LOAD_FIELD_S16: + case BYTECODE_OP_LOAD_FIELD_S32: + case BYTECODE_OP_LOAD_FIELD_S64: + case BYTECODE_OP_LOAD_FIELD_U8: + case BYTECODE_OP_LOAD_FIELD_U16: + case BYTECODE_OP_LOAD_FIELD_U32: + case BYTECODE_OP_LOAD_FIELD_U64: { /* Pop 1, push 1 */ vstack_ax(stack)->type = REG_S64; @@ -1125,8 +1125,8 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_FIELD_STRING: - case FILTER_OP_LOAD_FIELD_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_STRING: + case BYTECODE_OP_LOAD_FIELD_SEQUENCE: { /* Pop 1, push 1 */ vstack_ax(stack)->type = REG_STRING; @@ -1134,7 +1134,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_LOAD_FIELD_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_DOUBLE: { /* Pop 1, push 1 */ vstack_ax(stack)->type = REG_DOUBLE; @@ -1142,14 +1142,14 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_GET_SYMBOL: + case BYTECODE_OP_GET_SYMBOL: { struct load_op *insn = (struct load_op *) pc; dbg_printk("op get symbol\n"); switch (vstack_ax(stack)->load.type) { case LOAD_OBJECT: - printk(KERN_WARNING "LTTng: filter: Nested fields not implemented yet.\n"); + printk(KERN_WARNING "LTTng: bytecode: Nested fields not implemented yet.\n"); ret = -EINVAL; goto end; case LOAD_ROOT_CONTEXT: @@ -1175,14 +1175,14 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_GET_SYMBOL_FIELD: + case BYTECODE_OP_GET_SYMBOL_FIELD: { /* Always generated by specialize phase. */ ret = -EINVAL; goto end; } - case FILTER_OP_GET_INDEX_U16: + case BYTECODE_OP_GET_INDEX_U16: { struct load_op *insn = (struct load_op *) pc; struct get_index_u16 *index = (struct get_index_u16 *) insn->data; @@ -1197,7 +1197,7 @@ int lttng_filter_specialize_bytecode(const struct lttng_event_desc *event_desc, break; } - case FILTER_OP_GET_INDEX_U64: + case BYTECODE_OP_GET_INDEX_U64: { struct load_op *insn = (struct load_op *) pc; struct get_index_u64 *index = (struct get_index_u64 *) insn->data; diff --git a/src/lttng-filter-validator.c b/src/lttng-bytecode-validator.c similarity index 60% rename from src/lttng-filter-validator.c rename to src/lttng-bytecode-validator.c index 3353be2b..1bee0d65 100644 --- a/src/lttng-filter-validator.c +++ b/src/lttng-bytecode-validator.c @@ -1,8 +1,8 @@ /* SPDX-License-Identifier: MIT * - * lttng-filter-validator.c + * lttng-bytecode-validator.c * - * LTTng modules filter bytecode validator. + * LTTng modules bytecode bytecode validator. * * Copyright (C) 2010-2016 Mathieu Desnoyers */ @@ -12,7 +12,7 @@ #include #include -#include +#include #define MERGE_POINT_TABLE_BITS 7 #define MERGE_POINT_TABLE_SIZE (1U << MERGE_POINT_TABLE_BITS) @@ -66,7 +66,7 @@ int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc, struct mp_node *lookup_node; int found = 0; - dbg_printk("Filter: adding merge point at offset %lu, hash %lu\n", + dbg_printk("Bytecode: adding merge point at offset %lu, hash %lu\n", target_pc, hash); mp_node = kzalloc(sizeof(struct mp_node), GFP_KERNEL); if (!mp_node) @@ -83,11 +83,11 @@ int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc, } if (found) { /* Key already present */ - dbg_printk("Filter: compare merge points for offset %lu, hash %lu\n", + dbg_printk("Bytecode: compare merge points for offset %lu, hash %lu\n", target_pc, hash); kfree(mp_node); if (merge_points_compare(stack, &lookup_node->stack)) { - printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n", + printk(KERN_WARNING "LTTng: bytecode: Merge points differ for offset %lu\n", target_pc); return -EINVAL; } @@ -101,7 +101,7 @@ int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc, * Binary comparators use top of stack and top of stack -1. */ static -int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode, +int bin_op_compare_check(struct vstack *stack, const bytecode_opcode_t opcode, const char *str) { if (unlikely(!vstack_ax(stack) || !vstack_bx(stack))) @@ -122,7 +122,7 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode, case REG_STRING: break; case REG_STAR_GLOB_STRING: - if (opcode != FILTER_OP_EQ && opcode != FILTER_OP_NE) { + if (opcode != BYTECODE_OP_EQ && opcode != BYTECODE_OP_NE) { goto error_mismatch; } break; @@ -139,7 +139,7 @@ int bin_op_compare_check(struct vstack *stack, const filter_opcode_t opcode, case REG_TYPE_UNKNOWN: goto unknown; case REG_STRING: - if (opcode != FILTER_OP_EQ && opcode != FILTER_OP_NE) { + if (opcode != BYTECODE_OP_EQ && opcode != BYTECODE_OP_NE) { goto error_mismatch; } break; @@ -185,15 +185,15 @@ unknown: return 1; error_empty: - printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: bytecode: empty stack for '%s' binary operator\n", str); return -EINVAL; error_mismatch: - printk(KERN_WARNING "LTTng: filter: type mismatch for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: bytecode: type mismatch for '%s' binary operator\n", str); return -EINVAL; error_type: - printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: bytecode: unknown type for '%s' binary operator\n", str); return -EINVAL; } @@ -203,7 +203,7 @@ error_type: * (unknown), negative error value on error. */ static -int bin_op_bitwise_check(struct vstack *stack, filter_opcode_t opcode, +int bin_op_bitwise_check(struct vstack *stack, bytecode_opcode_t opcode, const char *str) { if (unlikely(!vstack_ax(stack) || !vstack_bx(stack))) @@ -245,11 +245,11 @@ unknown: return 1; error_empty: - printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: bytecode: empty stack for '%s' binary operator\n", str); return -EINVAL; error_type: - printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: bytecode: unknown type for '%s' binary operator\n", str); return -EINVAL; } @@ -281,18 +281,18 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, { int ret = 0; - switch (*(filter_opcode_t *) pc) { - case FILTER_OP_UNKNOWN: + switch (*(bytecode_opcode_t *) pc) { + case BYTECODE_OP_UNKNOWN: default: { - printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; break; } - case FILTER_OP_RETURN: - case FILTER_OP_RETURN_S64: + case BYTECODE_OP_RETURN: + case BYTECODE_OP_RETURN_S64: { if (unlikely(pc + sizeof(struct return_op) > start_pc + bytecode->len)) { @@ -302,69 +302,69 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* binary */ - case FILTER_OP_MUL: - case FILTER_OP_DIV: - case FILTER_OP_MOD: - case FILTER_OP_PLUS: - case FILTER_OP_MINUS: - case FILTER_OP_EQ_DOUBLE: - case FILTER_OP_NE_DOUBLE: - case FILTER_OP_GT_DOUBLE: - case FILTER_OP_LT_DOUBLE: - case FILTER_OP_GE_DOUBLE: - case FILTER_OP_LE_DOUBLE: + case BYTECODE_OP_MUL: + case BYTECODE_OP_DIV: + case BYTECODE_OP_MOD: + case BYTECODE_OP_PLUS: + case BYTECODE_OP_MINUS: + case BYTECODE_OP_EQ_DOUBLE: + case BYTECODE_OP_NE_DOUBLE: + case BYTECODE_OP_GT_DOUBLE: + case BYTECODE_OP_LT_DOUBLE: + case BYTECODE_OP_GE_DOUBLE: + case BYTECODE_OP_LE_DOUBLE: /* Floating point */ - case FILTER_OP_EQ_DOUBLE_S64: - case FILTER_OP_NE_DOUBLE_S64: - case FILTER_OP_GT_DOUBLE_S64: - case FILTER_OP_LT_DOUBLE_S64: - case FILTER_OP_GE_DOUBLE_S64: - case FILTER_OP_LE_DOUBLE_S64: - case FILTER_OP_EQ_S64_DOUBLE: - case FILTER_OP_NE_S64_DOUBLE: - case FILTER_OP_GT_S64_DOUBLE: - case FILTER_OP_LT_S64_DOUBLE: - case FILTER_OP_GE_S64_DOUBLE: - case FILTER_OP_LE_S64_DOUBLE: - case FILTER_OP_LOAD_FIELD_REF_DOUBLE: - case FILTER_OP_GET_CONTEXT_REF_DOUBLE: - case FILTER_OP_LOAD_DOUBLE: - case FILTER_OP_CAST_DOUBLE_TO_S64: - case FILTER_OP_UNARY_PLUS_DOUBLE: - case FILTER_OP_UNARY_MINUS_DOUBLE: - case FILTER_OP_UNARY_NOT_DOUBLE: - { - printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + case BYTECODE_OP_EQ_DOUBLE_S64: + case BYTECODE_OP_NE_DOUBLE_S64: + case BYTECODE_OP_GT_DOUBLE_S64: + case BYTECODE_OP_LT_DOUBLE_S64: + case BYTECODE_OP_GE_DOUBLE_S64: + case BYTECODE_OP_LE_DOUBLE_S64: + case BYTECODE_OP_EQ_S64_DOUBLE: + case BYTECODE_OP_NE_S64_DOUBLE: + case BYTECODE_OP_GT_S64_DOUBLE: + case BYTECODE_OP_LT_S64_DOUBLE: + case BYTECODE_OP_GE_S64_DOUBLE: + case BYTECODE_OP_LE_S64_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE: + case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE: + case BYTECODE_OP_LOAD_DOUBLE: + case BYTECODE_OP_CAST_DOUBLE_TO_S64: + case BYTECODE_OP_UNARY_PLUS_DOUBLE: + case BYTECODE_OP_UNARY_MINUS_DOUBLE: + case BYTECODE_OP_UNARY_NOT_DOUBLE: + { + printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; break; } - case FILTER_OP_EQ: - case FILTER_OP_NE: - case FILTER_OP_GT: - case FILTER_OP_LT: - case FILTER_OP_GE: - case FILTER_OP_LE: - case FILTER_OP_EQ_STRING: - case FILTER_OP_NE_STRING: - case FILTER_OP_GT_STRING: - case FILTER_OP_LT_STRING: - case FILTER_OP_GE_STRING: - case FILTER_OP_LE_STRING: - case FILTER_OP_EQ_STAR_GLOB_STRING: - case FILTER_OP_NE_STAR_GLOB_STRING: - case FILTER_OP_EQ_S64: - case FILTER_OP_NE_S64: - case FILTER_OP_GT_S64: - case FILTER_OP_LT_S64: - case FILTER_OP_GE_S64: - case FILTER_OP_LE_S64: - case FILTER_OP_BIT_RSHIFT: - case FILTER_OP_BIT_LSHIFT: - case FILTER_OP_BIT_AND: - case FILTER_OP_BIT_OR: - case FILTER_OP_BIT_XOR: + case BYTECODE_OP_EQ: + case BYTECODE_OP_NE: + case BYTECODE_OP_GT: + case BYTECODE_OP_LT: + case BYTECODE_OP_GE: + case BYTECODE_OP_LE: + case BYTECODE_OP_EQ_STRING: + case BYTECODE_OP_NE_STRING: + case BYTECODE_OP_GT_STRING: + case BYTECODE_OP_LT_STRING: + case BYTECODE_OP_GE_STRING: + case BYTECODE_OP_LE_STRING: + case BYTECODE_OP_EQ_STAR_GLOB_STRING: + case BYTECODE_OP_NE_STAR_GLOB_STRING: + case BYTECODE_OP_EQ_S64: + case BYTECODE_OP_NE_S64: + case BYTECODE_OP_GT_S64: + case BYTECODE_OP_LT_S64: + case BYTECODE_OP_GE_S64: + case BYTECODE_OP_LE_S64: + case BYTECODE_OP_BIT_RSHIFT: + case BYTECODE_OP_BIT_LSHIFT: + case BYTECODE_OP_BIT_AND: + case BYTECODE_OP_BIT_OR: + case BYTECODE_OP_BIT_XOR: { if (unlikely(pc + sizeof(struct binary_op) > start_pc + bytecode->len)) { @@ -374,13 +374,13 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* unary */ - case FILTER_OP_UNARY_PLUS: - case FILTER_OP_UNARY_MINUS: - case FILTER_OP_UNARY_NOT: - case FILTER_OP_UNARY_PLUS_S64: - case FILTER_OP_UNARY_MINUS_S64: - case FILTER_OP_UNARY_NOT_S64: - case FILTER_OP_UNARY_BIT_NOT: + case BYTECODE_OP_UNARY_PLUS: + case BYTECODE_OP_UNARY_MINUS: + case BYTECODE_OP_UNARY_NOT: + case BYTECODE_OP_UNARY_PLUS_S64: + case BYTECODE_OP_UNARY_MINUS_S64: + case BYTECODE_OP_UNARY_NOT_S64: + case BYTECODE_OP_UNARY_BIT_NOT: { if (unlikely(pc + sizeof(struct unary_op) > start_pc + bytecode->len)) { @@ -390,8 +390,8 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* logical */ - case FILTER_OP_AND: - case FILTER_OP_OR: + case BYTECODE_OP_AND: + case BYTECODE_OP_OR: { if (unlikely(pc + sizeof(struct logical_op) > start_pc + bytecode->len)) { @@ -401,27 +401,27 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* load field ref */ - case FILTER_OP_LOAD_FIELD_REF: + case BYTECODE_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n"); ret = -EINVAL; break; } /* get context ref */ - case FILTER_OP_GET_CONTEXT_REF: + case BYTECODE_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n"); ret = -EINVAL; break; } - case FILTER_OP_LOAD_FIELD_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: - case FILTER_OP_LOAD_FIELD_REF_USER_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE: - case FILTER_OP_LOAD_FIELD_REF_S64: - case FILTER_OP_GET_CONTEXT_REF_STRING: - case FILTER_OP_GET_CONTEXT_REF_S64: + case BYTECODE_OP_LOAD_FIELD_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_S64: + case BYTECODE_OP_GET_CONTEXT_REF_STRING: + case BYTECODE_OP_GET_CONTEXT_REF_S64: { if (unlikely(pc + sizeof(struct load_op) + sizeof(struct field_ref) > start_pc + bytecode->len)) { @@ -431,8 +431,8 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* load from immediate operand */ - case FILTER_OP_LOAD_STRING: - case FILTER_OP_LOAD_STAR_GLOB_STRING: + case BYTECODE_OP_LOAD_STRING: + case BYTECODE_OP_LOAD_STAR_GLOB_STRING: { struct load_op *insn = (struct load_op *) pc; uint32_t str_len, maxlen; @@ -452,7 +452,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_S64: + case BYTECODE_OP_LOAD_S64: { if (unlikely(pc + sizeof(struct load_op) + sizeof(struct literal_numeric) > start_pc + bytecode->len)) { @@ -461,8 +461,8 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_CAST_TO_S64: - case FILTER_OP_CAST_NOP: + case BYTECODE_OP_CAST_TO_S64: + case BYTECODE_OP_CAST_NOP: { if (unlikely(pc + sizeof(struct cast_op) > start_pc + bytecode->len)) { @@ -474,28 +474,28 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, /* * Instructions for recursive traversal through composed types. */ - case FILTER_OP_GET_CONTEXT_ROOT: - case FILTER_OP_GET_APP_CONTEXT_ROOT: - case FILTER_OP_GET_PAYLOAD_ROOT: - case FILTER_OP_LOAD_FIELD: - case FILTER_OP_LOAD_FIELD_S8: - case FILTER_OP_LOAD_FIELD_S16: - case FILTER_OP_LOAD_FIELD_S32: - case FILTER_OP_LOAD_FIELD_S64: - case FILTER_OP_LOAD_FIELD_U8: - case FILTER_OP_LOAD_FIELD_U16: - case FILTER_OP_LOAD_FIELD_U32: - case FILTER_OP_LOAD_FIELD_U64: - case FILTER_OP_LOAD_FIELD_STRING: - case FILTER_OP_LOAD_FIELD_SEQUENCE: - case FILTER_OP_LOAD_FIELD_DOUBLE: + case BYTECODE_OP_GET_CONTEXT_ROOT: + case BYTECODE_OP_GET_APP_CONTEXT_ROOT: + case BYTECODE_OP_GET_PAYLOAD_ROOT: + case BYTECODE_OP_LOAD_FIELD: + case BYTECODE_OP_LOAD_FIELD_S8: + case BYTECODE_OP_LOAD_FIELD_S16: + case BYTECODE_OP_LOAD_FIELD_S32: + case BYTECODE_OP_LOAD_FIELD_S64: + case BYTECODE_OP_LOAD_FIELD_U8: + case BYTECODE_OP_LOAD_FIELD_U16: + case BYTECODE_OP_LOAD_FIELD_U32: + case BYTECODE_OP_LOAD_FIELD_U64: + case BYTECODE_OP_LOAD_FIELD_STRING: + case BYTECODE_OP_LOAD_FIELD_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_DOUBLE: if (unlikely(pc + sizeof(struct load_op) > start_pc + bytecode->len)) { ret = -ERANGE; } break; - case FILTER_OP_GET_SYMBOL: + case BYTECODE_OP_GET_SYMBOL: { struct load_op *insn = (struct load_op *) pc; struct get_symbol *sym = (struct get_symbol *) insn->data; @@ -509,19 +509,19 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_SYMBOL_FIELD: - printk(KERN_WARNING "LTTng: filter: Unexpected get symbol field\n"); + case BYTECODE_OP_GET_SYMBOL_FIELD: + printk(KERN_WARNING "LTTng: bytecode: Unexpected get symbol field\n"); ret = -EINVAL; break; - case FILTER_OP_GET_INDEX_U16: + case BYTECODE_OP_GET_INDEX_U16: if (unlikely(pc + sizeof(struct load_op) + sizeof(struct get_index_u16) > start_pc + bytecode->len)) { ret = -ERANGE; } break; - case FILTER_OP_GET_INDEX_U64: + case BYTECODE_OP_GET_INDEX_U64: if (unlikely(pc + sizeof(struct load_op) + sizeof(struct get_index_u64) > start_pc + bytecode->len)) { ret = -ERANGE; @@ -564,99 +564,99 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, char *pc) { int ret = 0; - const filter_opcode_t opcode = *(filter_opcode_t *) pc; + const bytecode_opcode_t opcode = *(bytecode_opcode_t *) pc; switch (opcode) { - case FILTER_OP_UNKNOWN: + case BYTECODE_OP_UNKNOWN: default: { - printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; } - case FILTER_OP_RETURN: - case FILTER_OP_RETURN_S64: + case BYTECODE_OP_RETURN: + case BYTECODE_OP_RETURN_S64: { goto end; } /* binary */ - case FILTER_OP_MUL: - case FILTER_OP_DIV: - case FILTER_OP_MOD: - case FILTER_OP_PLUS: - case FILTER_OP_MINUS: + case BYTECODE_OP_MUL: + case BYTECODE_OP_DIV: + case BYTECODE_OP_MOD: + case BYTECODE_OP_PLUS: + case BYTECODE_OP_MINUS: /* Floating point */ - case FILTER_OP_EQ_DOUBLE: - case FILTER_OP_NE_DOUBLE: - case FILTER_OP_GT_DOUBLE: - case FILTER_OP_LT_DOUBLE: - case FILTER_OP_GE_DOUBLE: - case FILTER_OP_LE_DOUBLE: - case FILTER_OP_EQ_DOUBLE_S64: - case FILTER_OP_NE_DOUBLE_S64: - case FILTER_OP_GT_DOUBLE_S64: - case FILTER_OP_LT_DOUBLE_S64: - case FILTER_OP_GE_DOUBLE_S64: - case FILTER_OP_LE_DOUBLE_S64: - case FILTER_OP_EQ_S64_DOUBLE: - case FILTER_OP_NE_S64_DOUBLE: - case FILTER_OP_GT_S64_DOUBLE: - case FILTER_OP_LT_S64_DOUBLE: - case FILTER_OP_GE_S64_DOUBLE: - case FILTER_OP_LE_S64_DOUBLE: - case FILTER_OP_UNARY_PLUS_DOUBLE: - case FILTER_OP_UNARY_MINUS_DOUBLE: - case FILTER_OP_UNARY_NOT_DOUBLE: - case FILTER_OP_LOAD_FIELD_REF_DOUBLE: - case FILTER_OP_LOAD_DOUBLE: - case FILTER_OP_CAST_DOUBLE_TO_S64: - case FILTER_OP_GET_CONTEXT_REF_DOUBLE: - { - printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + case BYTECODE_OP_EQ_DOUBLE: + case BYTECODE_OP_NE_DOUBLE: + case BYTECODE_OP_GT_DOUBLE: + case BYTECODE_OP_LT_DOUBLE: + case BYTECODE_OP_GE_DOUBLE: + case BYTECODE_OP_LE_DOUBLE: + case BYTECODE_OP_EQ_DOUBLE_S64: + case BYTECODE_OP_NE_DOUBLE_S64: + case BYTECODE_OP_GT_DOUBLE_S64: + case BYTECODE_OP_LT_DOUBLE_S64: + case BYTECODE_OP_GE_DOUBLE_S64: + case BYTECODE_OP_LE_DOUBLE_S64: + case BYTECODE_OP_EQ_S64_DOUBLE: + case BYTECODE_OP_NE_S64_DOUBLE: + case BYTECODE_OP_GT_S64_DOUBLE: + case BYTECODE_OP_LT_S64_DOUBLE: + case BYTECODE_OP_GE_S64_DOUBLE: + case BYTECODE_OP_LE_S64_DOUBLE: + case BYTECODE_OP_UNARY_PLUS_DOUBLE: + case BYTECODE_OP_UNARY_MINUS_DOUBLE: + case BYTECODE_OP_UNARY_NOT_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE: + case BYTECODE_OP_LOAD_DOUBLE: + case BYTECODE_OP_CAST_DOUBLE_TO_S64: + case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE: + { + printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; } - case FILTER_OP_EQ: + case BYTECODE_OP_EQ: { ret = bin_op_compare_check(stack, opcode, "=="); if (ret < 0) goto end; break; } - case FILTER_OP_NE: + case BYTECODE_OP_NE: { ret = bin_op_compare_check(stack, opcode, "!="); if (ret < 0) goto end; break; } - case FILTER_OP_GT: + case BYTECODE_OP_GT: { ret = bin_op_compare_check(stack, opcode, ">"); if (ret < 0) goto end; break; } - case FILTER_OP_LT: + case BYTECODE_OP_LT: { ret = bin_op_compare_check(stack, opcode, "<"); if (ret < 0) goto end; break; } - case FILTER_OP_GE: + case BYTECODE_OP_GE: { ret = bin_op_compare_check(stack, opcode, ">="); if (ret < 0) goto end; break; } - case FILTER_OP_LE: + case BYTECODE_OP_LE: { ret = bin_op_compare_check(stack, opcode, "<="); if (ret < 0) @@ -664,21 +664,21 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_EQ_STRING: - case FILTER_OP_NE_STRING: - case FILTER_OP_GT_STRING: - case FILTER_OP_LT_STRING: - case FILTER_OP_GE_STRING: - case FILTER_OP_LE_STRING: + case BYTECODE_OP_EQ_STRING: + case BYTECODE_OP_NE_STRING: + case BYTECODE_OP_GT_STRING: + case BYTECODE_OP_LT_STRING: + case BYTECODE_OP_GE_STRING: + case BYTECODE_OP_LE_STRING: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_STRING || vstack_bx(stack)->type != REG_STRING) { - printk(KERN_WARNING "LTTng: filter: Unexpected register type for string comparator\n"); + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for string comparator\n"); ret = -EINVAL; goto end; } @@ -686,32 +686,32 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } - case FILTER_OP_EQ_STAR_GLOB_STRING: - case FILTER_OP_NE_STAR_GLOB_STRING: + case BYTECODE_OP_EQ_STAR_GLOB_STRING: + case BYTECODE_OP_NE_STAR_GLOB_STRING: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_STAR_GLOB_STRING && vstack_bx(stack)->type != REG_STAR_GLOB_STRING) { - printk(KERN_WARNING "LTTng: filter: Unexpected register type for globbing pattern comparator\n"); + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for globbing pattern comparator\n"); ret = -EINVAL; goto end; } break; } - case FILTER_OP_EQ_S64: - case FILTER_OP_NE_S64: - case FILTER_OP_GT_S64: - case FILTER_OP_LT_S64: - case FILTER_OP_GE_S64: - case FILTER_OP_LE_S64: + case BYTECODE_OP_EQ_S64: + case BYTECODE_OP_NE_S64: + case BYTECODE_OP_GT_S64: + case BYTECODE_OP_LT_S64: + case BYTECODE_OP_GE_S64: + case BYTECODE_OP_LE_S64: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -720,7 +720,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case REG_U64: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type for s64 comparator\n"); + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for s64 comparator\n"); ret = -EINVAL; goto end; } @@ -729,59 +729,59 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case REG_U64: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type for s64 comparator\n"); + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type for s64 comparator\n"); ret = -EINVAL; goto end; } break; } - case FILTER_OP_BIT_RSHIFT: + case BYTECODE_OP_BIT_RSHIFT: ret = bin_op_bitwise_check(stack, opcode, ">>"); if (ret < 0) goto end; break; - case FILTER_OP_BIT_LSHIFT: + case BYTECODE_OP_BIT_LSHIFT: ret = bin_op_bitwise_check(stack, opcode, "<<"); if (ret < 0) goto end; break; - case FILTER_OP_BIT_AND: + case BYTECODE_OP_BIT_AND: ret = bin_op_bitwise_check(stack, opcode, "&"); if (ret < 0) goto end; break; - case FILTER_OP_BIT_OR: + case BYTECODE_OP_BIT_OR: ret = bin_op_bitwise_check(stack, opcode, "|"); if (ret < 0) goto end; break; - case FILTER_OP_BIT_XOR: + case BYTECODE_OP_BIT_XOR: ret = bin_op_bitwise_check(stack, opcode, "^"); if (ret < 0) goto end; break; /* unary */ - case FILTER_OP_UNARY_PLUS: - case FILTER_OP_UNARY_MINUS: - case FILTER_OP_UNARY_NOT: + case BYTECODE_OP_UNARY_PLUS: + case BYTECODE_OP_UNARY_MINUS: + case BYTECODE_OP_UNARY_NOT: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: case REG_DOUBLE: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: Unary op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: bytecode: Unary op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -791,23 +791,23 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } break; } - case FILTER_OP_UNARY_BIT_NOT: + case BYTECODE_OP_UNARY_BIT_NOT: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: case REG_DOUBLE: - printk(KERN_WARNING "LTTng: filter: Unary bitwise op can only be applied to numeric registers\n"); + printk(KERN_WARNING "LTTng: bytecode: Unary bitwise op can only be applied to numeric registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -818,18 +818,18 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_UNARY_PLUS_S64: - case FILTER_OP_UNARY_MINUS_S64: - case FILTER_OP_UNARY_NOT_S64: + case BYTECODE_OP_UNARY_PLUS_S64: + case BYTECODE_OP_UNARY_MINUS_S64: + case BYTECODE_OP_UNARY_NOT_S64: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_S64 && vstack_ax(stack)->type != REG_U64) { - printk(KERN_WARNING "LTTng: filter: Invalid register type\n"); + printk(KERN_WARNING "LTTng: bytecode: Invalid register type\n"); ret = -EINVAL; goto end; } @@ -837,19 +837,19 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } /* logical */ - case FILTER_OP_AND: - case FILTER_OP_OR: + case BYTECODE_OP_AND: + case BYTECODE_OP_OR: { struct logical_op *insn = (struct logical_op *) pc; if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_S64 && vstack_ax(stack)->type != REG_U64) { - printk(KERN_WARNING "LTTng: filter: Logical comparator expects S64 register\n"); + printk(KERN_WARNING "LTTng: bytecode: Logical comparator expects S64 register\n"); ret = -EINVAL; goto end; } @@ -857,7 +857,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, dbg_printk("Validate jumping to bytecode offset %u\n", (unsigned int) insn->skip_offset); if (unlikely(start_pc + insn->skip_offset <= pc)) { - printk(KERN_WARNING "LTTng: filter: Loops are not allowed in bytecode\n"); + printk(KERN_WARNING "LTTng: bytecode: Loops are not allowed in bytecode\n"); ret = -EINVAL; goto end; } @@ -865,16 +865,16 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } /* load field ref */ - case FILTER_OP_LOAD_FIELD_REF: + case BYTECODE_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n"); ret = -EINVAL; goto end; } - case FILTER_OP_LOAD_FIELD_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: - case FILTER_OP_LOAD_FIELD_REF_USER_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE: { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -883,7 +883,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, ref->offset); break; } - case FILTER_OP_LOAD_FIELD_REF_S64: + case BYTECODE_OP_LOAD_FIELD_REF_S64: { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -894,63 +894,63 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } /* load from immediate operand */ - case FILTER_OP_LOAD_STRING: - case FILTER_OP_LOAD_STAR_GLOB_STRING: + case BYTECODE_OP_LOAD_STRING: + case BYTECODE_OP_LOAD_STAR_GLOB_STRING: { break; } - case FILTER_OP_LOAD_S64: + case BYTECODE_OP_LOAD_S64: { break; } - case FILTER_OP_CAST_TO_S64: + case BYTECODE_OP_CAST_TO_S64: { struct cast_op *insn = (struct cast_op *) pc; if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: case REG_DOUBLE: - printk(KERN_WARNING "LTTng: filter: unknown register type\n"); + printk(KERN_WARNING "LTTng: bytecode: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "LTTng: filter: Cast op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: bytecode: Cast op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: break; } - if (insn->op == FILTER_OP_CAST_DOUBLE_TO_S64) { + if (insn->op == BYTECODE_OP_CAST_DOUBLE_TO_S64) { if (vstack_ax(stack)->type != REG_DOUBLE) { - printk(KERN_WARNING "LTTng: filter: Cast expects double\n"); + printk(KERN_WARNING "LTTng: bytecode: Cast expects double\n"); ret = -EINVAL; goto end; } } break; } - case FILTER_OP_CAST_NOP: + case BYTECODE_OP_CAST_NOP: { break; } /* get context ref */ - case FILTER_OP_GET_CONTEXT_REF: + case BYTECODE_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n"); ret = -EINVAL; goto end; } - case FILTER_OP_GET_CONTEXT_REF_STRING: + case BYTECODE_OP_GET_CONTEXT_REF_STRING: { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -959,7 +959,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, ref->offset); break; } - case FILTER_OP_GET_CONTEXT_REF_S64: + case BYTECODE_OP_GET_CONTEXT_REF_S64: { struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; @@ -972,22 +972,22 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, /* * Instructions for recursive traversal through composed types. */ - case FILTER_OP_GET_CONTEXT_ROOT: + case BYTECODE_OP_GET_CONTEXT_ROOT: { dbg_printk("Validate get context root\n"); break; } - case FILTER_OP_GET_APP_CONTEXT_ROOT: + case BYTECODE_OP_GET_APP_CONTEXT_ROOT: { dbg_printk("Validate get app context root\n"); break; } - case FILTER_OP_GET_PAYLOAD_ROOT: + case BYTECODE_OP_GET_PAYLOAD_ROOT: { dbg_printk("Validate get payload root\n"); break; } - case FILTER_OP_LOAD_FIELD: + case BYTECODE_OP_LOAD_FIELD: { /* * We tolerate that field type is unknown at validation, @@ -997,63 +997,63 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, dbg_printk("Validate load field\n"); break; } - case FILTER_OP_LOAD_FIELD_S8: + case BYTECODE_OP_LOAD_FIELD_S8: { dbg_printk("Validate load field s8\n"); break; } - case FILTER_OP_LOAD_FIELD_S16: + case BYTECODE_OP_LOAD_FIELD_S16: { dbg_printk("Validate load field s16\n"); break; } - case FILTER_OP_LOAD_FIELD_S32: + case BYTECODE_OP_LOAD_FIELD_S32: { dbg_printk("Validate load field s32\n"); break; } - case FILTER_OP_LOAD_FIELD_S64: + case BYTECODE_OP_LOAD_FIELD_S64: { dbg_printk("Validate load field s64\n"); break; } - case FILTER_OP_LOAD_FIELD_U8: + case BYTECODE_OP_LOAD_FIELD_U8: { dbg_printk("Validate load field u8\n"); break; } - case FILTER_OP_LOAD_FIELD_U16: + case BYTECODE_OP_LOAD_FIELD_U16: { dbg_printk("Validate load field u16\n"); break; } - case FILTER_OP_LOAD_FIELD_U32: + case BYTECODE_OP_LOAD_FIELD_U32: { dbg_printk("Validate load field u32\n"); break; } - case FILTER_OP_LOAD_FIELD_U64: + case BYTECODE_OP_LOAD_FIELD_U64: { dbg_printk("Validate load field u64\n"); break; } - case FILTER_OP_LOAD_FIELD_STRING: + case BYTECODE_OP_LOAD_FIELD_STRING: { dbg_printk("Validate load field string\n"); break; } - case FILTER_OP_LOAD_FIELD_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_SEQUENCE: { dbg_printk("Validate load field sequence\n"); break; } - case FILTER_OP_LOAD_FIELD_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_DOUBLE: { dbg_printk("Validate load field double\n"); break; } - case FILTER_OP_GET_SYMBOL: + case BYTECODE_OP_GET_SYMBOL: { struct load_op *insn = (struct load_op *) pc; struct get_symbol *sym = (struct get_symbol *) insn->data; @@ -1062,7 +1062,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_SYMBOL_FIELD: + case BYTECODE_OP_GET_SYMBOL_FIELD: { struct load_op *insn = (struct load_op *) pc; struct get_symbol *sym = (struct get_symbol *) insn->data; @@ -1071,7 +1071,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_INDEX_U16: + case BYTECODE_OP_GET_INDEX_U16: { struct load_op *insn = (struct load_op *) pc; struct get_index_u16 *get_index = (struct get_index_u16 *) insn->data; @@ -1080,7 +1080,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_INDEX_U64: + case BYTECODE_OP_GET_INDEX_U64: { struct load_op *insn = (struct load_op *) pc; struct get_index_u64 *get_index = (struct get_index_u64 *) insn->data; @@ -1127,15 +1127,15 @@ int validate_instruction_all_contexts(struct bytecode_runtime *bytecode, } } if (found) { - dbg_printk("Filter: validate merge point at offset %lu\n", + dbg_printk("Bytecode: validate merge point at offset %lu\n", target_pc); if (merge_points_compare(stack, &mp_node->stack)) { - printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n", + printk(KERN_WARNING "LTTng: bytecode: Merge points differ for offset %lu\n", target_pc); return -EINVAL; } /* Once validated, we can remove the merge point */ - dbg_printk("Filter: remove merge point at offset %lu\n", + dbg_printk("Bytecode: remove merge point at offset %lu\n", target_pc); hlist_del(&mp_node->node); } @@ -1158,20 +1158,20 @@ int exec_insn(struct bytecode_runtime *bytecode, int ret = 1; char *next_pc = *_next_pc; - switch (*(filter_opcode_t *) pc) { - case FILTER_OP_UNKNOWN: + switch (*(bytecode_opcode_t *) pc) { + case BYTECODE_OP_UNKNOWN: default: { - printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; } - case FILTER_OP_RETURN: + case BYTECODE_OP_RETURN: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1184,7 +1184,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d at end of bytecode\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1194,10 +1194,10 @@ int exec_insn(struct bytecode_runtime *bytecode, goto end; } - case FILTER_OP_RETURN_S64: + case BYTECODE_OP_RETURN_S64: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1207,7 +1207,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; default: case REG_TYPE_UNKNOWN: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d at end of bytecode\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1218,64 +1218,64 @@ int exec_insn(struct bytecode_runtime *bytecode, } /* binary */ - case FILTER_OP_MUL: - case FILTER_OP_DIV: - case FILTER_OP_MOD: - case FILTER_OP_PLUS: - case FILTER_OP_MINUS: + case BYTECODE_OP_MUL: + case BYTECODE_OP_DIV: + case BYTECODE_OP_MOD: + case BYTECODE_OP_PLUS: + case BYTECODE_OP_MINUS: /* Floating point */ - case FILTER_OP_EQ_DOUBLE: - case FILTER_OP_NE_DOUBLE: - case FILTER_OP_GT_DOUBLE: - case FILTER_OP_LT_DOUBLE: - case FILTER_OP_GE_DOUBLE: - case FILTER_OP_LE_DOUBLE: - case FILTER_OP_EQ_DOUBLE_S64: - case FILTER_OP_NE_DOUBLE_S64: - case FILTER_OP_GT_DOUBLE_S64: - case FILTER_OP_LT_DOUBLE_S64: - case FILTER_OP_GE_DOUBLE_S64: - case FILTER_OP_LE_DOUBLE_S64: - case FILTER_OP_EQ_S64_DOUBLE: - case FILTER_OP_NE_S64_DOUBLE: - case FILTER_OP_GT_S64_DOUBLE: - case FILTER_OP_LT_S64_DOUBLE: - case FILTER_OP_GE_S64_DOUBLE: - case FILTER_OP_LE_S64_DOUBLE: - case FILTER_OP_UNARY_PLUS_DOUBLE: - case FILTER_OP_UNARY_MINUS_DOUBLE: - case FILTER_OP_UNARY_NOT_DOUBLE: - case FILTER_OP_LOAD_FIELD_REF_DOUBLE: - case FILTER_OP_GET_CONTEXT_REF_DOUBLE: - case FILTER_OP_LOAD_DOUBLE: - case FILTER_OP_CAST_DOUBLE_TO_S64: - { - printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + case BYTECODE_OP_EQ_DOUBLE: + case BYTECODE_OP_NE_DOUBLE: + case BYTECODE_OP_GT_DOUBLE: + case BYTECODE_OP_LT_DOUBLE: + case BYTECODE_OP_GE_DOUBLE: + case BYTECODE_OP_LE_DOUBLE: + case BYTECODE_OP_EQ_DOUBLE_S64: + case BYTECODE_OP_NE_DOUBLE_S64: + case BYTECODE_OP_GT_DOUBLE_S64: + case BYTECODE_OP_LT_DOUBLE_S64: + case BYTECODE_OP_GE_DOUBLE_S64: + case BYTECODE_OP_LE_DOUBLE_S64: + case BYTECODE_OP_EQ_S64_DOUBLE: + case BYTECODE_OP_NE_S64_DOUBLE: + case BYTECODE_OP_GT_S64_DOUBLE: + case BYTECODE_OP_LT_S64_DOUBLE: + case BYTECODE_OP_GE_S64_DOUBLE: + case BYTECODE_OP_LE_S64_DOUBLE: + case BYTECODE_OP_UNARY_PLUS_DOUBLE: + case BYTECODE_OP_UNARY_MINUS_DOUBLE: + case BYTECODE_OP_UNARY_NOT_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE: + case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE: + case BYTECODE_OP_LOAD_DOUBLE: + case BYTECODE_OP_CAST_DOUBLE_TO_S64: + { + printk(KERN_WARNING "LTTng: bytecode: unsupported bytecode op %u\n", + (unsigned int) *(bytecode_opcode_t *) pc); ret = -EINVAL; goto end; } - case FILTER_OP_EQ: - case FILTER_OP_NE: - case FILTER_OP_GT: - case FILTER_OP_LT: - case FILTER_OP_GE: - case FILTER_OP_LE: - case FILTER_OP_EQ_STRING: - case FILTER_OP_NE_STRING: - case FILTER_OP_GT_STRING: - case FILTER_OP_LT_STRING: - case FILTER_OP_GE_STRING: - case FILTER_OP_LE_STRING: - case FILTER_OP_EQ_STAR_GLOB_STRING: - case FILTER_OP_NE_STAR_GLOB_STRING: - case FILTER_OP_EQ_S64: - case FILTER_OP_NE_S64: - case FILTER_OP_GT_S64: - case FILTER_OP_LT_S64: - case FILTER_OP_GE_S64: - case FILTER_OP_LE_S64: + case BYTECODE_OP_EQ: + case BYTECODE_OP_NE: + case BYTECODE_OP_GT: + case BYTECODE_OP_LT: + case BYTECODE_OP_GE: + case BYTECODE_OP_LE: + case BYTECODE_OP_EQ_STRING: + case BYTECODE_OP_NE_STRING: + case BYTECODE_OP_GT_STRING: + case BYTECODE_OP_LT_STRING: + case BYTECODE_OP_GE_STRING: + case BYTECODE_OP_LE_STRING: + case BYTECODE_OP_EQ_STAR_GLOB_STRING: + case BYTECODE_OP_NE_STAR_GLOB_STRING: + case BYTECODE_OP_EQ_S64: + case BYTECODE_OP_NE_S64: + case BYTECODE_OP_GT_S64: + case BYTECODE_OP_LT_S64: + case BYTECODE_OP_GE_S64: + case BYTECODE_OP_LE_S64: { /* Pop 2, push 1 */ if (vstack_pop(stack)) { @@ -1306,11 +1306,11 @@ int exec_insn(struct bytecode_runtime *bytecode, next_pc += sizeof(struct binary_op); break; } - case FILTER_OP_BIT_RSHIFT: - case FILTER_OP_BIT_LSHIFT: - case FILTER_OP_BIT_AND: - case FILTER_OP_BIT_OR: - case FILTER_OP_BIT_XOR: + case BYTECODE_OP_BIT_RSHIFT: + case BYTECODE_OP_BIT_LSHIFT: + case BYTECODE_OP_BIT_AND: + case BYTECODE_OP_BIT_OR: + case BYTECODE_OP_BIT_XOR: { /* Pop 2, push 1 */ if (vstack_pop(stack)) { @@ -1318,7 +1318,7 @@ int exec_insn(struct bytecode_runtime *bytecode, goto end; } if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1331,7 +1331,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1343,12 +1343,12 @@ int exec_insn(struct bytecode_runtime *bytecode, } /* unary */ - case FILTER_OP_UNARY_PLUS: - case FILTER_OP_UNARY_MINUS: + case BYTECODE_OP_UNARY_PLUS: + case BYTECODE_OP_UNARY_MINUS: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1358,7 +1358,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1369,13 +1369,13 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_UNARY_PLUS_S64: - case FILTER_OP_UNARY_MINUS_S64: - case FILTER_OP_UNARY_NOT_S64: + case BYTECODE_OP_UNARY_PLUS_S64: + case BYTECODE_OP_UNARY_MINUS_S64: + case BYTECODE_OP_UNARY_NOT_S64: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1384,7 +1384,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_U64: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1394,11 +1394,11 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_UNARY_NOT: + case BYTECODE_OP_UNARY_NOT: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1408,7 +1408,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1418,11 +1418,11 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_UNARY_BIT_NOT: + case BYTECODE_OP_UNARY_BIT_NOT: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1433,7 +1433,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; case REG_DOUBLE: default: - printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1445,8 +1445,8 @@ int exec_insn(struct bytecode_runtime *bytecode, } /* logical */ - case FILTER_OP_AND: - case FILTER_OP_OR: + case BYTECODE_OP_AND: + case BYTECODE_OP_OR: { struct logical_op *insn = (struct logical_op *) pc; int merge_ret; @@ -1460,7 +1460,7 @@ int exec_insn(struct bytecode_runtime *bytecode, } if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1470,7 +1470,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_U64: break; default: - printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for operation\n", + printk(KERN_WARNING "LTTng: bytecode: Incorrect register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1487,24 +1487,24 @@ int exec_insn(struct bytecode_runtime *bytecode, } /* load field ref */ - case FILTER_OP_LOAD_FIELD_REF: + case BYTECODE_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n"); ret = -EINVAL; goto end; } /* get context ref */ - case FILTER_OP_GET_CONTEXT_REF: + case BYTECODE_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n"); ret = -EINVAL; goto end; } - case FILTER_OP_LOAD_FIELD_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: - case FILTER_OP_GET_CONTEXT_REF_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_STRING: - case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE: + case BYTECODE_OP_GET_CONTEXT_REF_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING: + case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1514,8 +1514,8 @@ int exec_insn(struct bytecode_runtime *bytecode, next_pc += sizeof(struct load_op) + sizeof(struct field_ref); break; } - case FILTER_OP_LOAD_FIELD_REF_S64: - case FILTER_OP_GET_CONTEXT_REF_S64: + case BYTECODE_OP_LOAD_FIELD_REF_S64: + case BYTECODE_OP_GET_CONTEXT_REF_S64: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1527,7 +1527,7 @@ int exec_insn(struct bytecode_runtime *bytecode, } /* load from immediate operand */ - case FILTER_OP_LOAD_STRING: + case BYTECODE_OP_LOAD_STRING: { struct load_op *insn = (struct load_op *) pc; @@ -1540,7 +1540,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_STAR_GLOB_STRING: + case BYTECODE_OP_LOAD_STAR_GLOB_STRING: { struct load_op *insn = (struct load_op *) pc; @@ -1553,7 +1553,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_S64: + case BYTECODE_OP_LOAD_S64: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1565,11 +1565,11 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_CAST_TO_S64: + case BYTECODE_OP_CAST_TO_S64: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1580,7 +1580,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for cast\n", + printk(KERN_WARNING "LTTng: bytecode: Incorrect register type %d for cast\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1589,7 +1589,7 @@ int exec_insn(struct bytecode_runtime *bytecode, next_pc += sizeof(struct cast_op); break; } - case FILTER_OP_CAST_NOP: + case BYTECODE_OP_CAST_NOP: { next_pc += sizeof(struct cast_op); break; @@ -1598,9 +1598,9 @@ int exec_insn(struct bytecode_runtime *bytecode, /* * Instructions for recursive traversal through composed types. */ - case FILTER_OP_GET_CONTEXT_ROOT: - case FILTER_OP_GET_APP_CONTEXT_ROOT: - case FILTER_OP_GET_PAYLOAD_ROOT: + case BYTECODE_OP_GET_CONTEXT_ROOT: + case BYTECODE_OP_GET_APP_CONTEXT_ROOT: + case BYTECODE_OP_GET_PAYLOAD_ROOT: { if (vstack_push(stack)) { ret = -EINVAL; @@ -1611,16 +1611,16 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_FIELD: + case BYTECODE_OP_LOAD_FIELD: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1629,10 +1629,10 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_FIELD_S8: - case FILTER_OP_LOAD_FIELD_S16: - case FILTER_OP_LOAD_FIELD_S32: - case FILTER_OP_LOAD_FIELD_S64: + case BYTECODE_OP_LOAD_FIELD_S8: + case BYTECODE_OP_LOAD_FIELD_S16: + case BYTECODE_OP_LOAD_FIELD_S32: + case BYTECODE_OP_LOAD_FIELD_S64: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { @@ -1649,19 +1649,19 @@ int exec_insn(struct bytecode_runtime *bytecode, next_pc += sizeof(struct load_op); break; } - case FILTER_OP_LOAD_FIELD_U8: - case FILTER_OP_LOAD_FIELD_U16: - case FILTER_OP_LOAD_FIELD_U32: - case FILTER_OP_LOAD_FIELD_U64: + case BYTECODE_OP_LOAD_FIELD_U8: + case BYTECODE_OP_LOAD_FIELD_U16: + case BYTECODE_OP_LOAD_FIELD_U32: + case BYTECODE_OP_LOAD_FIELD_U64: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1669,17 +1669,17 @@ int exec_insn(struct bytecode_runtime *bytecode, next_pc += sizeof(struct load_op); break; } - case FILTER_OP_LOAD_FIELD_STRING: - case FILTER_OP_LOAD_FIELD_SEQUENCE: + case BYTECODE_OP_LOAD_FIELD_STRING: + case BYTECODE_OP_LOAD_FIELD_SEQUENCE: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1688,16 +1688,16 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_LOAD_FIELD_DOUBLE: + case BYTECODE_OP_LOAD_FIELD_DOUBLE: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1706,17 +1706,17 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_SYMBOL: - case FILTER_OP_GET_SYMBOL_FIELD: + case BYTECODE_OP_GET_SYMBOL: + case BYTECODE_OP_GET_SYMBOL_FIELD: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1724,16 +1724,16 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_INDEX_U16: + case BYTECODE_OP_GET_INDEX_U16: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1741,16 +1741,16 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } - case FILTER_OP_GET_INDEX_U64: + case BYTECODE_OP_GET_INDEX_U64: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: bytecode: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1767,7 +1767,7 @@ end: /* * Never called concurrently (hash seed is shared). */ -int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) +int lttng_bytecode_validate(struct bytecode_runtime *bytecode) { struct mp_table *mp_table; char *pc, *next_pc, *start_pc; @@ -1778,7 +1778,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) mp_table = kzalloc(sizeof(*mp_table), GFP_KERNEL); if (!mp_table) { - printk(KERN_WARNING "LTTng: filter: Error allocating hash table for bytecode validation\n"); + printk(KERN_WARNING "LTTng: bytecode: Error allocating hash table for bytecode validation\n"); return -ENOMEM; } start_pc = &bytecode->code[0]; @@ -1787,12 +1787,12 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) ret = bytecode_validate_overflow(bytecode, start_pc, pc); if (ret != 0) { if (ret == -ERANGE) - printk(KERN_WARNING "LTTng: filter: filter bytecode overflow\n"); + printk(KERN_WARNING "LTTng: bytecode: bytecode overflow\n"); goto end; } dbg_printk("Validating op %s (%u)\n", - lttng_filter_print_op((unsigned int) *(filter_opcode_t *) pc), - (unsigned int) *(filter_opcode_t *) pc); + lttng_bytecode_print_op((unsigned int) *(bytecode_opcode_t *) pc), + (unsigned int) *(bytecode_opcode_t *) pc); /* * For each instruction, validate the current context @@ -1810,7 +1810,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) end: if (delete_all_nodes(mp_table)) { if (!ret) { - printk(KERN_WARNING "LTTng: filter: Unexpected merge points\n"); + printk(KERN_WARNING "LTTng: bytecode: Unexpected merge points\n"); ret = -EINVAL; } } diff --git a/src/lttng-filter.c b/src/lttng-bytecode.c similarity index 62% rename from src/lttng-filter.c rename to src/lttng-bytecode.c index a0ad3085..79c581c8 100644 --- a/src/lttng-filter.c +++ b/src/lttng-bytecode.c @@ -1,8 +1,8 @@ /* SPDX-License-Identifier: MIT * - * lttng-filter.c + * lttng-bytecode.c * - * LTTng modules filter code. + * LTTng modules bytecode code. * * Copyright (C) 2010-2016 Mathieu Desnoyers */ @@ -10,157 +10,157 @@ #include #include -#include +#include static const char *opnames[] = { - [ FILTER_OP_UNKNOWN ] = "UNKNOWN", + [ BYTECODE_OP_UNKNOWN ] = "UNKNOWN", - [ FILTER_OP_RETURN ] = "RETURN", + [ BYTECODE_OP_RETURN ] = "RETURN", /* binary */ - [ FILTER_OP_MUL ] = "MUL", - [ FILTER_OP_DIV ] = "DIV", - [ FILTER_OP_MOD ] = "MOD", - [ FILTER_OP_PLUS ] = "PLUS", - [ FILTER_OP_MINUS ] = "MINUS", - [ FILTER_OP_BIT_RSHIFT ] = "BIT_RSHIFT", - [ FILTER_OP_BIT_LSHIFT ] = "BIT_LSHIFT", - [ FILTER_OP_BIT_AND ] = "BIT_AND", - [ FILTER_OP_BIT_OR ] = "BIT_OR", - [ FILTER_OP_BIT_XOR ] = "BIT_XOR", + [ BYTECODE_OP_MUL ] = "MUL", + [ BYTECODE_OP_DIV ] = "DIV", + [ BYTECODE_OP_MOD ] = "MOD", + [ BYTECODE_OP_PLUS ] = "PLUS", + [ BYTECODE_OP_MINUS ] = "MINUS", + [ BYTECODE_OP_BIT_RSHIFT ] = "BIT_RSHIFT", + [ BYTECODE_OP_BIT_LSHIFT ] = "BIT_LSHIFT", + [ BYTECODE_OP_BIT_AND ] = "BIT_AND", + [ BYTECODE_OP_BIT_OR ] = "BIT_OR", + [ BYTECODE_OP_BIT_XOR ] = "BIT_XOR", /* binary comparators */ - [ FILTER_OP_EQ ] = "EQ", - [ FILTER_OP_NE ] = "NE", - [ FILTER_OP_GT ] = "GT", - [ FILTER_OP_LT ] = "LT", - [ FILTER_OP_GE ] = "GE", - [ FILTER_OP_LE ] = "LE", + [ BYTECODE_OP_EQ ] = "EQ", + [ BYTECODE_OP_NE ] = "NE", + [ BYTECODE_OP_GT ] = "GT", + [ BYTECODE_OP_LT ] = "LT", + [ BYTECODE_OP_GE ] = "GE", + [ BYTECODE_OP_LE ] = "LE", /* string binary comparators */ - [ FILTER_OP_EQ_STRING ] = "EQ_STRING", - [ FILTER_OP_NE_STRING ] = "NE_STRING", - [ FILTER_OP_GT_STRING ] = "GT_STRING", - [ FILTER_OP_LT_STRING ] = "LT_STRING", - [ FILTER_OP_GE_STRING ] = "GE_STRING", - [ FILTER_OP_LE_STRING ] = "LE_STRING", + [ BYTECODE_OP_EQ_STRING ] = "EQ_STRING", + [ BYTECODE_OP_NE_STRING ] = "NE_STRING", + [ BYTECODE_OP_GT_STRING ] = "GT_STRING", + [ BYTECODE_OP_LT_STRING ] = "LT_STRING", + [ BYTECODE_OP_GE_STRING ] = "GE_STRING", + [ BYTECODE_OP_LE_STRING ] = "LE_STRING", /* s64 binary comparators */ - [ FILTER_OP_EQ_S64 ] = "EQ_S64", - [ FILTER_OP_NE_S64 ] = "NE_S64", - [ FILTER_OP_GT_S64 ] = "GT_S64", - [ FILTER_OP_LT_S64 ] = "LT_S64", - [ FILTER_OP_GE_S64 ] = "GE_S64", - [ FILTER_OP_LE_S64 ] = "LE_S64", + [ BYTECODE_OP_EQ_S64 ] = "EQ_S64", + [ BYTECODE_OP_NE_S64 ] = "NE_S64", + [ BYTECODE_OP_GT_S64 ] = "GT_S64", + [ BYTECODE_OP_LT_S64 ] = "LT_S64", + [ BYTECODE_OP_GE_S64 ] = "GE_S64", + [ BYTECODE_OP_LE_S64 ] = "LE_S64", /* double binary comparators */ - [ FILTER_OP_EQ_DOUBLE ] = "EQ_DOUBLE", - [ FILTER_OP_NE_DOUBLE ] = "NE_DOUBLE", - [ FILTER_OP_GT_DOUBLE ] = "GT_DOUBLE", - [ FILTER_OP_LT_DOUBLE ] = "LT_DOUBLE", - [ FILTER_OP_GE_DOUBLE ] = "GE_DOUBLE", - [ FILTER_OP_LE_DOUBLE ] = "LE_DOUBLE", + [ BYTECODE_OP_EQ_DOUBLE ] = "EQ_DOUBLE", + [ BYTECODE_OP_NE_DOUBLE ] = "NE_DOUBLE", + [ BYTECODE_OP_GT_DOUBLE ] = "GT_DOUBLE", + [ BYTECODE_OP_LT_DOUBLE ] = "LT_DOUBLE", + [ BYTECODE_OP_GE_DOUBLE ] = "GE_DOUBLE", + [ BYTECODE_OP_LE_DOUBLE ] = "LE_DOUBLE", /* Mixed S64-double binary comparators */ - [ FILTER_OP_EQ_DOUBLE_S64 ] = "EQ_DOUBLE_S64", - [ FILTER_OP_NE_DOUBLE_S64 ] = "NE_DOUBLE_S64", - [ FILTER_OP_GT_DOUBLE_S64 ] = "GT_DOUBLE_S64", - [ FILTER_OP_LT_DOUBLE_S64 ] = "LT_DOUBLE_S64", - [ FILTER_OP_GE_DOUBLE_S64 ] = "GE_DOUBLE_S64", - [ FILTER_OP_LE_DOUBLE_S64 ] = "LE_DOUBLE_S64", - - [ FILTER_OP_EQ_S64_DOUBLE ] = "EQ_S64_DOUBLE", - [ FILTER_OP_NE_S64_DOUBLE ] = "NE_S64_DOUBLE", - [ FILTER_OP_GT_S64_DOUBLE ] = "GT_S64_DOUBLE", - [ FILTER_OP_LT_S64_DOUBLE ] = "LT_S64_DOUBLE", - [ FILTER_OP_GE_S64_DOUBLE ] = "GE_S64_DOUBLE", - [ FILTER_OP_LE_S64_DOUBLE ] = "LE_S64_DOUBLE", + [ BYTECODE_OP_EQ_DOUBLE_S64 ] = "EQ_DOUBLE_S64", + [ BYTECODE_OP_NE_DOUBLE_S64 ] = "NE_DOUBLE_S64", + [ BYTECODE_OP_GT_DOUBLE_S64 ] = "GT_DOUBLE_S64", + [ BYTECODE_OP_LT_DOUBLE_S64 ] = "LT_DOUBLE_S64", + [ BYTECODE_OP_GE_DOUBLE_S64 ] = "GE_DOUBLE_S64", + [ BYTECODE_OP_LE_DOUBLE_S64 ] = "LE_DOUBLE_S64", + + [ BYTECODE_OP_EQ_S64_DOUBLE ] = "EQ_S64_DOUBLE", + [ BYTECODE_OP_NE_S64_DOUBLE ] = "NE_S64_DOUBLE", + [ BYTECODE_OP_GT_S64_DOUBLE ] = "GT_S64_DOUBLE", + [ BYTECODE_OP_LT_S64_DOUBLE ] = "LT_S64_DOUBLE", + [ BYTECODE_OP_GE_S64_DOUBLE ] = "GE_S64_DOUBLE", + [ BYTECODE_OP_LE_S64_DOUBLE ] = "LE_S64_DOUBLE", /* unary */ - [ FILTER_OP_UNARY_PLUS ] = "UNARY_PLUS", - [ FILTER_OP_UNARY_MINUS ] = "UNARY_MINUS", - [ FILTER_OP_UNARY_NOT ] = "UNARY_NOT", - [ FILTER_OP_UNARY_PLUS_S64 ] = "UNARY_PLUS_S64", - [ FILTER_OP_UNARY_MINUS_S64 ] = "UNARY_MINUS_S64", - [ FILTER_OP_UNARY_NOT_S64 ] = "UNARY_NOT_S64", - [ FILTER_OP_UNARY_PLUS_DOUBLE ] = "UNARY_PLUS_DOUBLE", - [ FILTER_OP_UNARY_MINUS_DOUBLE ] = "UNARY_MINUS_DOUBLE", - [ FILTER_OP_UNARY_NOT_DOUBLE ] = "UNARY_NOT_DOUBLE", + [ BYTECODE_OP_UNARY_PLUS ] = "UNARY_PLUS", + [ BYTECODE_OP_UNARY_MINUS ] = "UNARY_MINUS", + [ BYTECODE_OP_UNARY_NOT ] = "UNARY_NOT", + [ BYTECODE_OP_UNARY_PLUS_S64 ] = "UNARY_PLUS_S64", + [ BYTECODE_OP_UNARY_MINUS_S64 ] = "UNARY_MINUS_S64", + [ BYTECODE_OP_UNARY_NOT_S64 ] = "UNARY_NOT_S64", + [ BYTECODE_OP_UNARY_PLUS_DOUBLE ] = "UNARY_PLUS_DOUBLE", + [ BYTECODE_OP_UNARY_MINUS_DOUBLE ] = "UNARY_MINUS_DOUBLE", + [ BYTECODE_OP_UNARY_NOT_DOUBLE ] = "UNARY_NOT_DOUBLE", /* logical */ - [ FILTER_OP_AND ] = "AND", - [ FILTER_OP_OR ] = "OR", + [ BYTECODE_OP_AND ] = "AND", + [ BYTECODE_OP_OR ] = "OR", /* load field ref */ - [ FILTER_OP_LOAD_FIELD_REF ] = "LOAD_FIELD_REF", - [ FILTER_OP_LOAD_FIELD_REF_STRING ] = "LOAD_FIELD_REF_STRING", - [ FILTER_OP_LOAD_FIELD_REF_SEQUENCE ] = "LOAD_FIELD_REF_SEQUENCE", - [ FILTER_OP_LOAD_FIELD_REF_S64 ] = "LOAD_FIELD_REF_S64", - [ FILTER_OP_LOAD_FIELD_REF_DOUBLE ] = "LOAD_FIELD_REF_DOUBLE", + [ BYTECODE_OP_LOAD_FIELD_REF ] = "LOAD_FIELD_REF", + [ BYTECODE_OP_LOAD_FIELD_REF_STRING ] = "LOAD_FIELD_REF_STRING", + [ BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE ] = "LOAD_FIELD_REF_SEQUENCE", + [ BYTECODE_OP_LOAD_FIELD_REF_S64 ] = "LOAD_FIELD_REF_S64", + [ BYTECODE_OP_LOAD_FIELD_REF_DOUBLE ] = "LOAD_FIELD_REF_DOUBLE", /* load from immediate operand */ - [ FILTER_OP_LOAD_STRING ] = "LOAD_STRING", - [ FILTER_OP_LOAD_S64 ] = "LOAD_S64", - [ FILTER_OP_LOAD_DOUBLE ] = "LOAD_DOUBLE", + [ BYTECODE_OP_LOAD_STRING ] = "LOAD_STRING", + [ BYTECODE_OP_LOAD_S64 ] = "LOAD_S64", + [ BYTECODE_OP_LOAD_DOUBLE ] = "LOAD_DOUBLE", /* cast */ - [ FILTER_OP_CAST_TO_S64 ] = "CAST_TO_S64", - [ FILTER_OP_CAST_DOUBLE_TO_S64 ] = "CAST_DOUBLE_TO_S64", - [ FILTER_OP_CAST_NOP ] = "CAST_NOP", + [ BYTECODE_OP_CAST_TO_S64 ] = "CAST_TO_S64", + [ BYTECODE_OP_CAST_DOUBLE_TO_S64 ] = "CAST_DOUBLE_TO_S64", + [ BYTECODE_OP_CAST_NOP ] = "CAST_NOP", /* get context ref */ - [ FILTER_OP_GET_CONTEXT_REF ] = "GET_CONTEXT_REF", - [ FILTER_OP_GET_CONTEXT_REF_STRING ] = "GET_CONTEXT_REF_STRING", - [ FILTER_OP_GET_CONTEXT_REF_S64 ] = "GET_CONTEXT_REF_S64", - [ FILTER_OP_GET_CONTEXT_REF_DOUBLE ] = "GET_CONTEXT_REF_DOUBLE", + [ BYTECODE_OP_GET_CONTEXT_REF ] = "GET_CONTEXT_REF", + [ BYTECODE_OP_GET_CONTEXT_REF_STRING ] = "GET_CONTEXT_REF_STRING", + [ BYTECODE_OP_GET_CONTEXT_REF_S64 ] = "GET_CONTEXT_REF_S64", + [ BYTECODE_OP_GET_CONTEXT_REF_DOUBLE ] = "GET_CONTEXT_REF_DOUBLE", /* load userspace field ref */ - [ FILTER_OP_LOAD_FIELD_REF_USER_STRING ] = "LOAD_FIELD_REF_USER_STRING", - [ FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE ] = "LOAD_FIELD_REF_USER_SEQUENCE", + [ BYTECODE_OP_LOAD_FIELD_REF_USER_STRING ] = "LOAD_FIELD_REF_USER_STRING", + [ BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE ] = "LOAD_FIELD_REF_USER_SEQUENCE", /* * load immediate star globbing pattern (literal string) * from immediate. */ - [ FILTER_OP_LOAD_STAR_GLOB_STRING ] = "LOAD_STAR_GLOB_STRING", + [ BYTECODE_OP_LOAD_STAR_GLOB_STRING ] = "LOAD_STAR_GLOB_STRING", /* globbing pattern binary operator: apply to */ - [ FILTER_OP_EQ_STAR_GLOB_STRING ] = "EQ_STAR_GLOB_STRING", - [ FILTER_OP_NE_STAR_GLOB_STRING ] = "NE_STAR_GLOB_STRING", + [ BYTECODE_OP_EQ_STAR_GLOB_STRING ] = "EQ_STAR_GLOB_STRING", + [ BYTECODE_OP_NE_STAR_GLOB_STRING ] = "NE_STAR_GLOB_STRING", /* * Instructions for recursive traversal through composed types. */ - [ FILTER_OP_GET_CONTEXT_ROOT ] = "GET_CONTEXT_ROOT", - [ FILTER_OP_GET_APP_CONTEXT_ROOT ] = "GET_APP_CONTEXT_ROOT", - [ FILTER_OP_GET_PAYLOAD_ROOT ] = "GET_PAYLOAD_ROOT", - - [ FILTER_OP_GET_SYMBOL ] = "GET_SYMBOL", - [ FILTER_OP_GET_SYMBOL_FIELD ] = "GET_SYMBOL_FIELD", - [ FILTER_OP_GET_INDEX_U16 ] = "GET_INDEX_U16", - [ FILTER_OP_GET_INDEX_U64 ] = "GET_INDEX_U64", - - [ FILTER_OP_LOAD_FIELD ] = "LOAD_FIELD", - [ FILTER_OP_LOAD_FIELD_S8 ] = "LOAD_FIELD_S8", - [ FILTER_OP_LOAD_FIELD_S16 ] = "LOAD_FIELD_S16", - [ FILTER_OP_LOAD_FIELD_S32 ] = "LOAD_FIELD_S32", - [ FILTER_OP_LOAD_FIELD_S64 ] = "LOAD_FIELD_S64", - [ FILTER_OP_LOAD_FIELD_U8 ] = "LOAD_FIELD_U8", - [ FILTER_OP_LOAD_FIELD_U16 ] = "LOAD_FIELD_U16", - [ FILTER_OP_LOAD_FIELD_U32 ] = "LOAD_FIELD_U32", - [ FILTER_OP_LOAD_FIELD_U64 ] = "LOAD_FIELD_U64", - [ FILTER_OP_LOAD_FIELD_STRING ] = "LOAD_FIELD_STRING", - [ FILTER_OP_LOAD_FIELD_SEQUENCE ] = "LOAD_FIELD_SEQUENCE", - [ FILTER_OP_LOAD_FIELD_DOUBLE ] = "LOAD_FIELD_DOUBLE", - - [ FILTER_OP_UNARY_BIT_NOT ] = "UNARY_BIT_NOT", - - [ FILTER_OP_RETURN_S64 ] = "RETURN_S64", + [ BYTECODE_OP_GET_CONTEXT_ROOT ] = "GET_CONTEXT_ROOT", + [ BYTECODE_OP_GET_APP_CONTEXT_ROOT ] = "GET_APP_CONTEXT_ROOT", + [ BYTECODE_OP_GET_PAYLOAD_ROOT ] = "GET_PAYLOAD_ROOT", + + [ BYTECODE_OP_GET_SYMBOL ] = "GET_SYMBOL", + [ BYTECODE_OP_GET_SYMBOL_FIELD ] = "GET_SYMBOL_FIELD", + [ BYTECODE_OP_GET_INDEX_U16 ] = "GET_INDEX_U16", + [ BYTECODE_OP_GET_INDEX_U64 ] = "GET_INDEX_U64", + + [ BYTECODE_OP_LOAD_FIELD ] = "LOAD_FIELD", + [ BYTECODE_OP_LOAD_FIELD_S8 ] = "LOAD_FIELD_S8", + [ BYTECODE_OP_LOAD_FIELD_S16 ] = "LOAD_FIELD_S16", + [ BYTECODE_OP_LOAD_FIELD_S32 ] = "LOAD_FIELD_S32", + [ BYTECODE_OP_LOAD_FIELD_S64 ] = "LOAD_FIELD_S64", + [ BYTECODE_OP_LOAD_FIELD_U8 ] = "LOAD_FIELD_U8", + [ BYTECODE_OP_LOAD_FIELD_U16 ] = "LOAD_FIELD_U16", + [ BYTECODE_OP_LOAD_FIELD_U32 ] = "LOAD_FIELD_U32", + [ BYTECODE_OP_LOAD_FIELD_U64 ] = "LOAD_FIELD_U64", + [ BYTECODE_OP_LOAD_FIELD_STRING ] = "LOAD_FIELD_STRING", + [ BYTECODE_OP_LOAD_FIELD_SEQUENCE ] = "LOAD_FIELD_SEQUENCE", + [ BYTECODE_OP_LOAD_FIELD_DOUBLE ] = "LOAD_FIELD_DOUBLE", + + [ BYTECODE_OP_UNARY_BIT_NOT ] = "UNARY_BIT_NOT", + + [ BYTECODE_OP_RETURN_S64 ] = "RETURN_S64", }; -const char *lttng_filter_print_op(enum filter_op op) +const char *lttng_bytecode_print_op(enum bytecode_op op) { - if (op >= NR_FILTER_OPS) + if (op >= NR_BYTECODE_OPS) return "UNKNOWN"; else return opnames[op]; @@ -172,7 +172,7 @@ int apply_field_reloc(const struct lttng_event_desc *event_desc, uint32_t runtime_len, uint32_t reloc_offset, const char *field_name, - enum filter_op filter_op) + enum bytecode_op bytecode_op) { const struct lttng_event_field *fields, *field = NULL; unsigned int nr_fields, i; @@ -232,8 +232,8 @@ int apply_field_reloc(const struct lttng_event_desc *event_desc, /* set type */ op = (struct load_op *) &runtime->code[reloc_offset]; - switch (filter_op) { - case FILTER_OP_LOAD_FIELD_REF: + switch (bytecode_op) { + case BYTECODE_OP_LOAD_FIELD_REF: { struct field_ref *field_ref; @@ -241,20 +241,20 @@ int apply_field_reloc(const struct lttng_event_desc *event_desc, switch (field->type.atype) { case atype_integer: case atype_enum_nestable: - op->op = FILTER_OP_LOAD_FIELD_REF_S64; + op->op = BYTECODE_OP_LOAD_FIELD_REF_S64; break; case atype_array_nestable: case atype_sequence_nestable: if (field->user) - op->op = FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE; + op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE; else - op->op = FILTER_OP_LOAD_FIELD_REF_SEQUENCE; + op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE; break; case atype_string: if (field->user) - op->op = FILTER_OP_LOAD_FIELD_REF_USER_STRING; + op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_STRING; else - op->op = FILTER_OP_LOAD_FIELD_REF_STRING; + op->op = BYTECODE_OP_LOAD_FIELD_REF_STRING; break; case atype_struct_nestable: /* Unsupported. */ case atype_variant_nestable: /* Unsupported. */ @@ -276,7 +276,7 @@ int apply_context_reloc(struct bytecode_runtime *runtime, uint32_t runtime_len, uint32_t reloc_offset, const char *context_name, - enum filter_op filter_op) + enum bytecode_op bytecode_op) { struct load_op *op; struct lttng_ctx_field *ctx_field; @@ -297,8 +297,8 @@ int apply_context_reloc(struct bytecode_runtime *runtime, ctx_field = <tng_static_ctx->fields[idx]; op = (struct load_op *) &runtime->code[reloc_offset]; - switch (filter_op) { - case FILTER_OP_GET_CONTEXT_REF: + switch (bytecode_op) { + case BYTECODE_OP_GET_CONTEXT_REF: { struct field_ref *field_ref; @@ -306,24 +306,24 @@ int apply_context_reloc(struct bytecode_runtime *runtime, switch (ctx_field->event_field.type.atype) { case atype_integer: case atype_enum_nestable: - op->op = FILTER_OP_GET_CONTEXT_REF_S64; + op->op = BYTECODE_OP_GET_CONTEXT_REF_S64; break; /* Sequence and array supported as string */ case atype_string: BUG_ON(ctx_field->event_field.user); - op->op = FILTER_OP_GET_CONTEXT_REF_STRING; + op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING; break; case atype_array_nestable: if (!lttng_is_bytewise_integer(ctx_field->event_field.type.u.array_nestable.elem_type)) return -EINVAL; BUG_ON(ctx_field->event_field.user); - op->op = FILTER_OP_GET_CONTEXT_REF_STRING; + op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING; break; case atype_sequence_nestable: if (!lttng_is_bytewise_integer(ctx_field->event_field.type.u.sequence_nestable.elem_type)) return -EINVAL; BUG_ON(ctx_field->event_field.user); - op->op = FILTER_OP_GET_CONTEXT_REF_STRING; + op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING; break; case atype_struct_nestable: /* Unsupported. */ case atype_variant_nestable: /* Unsupported. */ @@ -357,14 +357,14 @@ int apply_reloc(const struct lttng_event_desc *event_desc, op = (struct load_op *) &runtime->code[reloc_offset]; switch (op->op) { - case FILTER_OP_LOAD_FIELD_REF: + case BYTECODE_OP_LOAD_FIELD_REF: return apply_field_reloc(event_desc, runtime, runtime_len, reloc_offset, name, op->op); - case FILTER_OP_GET_CONTEXT_REF: + case BYTECODE_OP_GET_CONTEXT_REF: return apply_context_reloc(runtime, runtime_len, reloc_offset, name, op->op); - case FILTER_OP_GET_SYMBOL: - case FILTER_OP_GET_SYMBOL_FIELD: + case BYTECODE_OP_GET_SYMBOL: + case BYTECODE_OP_GET_SYMBOL_FIELD: /* * Will be handled by load specialize phase or * dynamically by interpreter. @@ -443,23 +443,23 @@ int _lttng_filter_link_bytecode(const struct lttng_event_desc *event_desc, next_offset = offset + sizeof(uint16_t) + strlen(name) + 1; } /* Validate bytecode */ - ret = lttng_filter_validate_bytecode(runtime); + ret = lttng_bytecode_validate(runtime); if (ret) { goto link_error; } /* Specialize bytecode */ - ret = lttng_filter_specialize_bytecode(event_desc, runtime); + ret = lttng_bytecode_specialize(event_desc, runtime); if (ret) { goto link_error; } - runtime->p.filter = lttng_filter_interpret_bytecode; + runtime->p.filter = lttng_bytecode_filter_interpret; runtime->p.link_failed = 0; list_add_rcu(&runtime->p.node, insert_loc); dbg_printk("Linking successful.\n"); return 0; link_error: - runtime->p.filter = lttng_filter_interpret_bytecode_false; + runtime->p.filter = lttng_bytecode_filter_interpret_false; runtime->p.link_failed = 1; list_add_rcu(&runtime->p.node, insert_loc); alloc_error: @@ -472,9 +472,9 @@ void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime) struct lttng_bytecode_node *bc = runtime->bc; if (!bc->enabler->enabled || runtime->link_failed) - runtime->filter = lttng_filter_interpret_bytecode_false; + runtime->filter = lttng_bytecode_filter_interpret_false; else - runtime->filter = lttng_filter_interpret_bytecode; + runtime->filter = lttng_bytecode_filter_interpret; } /* -- 2.34.1