X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-bytecode-interpreter.c;h=8ffe2f41d14156aa9b2050b563519ce4a7f985f8;hb=2dc781e02eb156a76554ada092a181ab2916db57;hp=01828b171aaf799201e6c8677b787c14f2d85d68;hpb=12bb2edb6ed3e96d3299a979e49b828f2b17dcb2;p=lttng-modules.git diff --git a/src/lttng-bytecode-interpreter.c b/src/lttng-bytecode-interpreter.c index 01828b17..8ffe2f41 100644 --- a/src/lttng-bytecode-interpreter.c +++ b/src/lttng-bytecode-interpreter.c @@ -14,6 +14,7 @@ #include #include +#include /* * get_char should be called with page fault handler disabled if it is expected @@ -207,19 +208,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) -{ - return LTTNG_INTERPRETER_DISCARD; -} - -uint64_t lttng_bytecode_capture_interpret_false(void *filter_data, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *capture_stack_data, - struct lttng_interpreter_output *output) +int lttng_bytecode_interpret_error( + struct lttng_bytecode_runtime *bytecode_runtime __attribute__((unused)), + const char *stack_data __attribute__((unused)), + struct lttng_probe_ctx *probe_ctx __attribute__((unused)), + void *ctx __attribute__((unused))) { - return LTTNG_INTERPRETER_DISCARD; + return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR; } #ifdef INTERPRETER_USE_SWITCH @@ -276,85 +271,93 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, uint32_t idx) { - struct lttng_ctx_field *ctx_field; - struct lttng_event_field *field; - union lttng_ctx_value v; + struct lttng_kernel_ctx_field *ctx_field; + const struct lttng_kernel_event_field *field; + struct lttng_ctx_value v; ctx_field = <tng_static_ctx->fields[idx]; - field = &ctx_field->event_field; + field = ctx_field->event_field; ptr->type = LOAD_OBJECT; /* field is only used for types nested within variants. */ ptr->field = NULL; - switch (field->type.type) { + switch (field->type->type) { case lttng_kernel_type_integer: - ctx_field->get_value(ctx_field, lttng_probe_ctx, &v); - if (field->type.u.integer.signedness) { + 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; - case lttng_kernel_type_enum_nestable: + case lttng_kernel_type_enum: { - const struct lttng_integer_type *itype = - &field->type.u.enum_nestable.container_type->u.integer; + 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); - if (itype->signedness) { + 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; } - case lttng_kernel_type_array_nestable: - if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { + case lttng_kernel_type_array: + { + const struct lttng_kernel_type_array *array_type = lttng_kernel_get_type_array(field->type); + + if (!lttng_kernel_type_is_bytewise_integer(array_type->elem_type)) { 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) { + if (array_type->encoding == lttng_kernel_string_encoding_none) { printk(KERN_WARNING "LTTng: bytecode: Only string arrays are supported for contexts.\n"); 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_nestable: - if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { + } + case lttng_kernel_type_sequence: + { + const struct lttng_kernel_type_sequence *sequence_type = lttng_kernel_get_type_sequence(field->type); + + if (!lttng_kernel_type_is_bytewise_integer(sequence_type->elem_type)) { 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) { + if (sequence_type->encoding == lttng_kernel_string_encoding_none) { printk(KERN_WARNING "LTTng: bytecode: Only string sequences are supported for contexts.\n"); 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_nestable: + case lttng_kernel_type_struct: printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n"); return -EINVAL; - case lttng_kernel_type_variant_nestable: + case lttng_kernel_type_variant: printk(KERN_WARNING "LTTng: bytecode: Variant type cannot be loaded.\n"); return -EINVAL; default: - printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type.type); + printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type->type); return -EINVAL; } return 0; @@ -382,7 +385,7 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, stack_top->u.ptr.ptr = ptr; stack_top->u.ptr.object_type = gid->elem.type; stack_top->u.ptr.rev_bo = gid->elem.rev_bo; - BUG_ON(stack_top->u.ptr.field->type.type != lttng_kernel_type_array_nestable); + BUG_ON(stack_top->u.ptr.field->type->type != lttng_kernel_type_array); stack_top->u.ptr.field = NULL; break; } @@ -401,7 +404,7 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, stack_top->u.ptr.ptr = ptr; stack_top->u.ptr.object_type = gid->elem.type; stack_top->u.ptr.rev_bo = gid->elem.rev_bo; - BUG_ON(stack_top->u.ptr.field->type.type != lttng_kernel_type_sequence_nestable); + BUG_ON(stack_top->u.ptr.field->type->type != lttng_kernel_type_sequence); stack_top->u.ptr.field = NULL; break; } @@ -672,14 +675,14 @@ again: output->type = LTTNG_INTERPRETER_TYPE_SEQUENCE; output->u.sequence.ptr = *(const char **) (ax->u.ptr.ptr + sizeof(unsigned long)); output->u.sequence.nr_elem = *(unsigned long *) ax->u.ptr.ptr; - output->u.sequence.nested_type = ax->u.ptr.field->type.u.sequence_nestable.elem_type; + output->u.sequence.nested_type = lttng_kernel_get_type_sequence(ax->u.ptr.field->type)->elem_type; break; case OBJECT_TYPE_ARRAY: /* Skip count (unsigned long) */ output->type = LTTNG_INTERPRETER_TYPE_SEQUENCE; output->u.sequence.ptr = *(const char **) (ax->u.ptr.ptr + sizeof(unsigned long)); - output->u.sequence.nr_elem = ax->u.ptr.field->type.u.array_nestable.length; - output->u.sequence.nested_type = ax->u.ptr.field->type.u.array_nestable.elem_type; + output->u.sequence.nr_elem = lttng_kernel_get_type_array(ax->u.ptr.field->type)->length; + output->u.sequence.nested_type = lttng_kernel_get_type_array(ax->u.ptr.field->type)->elem_type; break; case OBJECT_TYPE_SIGNED_ENUM: ret = dynamic_load_field(ax); @@ -708,7 +711,7 @@ again: return -EINVAL; } - return LTTNG_INTERPRETER_RECORD_FLAG; + return 0; } #ifdef DEBUG @@ -745,17 +748,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, - struct lttng_probe_ctx *lttng_probe_ctx, +int lttng_bytecode_interpret(struct lttng_bytecode_runtime *kernel_bytecode, const char *interpreter_stack_data, - struct lttng_interpreter_output *output) + struct lttng_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; @@ -919,8 +925,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: @@ -929,7 +934,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; } @@ -943,6 +948,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): @@ -1476,15 +1487,15 @@ 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_ctx_field *ctx_field; - union lttng_ctx_value v; + struct lttng_kernel_ctx_field *ctx_field; + 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; @@ -1504,15 +1515,15 @@ 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_ctx_field *ctx_field; - union lttng_ctx_value v; + struct lttng_kernel_ctx_field *ctx_field; + 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); @@ -1802,34 +1813,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, lttng_probe_ctx, - filter_stack_data, 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, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *capture_stack_data, - 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_probe_ctx *probe_ctx, + void *event_filter_ctx __attribute__((unused))) { - return bytecode_interpret(capture_data, lttng_probe_ctx, - capture_stack_data, output); + struct lttng_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