X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-bytecode-specialize.c;h=936e342db786b86f1d5624eaa1a26b8add7f18b3;hb=refs%2Fheads%2Fmaster;hp=091879eae9cbdc15cf9905500863d2968fe52aed;hpb=28cbcb59855c099a89b02054b15b45ee3ad6a52a;p=lttng-modules.git diff --git a/src/lttng-bytecode-specialize.c b/src/lttng-bytecode-specialize.c index 091879ea..936e342d 100644 --- a/src/lttng-bytecode-specialize.c +++ b/src/lttng-bytecode-specialize.c @@ -8,8 +8,11 @@ */ #include +#include + #include #include +#include static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime, size_t align, size_t len) @@ -74,57 +77,68 @@ static int specialize_load_field(struct vstack_entry *stack_top, case OBJECT_TYPE_S8: dbg_printk("op load field s8\n"); stack_top->type = REG_S64; - if (!stack_top->load.rev_bo) + if (!stack_top->load.user) 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) insn->op = BYTECODE_OP_LOAD_FIELD_S64; break; case OBJECT_TYPE_SIGNED_ENUM: dbg_printk("op load field signed enumeration\n"); - stack_top->type = REG_PTR; + if (stack_top->load.user) { + printk(KERN_WARNING "LTTng: bytecode: user enum unsupported\n"); + ret = -EINVAL; + goto end; + } + stack_top->type = REG_S64; break; case OBJECT_TYPE_U8: dbg_printk("op load field u8\n"); stack_top->type = REG_S64; - insn->op = BYTECODE_OP_LOAD_FIELD_U8; + if (!stack_top->load.user) + 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) 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) + if (!stack_top->load.rev_bo && !stack_top->load.user) insn->op = BYTECODE_OP_LOAD_FIELD_U64; break; case OBJECT_TYPE_UNSIGNED_ENUM: dbg_printk("op load field unsigned enumeration\n"); - stack_top->type = REG_PTR; + if (stack_top->load.user) { + printk(KERN_WARNING "LTTng: bytecode: user enum unsupported\n"); + ret = -EINVAL; + goto end; + } + stack_top->type = REG_U64; break; case OBJECT_TYPE_DOUBLE: printk(KERN_WARNING "LTTng: bytecode: Double type unsupported\n\n"); @@ -133,12 +147,14 @@ static int specialize_load_field(struct vstack_entry *stack_top, case OBJECT_TYPE_STRING: dbg_printk("op load field string\n"); stack_top->type = REG_STRING; - insn->op = BYTECODE_OP_LOAD_FIELD_STRING; + if (!stack_top->load.user) + 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 = BYTECODE_OP_LOAD_FIELD_SEQUENCE; + if (!stack_top->load.user) + insn->op = BYTECODE_OP_LOAD_FIELD_SEQUENCE; break; case OBJECT_TYPE_DYNAMIC: ret = -EINVAL; @@ -206,18 +222,20 @@ static int specialize_get_index(struct bytecode_runtime *runtime, switch (stack_top->load.object_type) { case OBJECT_TYPE_ARRAY: { - const struct lttng_integer_type *integer_type; - const struct lttng_event_field *field; + const struct lttng_kernel_event_field *field; + const struct lttng_kernel_type_array *array_type; + const struct lttng_kernel_type_integer *integer_type; uint32_t elem_len, num_elems; int signedness; field = stack_top->load.field; - if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { + array_type = lttng_kernel_get_type_array(field->type); + if (!lttng_kernel_type_is_bytewise_integer(array_type->elem_type)) { ret = -EINVAL; goto end; } - integer_type = &field->type.u.array_nestable.elem_type->u.integer; - num_elems = field->type.u.array_nestable.length; + integer_type = lttng_kernel_get_type_integer(array_type->elem_type); + num_elems = array_type->length; elem_len = integer_type->size; signedness = integer_type->signedness; if (index >= num_elems) { @@ -232,24 +250,25 @@ static int specialize_get_index(struct bytecode_runtime *runtime, gid.array_len = num_elems * (elem_len / CHAR_BIT); gid.elem.type = stack_top->load.object_type; gid.elem.len = elem_len; - if (integer_type->reverse_byte_order) - gid.elem.rev_bo = true; - stack_top->load.rev_bo = gid.elem.rev_bo; + stack_top->load.rev_bo = gid.elem.rev_bo = integer_type->reverse_byte_order; + stack_top->load.user = gid.elem.user = integer_type->user; break; } case OBJECT_TYPE_SEQUENCE: { - const struct lttng_integer_type *integer_type; - const struct lttng_event_field *field; + const struct lttng_kernel_event_field *field; + const struct lttng_kernel_type_sequence *sequence_type; + const struct lttng_kernel_type_integer *integer_type; uint32_t elem_len; int signedness; field = stack_top->load.field; - if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { + sequence_type = lttng_kernel_get_type_sequence(field->type); + if (!lttng_kernel_type_is_bytewise_integer(sequence_type->elem_type)) { ret = -EINVAL; goto end; } - integer_type = &field->type.u.sequence_nestable.elem_type->u.integer; + integer_type = lttng_kernel_get_type_integer(sequence_type->elem_type); elem_len = integer_type->size; signedness = integer_type->signedness; ret = specialize_get_index_object_type(&stack_top->load.object_type, @@ -259,14 +278,14 @@ static int specialize_get_index(struct bytecode_runtime *runtime, gid.offset = index * (elem_len / CHAR_BIT); gid.elem.type = stack_top->load.object_type; gid.elem.len = elem_len; - if (integer_type->reverse_byte_order) - gid.elem.rev_bo = true; - stack_top->load.rev_bo = gid.elem.rev_bo; + stack_top->load.rev_bo = gid.elem.rev_bo = integer_type->reverse_byte_order; + stack_top->load.user = gid.elem.user = integer_type->user; break; } case OBJECT_TYPE_STRUCT: /* Only generated by the specialize phase. */ - case OBJECT_TYPE_VARIANT: /* Fall-through */ + case OBJECT_TYPE_VARIANT: + lttng_fallthrough; default: printk(KERN_WARNING "LTTng: bytecode: Unexpected get index type %d", (int) stack_top->load.object_type); @@ -305,7 +324,7 @@ end: return ret; } -static int specialize_context_lookup_name(struct lttng_ctx *ctx, +static int specialize_context_lookup_name(struct lttng_kernel_ctx *ctx, struct bytecode_runtime *bytecode, struct load_op *insn) { @@ -314,90 +333,117 @@ static int specialize_context_lookup_name(struct lttng_ctx *ctx, offset = ((struct get_symbol *) insn->data)->offset; name = bytecode->p.bc->bc.data + bytecode->p.bc->bc.reloc_offset + offset; - return lttng_get_context_index(ctx, name); + return lttng_kernel_get_context_index(ctx, name); } -static int specialize_load_object(const struct lttng_event_field *field, +static int specialize_load_object(const struct lttng_kernel_event_field *field, struct vstack_load *load, bool is_context) { load->type = LOAD_OBJECT; - switch (field->type.type) { + switch (field->type->type) { case lttng_kernel_type_integer: - if (field->type.u.integer.signedness) + { + const struct lttng_kernel_type_integer *integer_type = lttng_kernel_get_type_integer(field->type); + + if (integer_type->signedness) load->object_type = OBJECT_TYPE_S64; else load->object_type = OBJECT_TYPE_U64; - load->rev_bo = false; + load->rev_bo = integer_type->reverse_byte_order; + load->user = integer_type->user; 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); - if (itype->signedness) + if (integer_type->signedness) load->object_type = OBJECT_TYPE_SIGNED_ENUM; else load->object_type = OBJECT_TYPE_UNSIGNED_ENUM; - load->rev_bo = false; + load->rev_bo = integer_type->reverse_byte_order; + load->user = integer_type->user; 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); + const struct lttng_kernel_type_integer *integer_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; } + integer_type = lttng_kernel_get_type_integer(array_type->elem_type); if (is_context) { load->object_type = OBJECT_TYPE_STRING; + load->user = integer_type->user; } else { - if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_kernel_string_encoding_none) { + if (array_type->encoding == lttng_kernel_string_encoding_none) { load->object_type = OBJECT_TYPE_ARRAY; load->field = field; } else { load->object_type = OBJECT_TYPE_STRING_SEQUENCE; + load->user = integer_type->user; } } 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); + const struct lttng_kernel_type_integer *integer_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; } + integer_type = lttng_kernel_get_type_integer(sequence_type->elem_type); if (is_context) { load->object_type = OBJECT_TYPE_STRING; + load->user = integer_type->user; } else { - if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_kernel_string_encoding_none) { + if (sequence_type->encoding == lttng_kernel_string_encoding_none) { load->object_type = OBJECT_TYPE_SEQUENCE; load->field = field; } else { load->object_type = OBJECT_TYPE_STRING_SEQUENCE; + load->user = integer_type->user; } } break; + } case lttng_kernel_type_string: + { + const struct lttng_kernel_type_string *string_type = lttng_kernel_get_type_string(field->type); + load->object_type = OBJECT_TYPE_STRING; + load->user = string_type->user; 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; } -static int specialize_context_lookup(struct lttng_ctx *ctx, +static int specialize_context_lookup(struct lttng_kernel_ctx *ctx, struct bytecode_runtime *runtime, struct load_op *insn, struct vstack_load *load) { int idx, ret; - struct lttng_ctx_field *ctx_field; - struct lttng_event_field *field; + const struct lttng_kernel_ctx_field *ctx_field; + const struct lttng_kernel_event_field *field; struct bytecode_get_index_data gid; ssize_t data_offset; @@ -406,7 +452,7 @@ static int specialize_context_lookup(struct lttng_ctx *ctx, return -ENOENT; } ctx_field = <tng_static_ctx->fields[idx]; - field = &ctx_field->event_field; + field = ctx_field->event_field; ret = specialize_load_object(field, load, true); if (ret) return ret; @@ -416,6 +462,7 @@ static int specialize_context_lookup(struct lttng_ctx *ctx, gid.ctx_index = idx; gid.elem.type = load->object_type; gid.elem.rev_bo = load->rev_bo; + gid.elem.user = load->user; gid.field = field; data_offset = bytecode_push_data(runtime, &gid, __alignof__(gid), sizeof(gid)); @@ -426,7 +473,7 @@ static int specialize_context_lookup(struct lttng_ctx *ctx, return 0; } -static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, +static int specialize_payload_lookup(const struct lttng_kernel_event_desc *event_desc, struct bytecode_runtime *runtime, struct load_op *insn, struct vstack_load *load) @@ -436,16 +483,16 @@ static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, unsigned int i, nr_fields; bool found = false; uint32_t field_offset = 0; - const struct lttng_event_field *field; + const struct lttng_kernel_event_field *field; int ret; struct bytecode_get_index_data gid; ssize_t data_offset; - nr_fields = event_desc->nr_fields; + nr_fields = event_desc->tp_class->nr_fields; offset = ((struct get_symbol *) insn->data)->offset; name = runtime->p.bc->bc.data + runtime->p.bc->bc.reloc_offset + offset; for (i = 0; i < nr_fields; i++) { - field = &event_desc->fields[i]; + field = event_desc->tp_class->fields[i]; if (field->nofilter) { continue; } @@ -454,13 +501,13 @@ static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, break; } /* compute field offset on stack */ - switch (field->type.type) { + switch (field->type->type) { case lttng_kernel_type_integer: - case lttng_kernel_type_enum_nestable: + case lttng_kernel_type_enum: field_offset += sizeof(int64_t); break; - case lttng_kernel_type_array_nestable: - case lttng_kernel_type_sequence_nestable: + case lttng_kernel_type_array: + case lttng_kernel_type_sequence: field_offset += sizeof(unsigned long); field_offset += sizeof(void *); break; @@ -487,6 +534,7 @@ static int specialize_payload_lookup(const struct lttng_event_desc *event_desc, gid.offset = field_offset; gid.elem.type = load->object_type; gid.elem.rev_bo = load->rev_bo; + gid.elem.user = load->user; gid.field = field; data_offset = bytecode_push_data(runtime, &gid, __alignof__(gid), sizeof(gid)); @@ -500,14 +548,14 @@ end: return ret; } -int lttng_bytecode_specialize(const struct lttng_event_desc *event_desc, +int lttng_bytecode_specialize(const struct lttng_kernel_event_desc *event_desc, struct bytecode_runtime *bytecode) { void *pc, *next_pc, *start_pc; int ret = -EINVAL; struct vstack _stack; struct vstack *stack = &_stack; - struct lttng_ctx *ctx = bytecode->p.ctx; + struct lttng_kernel_ctx *ctx = bytecode->p.ctx; vstack_init(stack);