X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-bytecode-interpreter.c;h=a2a932c65f2d488d1f119741801cdbf0ef3c2456;hb=45fe4e1a42028b821757e0b98f9b33bf435a108a;hp=ca836d15be1e1d2eb54d2b0a5470071a6f32700f;hpb=a775608d0d1d6142c80c26b21ff79bf7e04d8e53;p=lttng-modules.git diff --git a/src/lttng-bytecode-interpreter.c b/src/lttng-bytecode-interpreter.c index ca836d15..a2a932c6 100644 --- a/src/lttng-bytecode-interpreter.c +++ b/src/lttng-bytecode-interpreter.c @@ -7,6 +7,7 @@ * Copyright (C) 2010-2016 Mathieu Desnoyers */ +#include #include #include #include @@ -208,19 +209,13 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type) return diff; } -uint64_t lttng_bytecode_filter_interpret_false(void *filter_data, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *filter_stack_data) +int lttng_bytecode_interpret_error( + struct lttng_kernel_bytecode_runtime *bytecode_runtime __attribute__((unused)), + const char *stack_data __attribute__((unused)), + struct lttng_kernel_probe_ctx *probe_ctx __attribute__((unused)), + void *ctx __attribute__((unused))) { - return LTTNG_INTERPRETER_DISCARD; -} - -uint64_t lttng_bytecode_capture_interpret_false(void *filter_data, - const char *capture_stack_data, - struct lttng_probe_ctx *lttng_probe_ctx, - struct lttng_interpreter_output *output) -{ - return LTTNG_INTERPRETER_DISCARD; + return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR; } #ifdef INTERPRETER_USE_SWITCH @@ -272,14 +267,14 @@ LABEL_##name #define IS_INTEGER_REGISTER(reg_type) \ (reg_type == REG_S64 || reg_type == REG_U64) -static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, +static int context_get_index(struct lttng_kernel_probe_ctx *lttng_probe_ctx, struct load_ptr *ptr, uint32_t idx) { struct lttng_kernel_ctx_field *ctx_field; const struct lttng_kernel_event_field *field; - union lttng_ctx_value v; + struct lttng_ctx_value v; ctx_field = <tng_static_ctx->fields[idx]; field = ctx_field->event_field; @@ -289,14 +284,14 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, switch (field->type->type) { case lttng_kernel_type_integer: - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); if (lttng_kernel_get_type_integer(field->type)->signedness) { ptr->object_type = OBJECT_TYPE_S64; - ptr->u.s64 = v.s64; + ptr->u.s64 = v.u.s64; ptr->ptr = &ptr->u.s64; } else { ptr->object_type = OBJECT_TYPE_U64; - ptr->u.u64 = v.s64; /* Cast. */ + ptr->u.u64 = v.u.s64; /* Cast. */ ptr->ptr = &ptr->u.u64; } break; @@ -305,14 +300,14 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, const struct lttng_kernel_type_enum *enum_type = lttng_kernel_get_type_enum(field->type); const struct lttng_kernel_type_integer *integer_type = lttng_kernel_get_type_integer(enum_type->container_type); - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); if (integer_type->signedness) { ptr->object_type = OBJECT_TYPE_SIGNED_ENUM; - ptr->u.s64 = v.s64; + ptr->u.s64 = v.u.s64; ptr->ptr = &ptr->u.s64; } else { ptr->object_type = OBJECT_TYPE_UNSIGNED_ENUM; - ptr->u.u64 = v.s64; /* Cast. */ + ptr->u.u64 = v.u.s64; /* Cast. */ ptr->ptr = &ptr->u.u64; } break; @@ -330,8 +325,8 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); - ptr->ptr = v.str; + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); + ptr->ptr = v.u.str; break; } case lttng_kernel_type_sequence: @@ -347,14 +342,14 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); - ptr->ptr = v.str; + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); + ptr->ptr = v.u.str; break; } case lttng_kernel_type_string: ptr->object_type = OBJECT_TYPE_STRING; - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); - ptr->ptr = v.str; + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); + ptr->ptr = v.u.str; break; case lttng_kernel_type_struct: printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n"); @@ -369,7 +364,7 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, return 0; } -static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, +static int dynamic_get_index(struct lttng_kernel_probe_ctx *lttng_probe_ctx, struct bytecode_runtime *runtime, uint64_t index, struct estack_entry *stack_top) { @@ -427,7 +422,8 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, } break; case LOAD_ROOT_CONTEXT: - case LOAD_ROOT_APP_CONTEXT: /* Fall-through */ + lttng_fallthrough; + case LOAD_ROOT_APP_CONTEXT: { ret = context_get_index(lttng_probe_ctx, &stack_top->u.ptr, @@ -717,7 +713,7 @@ again: return -EINVAL; } - return LTTNG_INTERPRETER_RECORD_FLAG; + return 0; } #ifdef DEBUG @@ -754,17 +750,20 @@ void dbg_load_ref_user_str_printk(const struct estack_entry *user_str_reg) #endif /* - * Return 0 (discard), or raise the 0x1 flag (log event). - * Currently, other flags are kept for future extensions and have no - * effect. + * Return LTTNG_KERNEL_BYTECODE_INTERPRETER_OK on success. + * Return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR on error. + * + * For FILTER bytecode: expect a struct lttng_kernel_bytecode_filter_ctx * + * as @ctx argument. + * For CAPTURE bytecode: expect a struct lttng_interpreter_output * + * as @ctx argument. */ -static -uint64_t bytecode_interpret(void *interpreter_data, +int lttng_bytecode_interpret(struct lttng_kernel_bytecode_runtime *kernel_bytecode, const char *interpreter_stack_data, - struct lttng_probe_ctx *lttng_probe_ctx, - struct lttng_interpreter_output *output) + struct lttng_kernel_probe_ctx *lttng_probe_ctx, + void *caller_ctx) { - struct bytecode_runtime *bytecode = interpreter_data; + struct bytecode_runtime *bytecode = container_of(kernel_bytecode, struct bytecode_runtime, p); void *pc, *next_pc, *start_pc; int ret = -EINVAL; uint64_t retval = 0; @@ -928,8 +927,7 @@ uint64_t bytecode_interpret(void *interpreter_data, goto end; OP(BYTECODE_OP_RETURN): - OP(BYTECODE_OP_RETURN_S64): - /* LTTNG_INTERPRETER_DISCARD or LTTNG_INTERPRETER_RECORD_FLAG */ + /* LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR or LTTNG_KERNEL_BYTECODE_INTERPRETER_OK */ switch (estack_ax_t) { case REG_S64: case REG_U64: @@ -938,7 +936,7 @@ uint64_t bytecode_interpret(void *interpreter_data, case REG_DOUBLE: case REG_STRING: case REG_PTR: - if (!output) { + if (kernel_bytecode->type != LTTNG_KERNEL_BYTECODE_TYPE_CAPTURE) { ret = -EINVAL; goto end; } @@ -952,6 +950,12 @@ uint64_t bytecode_interpret(void *interpreter_data, ret = 0; goto end; + OP(BYTECODE_OP_RETURN_S64): + /* LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR or LTTNG_KERNEL_BYTECODE_INTERPRETER_OK */ + retval = !!estack_ax_v; + ret = 0; + goto end; + /* binary */ OP(BYTECODE_OP_MUL): OP(BYTECODE_OP_DIV): @@ -1486,14 +1490,14 @@ uint64_t bytecode_interpret(void *interpreter_data, struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; struct lttng_kernel_ctx_field *ctx_field; - union lttng_ctx_value v; + struct lttng_ctx_value v; dbg_printk("get context ref offset %u type string\n", ref->offset); ctx_field = <tng_static_ctx->fields[ref->offset]; - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); estack_push(stack, top, ax, bx, ax_t, bx_t); - estack_ax(stack, top)->u.s.str = v.str; + estack_ax(stack, top)->u.s.str = v.u.str; if (unlikely(!estack_ax(stack, top)->u.s.str)) { dbg_printk("Bytecode warning: loading a NULL string.\n"); ret = -EINVAL; @@ -1514,14 +1518,14 @@ uint64_t bytecode_interpret(void *interpreter_data, struct load_op *insn = (struct load_op *) pc; struct field_ref *ref = (struct field_ref *) insn->data; struct lttng_kernel_ctx_field *ctx_field; - union lttng_ctx_value v; + struct lttng_ctx_value v; dbg_printk("get context ref offset %u type s64\n", ref->offset); ctx_field = <tng_static_ctx->fields[ref->offset]; - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); + ctx_field->get_value(ctx_field->priv, lttng_probe_ctx, &v); estack_push(stack, top, ax, bx, ax_t, bx_t); - estack_ax_v = v.s64; + estack_ax_v = v.u.s64; estack_ax_t = REG_S64; dbg_printk("ref get context s64 %lld\n", (long long) estack_ax_v); @@ -1811,34 +1815,63 @@ uint64_t bytecode_interpret(void *interpreter_data, END_OP end: - /* Return _DISCARD on error. */ + /* No need to prepare output if an error occurred. */ if (ret) - return LTTNG_INTERPRETER_DISCARD; + return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR; - if (output) { - return lttng_bytecode_interpret_format_output( - estack_ax(stack, top), output); + /* Prepare output. */ + switch (kernel_bytecode->type) { + case LTTNG_KERNEL_BYTECODE_TYPE_FILTER: + { + struct lttng_kernel_bytecode_filter_ctx *filter_ctx = + (struct lttng_kernel_bytecode_filter_ctx *) caller_ctx; + if (retval) + filter_ctx->result = LTTNG_KERNEL_BYTECODE_FILTER_ACCEPT; + else + filter_ctx->result = LTTNG_KERNEL_BYTECODE_FILTER_REJECT; + break; } - - return retval; -} -LTTNG_STACK_FRAME_NON_STANDARD(bytecode_interpret); - -uint64_t lttng_bytecode_filter_interpret(void *filter_data, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *filter_stack_data) -{ - return bytecode_interpret(filter_data, - filter_stack_data, lttng_probe_ctx, NULL); + case LTTNG_KERNEL_BYTECODE_TYPE_CAPTURE: + ret = lttng_bytecode_interpret_format_output(estack_ax(stack, top), + (struct lttng_interpreter_output *) caller_ctx); + break; + default: + ret = -EINVAL; + break; + } + if (ret) + return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR; + else + return LTTNG_KERNEL_BYTECODE_INTERPRETER_OK; } +LTTNG_STACK_FRAME_NON_STANDARD(lttng_bytecode_interpret); -uint64_t lttng_bytecode_capture_interpret(void *capture_data, - const char *capture_stack_data, - struct lttng_probe_ctx *lttng_probe_ctx, - struct lttng_interpreter_output *output) +/* + * Return LTTNG_KERNEL_EVENT_FILTER_ACCEPT or LTTNG_KERNEL_EVENT_FILTER_REJECT. + */ +int lttng_kernel_interpret_event_filter(const struct lttng_kernel_event_common *event, + const char *interpreter_stack_data, + struct lttng_kernel_probe_ctx *probe_ctx, + void *event_filter_ctx __attribute__((unused))) { - return bytecode_interpret(capture_data, - capture_stack_data, lttng_probe_ctx, output); + struct lttng_kernel_bytecode_runtime *filter_bc_runtime; + struct list_head *filter_bytecode_runtime_head = &event->priv->filter_bytecode_runtime_head; + struct lttng_kernel_bytecode_filter_ctx bytecode_filter_ctx; + bool filter_record = false; + + list_for_each_entry_rcu(filter_bc_runtime, filter_bytecode_runtime_head, node) { + if (likely(filter_bc_runtime->interpreter_func(filter_bc_runtime, + interpreter_stack_data, probe_ctx, &bytecode_filter_ctx) == LTTNG_KERNEL_BYTECODE_INTERPRETER_OK)) { + if (unlikely(bytecode_filter_ctx.result == LTTNG_KERNEL_BYTECODE_FILTER_ACCEPT)) { + filter_record = true; + break; + } + } + } + if (filter_record) + return LTTNG_KERNEL_EVENT_FILTER_ACCEPT; + else + return LTTNG_KERNEL_EVENT_FILTER_REJECT; } #undef START_OP