fix: mm: move kvmalloc-related functions to slab.h (v5.16)

[lttng-modules.git] / src / lttng-bytecode-interpreter.c

diff --git a/src/lttng-bytecode-interpreter.c b/src/lttng-bytecode-interpreter.c
index 0161d673ccb6c45ed58ac799f5c7b0fcd2840f82..a2a932c65f2d488d1f119741801cdbf0ef3c2456 100644 (file)
--- a/src/lttng-bytecode-interpreter.c
+++ b/src/lttng-bytecode-interpreter.c
@@ -7,6 +7,7 @@
  * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  */
 
+#include <wrapper/compiler_attributes.h>
 #include <wrapper/uaccess.h>
 #include <wrapper/objtool.h>
 #include <wrapper/types.h>
@@ -209,9 +210,9 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type)
 }
 
 int lttng_bytecode_interpret_error(
-       struct lttng_bytecode_runtime *bytecode_runtime __attribute__((unused)),
+       struct lttng_kernel_bytecode_runtime *bytecode_runtime __attribute__((unused)),
        const char *stack_data __attribute__((unused)),
-       struct lttng_probe_ctx *probe_ctx __attribute__((unused)),
+       struct lttng_kernel_probe_ctx *probe_ctx __attribute__((unused)),
        void *ctx __attribute__((unused)))
 {
        return LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR;
@@ -266,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 = &lttng_static_ctx->fields[idx];
        field = ctx_field->event_field;
@@ -283,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;
@@ -299,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;
@@ -324,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:
@@ -341,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");
@@ -363,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)
 {
@@ -421,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,
@@ -756,9 +758,9 @@ void dbg_load_ref_user_str_printk(const struct estack_entry *user_str_reg)
  * For CAPTURE bytecode: expect a struct lttng_interpreter_output *
  * as @ctx argument.
  */
-int lttng_bytecode_interpret(struct lttng_bytecode_runtime *kernel_bytecode,
+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_kernel_probe_ctx *lttng_probe_ctx,
                void *caller_ctx)
 {
        struct bytecode_runtime *bytecode = container_of(kernel_bytecode, struct bytecode_runtime, p);
@@ -1488,14 +1490,14 @@ int lttng_bytecode_interpret(struct lttng_bytecode_runtime *kernel_bytecode,
                        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 = &lttng_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;
@@ -1516,14 +1518,14 @@ int lttng_bytecode_interpret(struct lttng_bytecode_runtime *kernel_bytecode,
                        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 = &lttng_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);
@@ -1849,10 +1851,10 @@ LTTNG_STACK_FRAME_NON_STANDARD(lttng_bytecode_interpret);
  */
 int lttng_kernel_interpret_event_filter(const struct lttng_kernel_event_common *event,
                const char *interpreter_stack_data,
-               struct lttng_probe_ctx *probe_ctx,
+               struct lttng_kernel_probe_ctx *probe_ctx,
                void *event_filter_ctx __attribute__((unused)))
 {
-       struct lttng_bytecode_runtime *filter_bc_runtime;
+       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;