The bytecode validator allows unknown type as input for some
instructions which are not specialized. The interpreter therefore needs
to check the register type for their input.
Thie requires that every instruction in the interpreter sets the
register type of the output it populates (unless it is unchanged).
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I3339c36340645937b801f6bf6dbf517d06416a14
#define estack_ax_v ax
#define estack_bx_v bx
#define estack_ax_v ax
#define estack_bx_v bx
+#define estack_ax_t ax_t
+#define estack_bx_t bx_t
+
#define estack_ax(stack, top) \
({ \
BUG_ON((top) <= FILTER_STACK_EMPTY); \
#define estack_ax(stack, top) \
({ \
BUG_ON((top) <= FILTER_STACK_EMPTY); \
&(stack)->e[(top) - 1]; \
})
&(stack)->e[(top) - 1]; \
})
-#define estack_push(stack, top, ax, bx) \
+#define estack_push(stack, top, ax, bx, ax_t, bx_t) \
do { \
BUG_ON((top) >= FILTER_STACK_LEN - 1); \
(stack)->e[(top) - 1].u.v = (bx); \
do { \
BUG_ON((top) >= FILTER_STACK_LEN - 1); \
(stack)->e[(top) - 1].u.v = (bx); \
+ (stack)->e[(top) - 1].type = (bx_t); \
-#define estack_pop(stack, top, ax, bx) \
+#define estack_pop(stack, top, ax, bx, ax_t, bx_t) \
do { \
BUG_ON((top) <= FILTER_STACK_EMPTY); \
(ax) = (bx); \
do { \
BUG_ON((top) <= FILTER_STACK_EMPTY); \
(ax) = (bx); \
(bx) = (stack)->e[(top) - 2].u.v; \
(bx) = (stack)->e[(top) - 2].u.v; \
+ (bx_t) = (stack)->e[(top) - 2].type; \
+#define IS_INTEGER_REGISTER(reg_type) (reg_type == REG_S64)
+
static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
struct load_ptr *ptr,
uint32_t idx)
static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
struct load_ptr *ptr,
uint32_t idx)
case OBJECT_TYPE_S8:
dbg_printk("op load field s8\n");
stack_top->u.v = *(int8_t *) stack_top->u.ptr.ptr;
case OBJECT_TYPE_S8:
dbg_printk("op load field s8\n");
stack_top->u.v = *(int8_t *) stack_top->u.ptr.ptr;
+ stack_top->type = REG_S64;
break;
case OBJECT_TYPE_S16:
{
break;
case OBJECT_TYPE_S16:
{
if (stack_top->u.ptr.rev_bo)
__swab16s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab16s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_S32:
break;
}
case OBJECT_TYPE_S32:
if (stack_top->u.ptr.rev_bo)
__swab32s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab32s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_S64:
break;
}
case OBJECT_TYPE_S64:
if (stack_top->u.ptr.rev_bo)
__swab64s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab64s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_U8:
dbg_printk("op load field u8\n");
stack_top->u.v = *(uint8_t *) stack_top->u.ptr.ptr;
break;
}
case OBJECT_TYPE_U8:
dbg_printk("op load field u8\n");
stack_top->u.v = *(uint8_t *) stack_top->u.ptr.ptr;
+ stack_top->type = REG_S64;
break;
case OBJECT_TYPE_U16:
{
break;
case OBJECT_TYPE_U16:
{
if (stack_top->u.ptr.rev_bo)
__swab16s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab16s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_U32:
break;
}
case OBJECT_TYPE_U32:
if (stack_top->u.ptr.rev_bo)
__swab32s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab32s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_U64:
break;
}
case OBJECT_TYPE_U64:
if (stack_top->u.ptr.rev_bo)
__swab64s(&tmp);
stack_top->u.v = tmp;
if (stack_top->u.ptr.rev_bo)
__swab64s(&tmp);
stack_top->u.v = tmp;
+ stack_top->type = REG_S64;
break;
}
case OBJECT_TYPE_STRING:
break;
}
case OBJECT_TYPE_STRING:
stack_top->u.s.seq_len = LTTNG_SIZE_MAX;
stack_top->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
stack_top->u.s.seq_len = LTTNG_SIZE_MAX;
stack_top->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
+ stack_top->type = REG_STRING;
break;
}
case OBJECT_TYPE_STRING_SEQUENCE:
break;
}
case OBJECT_TYPE_STRING_SEQUENCE:
}
stack_top->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
}
stack_top->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
+ stack_top->type = REG_STRING;
break;
}
case OBJECT_TYPE_DYNAMIC:
break;
}
case OBJECT_TYPE_DYNAMIC:
struct estack _stack;
struct estack *stack = &_stack;
register int64_t ax = 0, bx = 0;
struct estack _stack;
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;
#ifndef INTERPRETER_USE_SWITCH
static void *dispatch[NR_FILTER_OPS] = {
register int top = FILTER_STACK_EMPTY;
#ifndef INTERPRETER_USE_SWITCH
static void *dispatch[NR_FILTER_OPS] = {
OP(FILTER_OP_RETURN):
OP(FILTER_OP_RETURN_S64):
/* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
OP(FILTER_OP_RETURN):
OP(FILTER_OP_RETURN_S64):
/* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
- retval = !!estack_ax_v;
+ switch (estack_ax_t) {
+ case REG_S64:
+ retval = !!estack_ax_v;
+ break;
+ case REG_DOUBLE:
+ case REG_STRING:
+ case REG_PTR:
+ case REG_STAR_GLOB_STRING:
+ case REG_TYPE_UNKNOWN:
+ ret = -EINVAL;
+ goto end;
+ }
int res;
res = (stack_strcmp(stack, top, "==") == 0);
int res;
res = (stack_strcmp(stack, top, "==") == 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_strcmp(stack, top, "!=") != 0);
int res;
res = (stack_strcmp(stack, top, "!=") != 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_strcmp(stack, top, ">") > 0);
int res;
res = (stack_strcmp(stack, top, ">") > 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_strcmp(stack, top, "<") < 0);
int res;
res = (stack_strcmp(stack, top, "<") < 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_strcmp(stack, top, ">=") >= 0);
int res;
res = (stack_strcmp(stack, top, ">=") >= 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_strcmp(stack, top, "<=") <= 0);
int res;
res = (stack_strcmp(stack, top, "<=") <= 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_star_glob_match(stack, top, "==") == 0);
int res;
res = (stack_star_glob_match(stack, top, "==") == 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (stack_star_glob_match(stack, top, "!=") != 0);
int res;
res = (stack_star_glob_match(stack, top, "!=") != 0);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v == estack_ax_v);
int res;
res = (estack_bx_v == estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v != estack_ax_v);
int res;
res = (estack_bx_v != estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v > estack_ax_v);
int res;
res = (estack_bx_v > estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v < estack_ax_v);
int res;
res = (estack_bx_v < estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v >= estack_ax_v);
int res;
res = (estack_bx_v >= estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
int res;
res = (estack_bx_v <= estack_ax_v);
int res;
res = (estack_bx_v <= estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
+ if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+ ret = -EINVAL;
+ goto end;
+ }
+
/* Catch undefined behavior. */
if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
ret = -EINVAL;
goto end;
}
res = ((uint64_t) estack_bx_v >> (uint32_t) estack_ax_v);
/* Catch undefined behavior. */
if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
ret = -EINVAL;
goto end;
}
res = ((uint64_t) estack_bx_v >> (uint32_t) estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
+ if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+ ret = -EINVAL;
+ goto end;
+ }
+
/* Catch undefined behavior. */
if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
ret = -EINVAL;
goto end;
}
res = ((uint64_t) estack_bx_v << (uint32_t) estack_ax_v);
/* Catch undefined behavior. */
if (unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
ret = -EINVAL;
goto end;
}
res = ((uint64_t) estack_bx_v << (uint32_t) estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
+ if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+ ret = -EINVAL;
+ goto end;
+ }
+
res = ((uint64_t) estack_bx_v & (uint64_t) estack_ax_v);
res = ((uint64_t) estack_bx_v & (uint64_t) estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
+ if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+ ret = -EINVAL;
+ goto end;
+ }
+
res = ((uint64_t) estack_bx_v | (uint64_t) estack_ax_v);
res = ((uint64_t) estack_bx_v | (uint64_t) estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
+ if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
+ ret = -EINVAL;
+ goto end;
+ }
+
res = ((uint64_t) estack_bx_v ^ (uint64_t) estack_ax_v);
res = ((uint64_t) estack_bx_v ^ (uint64_t) estack_ax_v);
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct binary_op);
PO;
}
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_UNARY_BIT_NOT):
{
estack_ax_v = ~(uint64_t) estack_ax_v;
OP(FILTER_OP_UNARY_BIT_NOT):
{
estack_ax_v = ~(uint64_t) estack_ax_v;
next_pc += sizeof(struct unary_op);
PO;
}
next_pc += sizeof(struct unary_op);
PO;
}
OP(FILTER_OP_UNARY_MINUS_S64):
{
estack_ax_v = -estack_ax_v;
OP(FILTER_OP_UNARY_MINUS_S64):
{
estack_ax_v = -estack_ax_v;
next_pc += sizeof(struct unary_op);
PO;
}
next_pc += sizeof(struct unary_op);
PO;
}
OP(FILTER_OP_UNARY_NOT_S64):
{
estack_ax_v = !estack_ax_v;
OP(FILTER_OP_UNARY_NOT_S64):
{
estack_ax_v = !estack_ax_v;
next_pc += sizeof(struct unary_op);
PO;
}
next_pc += sizeof(struct unary_op);
PO;
}
next_pc = start_pc + insn->skip_offset;
} else {
/* Pop 1 when jump not taken */
next_pc = start_pc + insn->skip_offset;
} else {
/* Pop 1 when jump not taken */
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct logical_op);
}
PO;
next_pc += sizeof(struct logical_op);
}
PO;
next_pc = start_pc + insn->skip_offset;
} else {
/* Pop 1 when jump not taken */
next_pc = start_pc + insn->skip_offset;
} else {
/* Pop 1 when jump not taken */
- estack_pop(stack, top, ax, bx);
+ estack_pop(stack, top, ax, bx, ax_t, bx_t);
next_pc += sizeof(struct logical_op);
}
PO;
next_pc += sizeof(struct logical_op);
}
PO;
dbg_printk("load field ref offset %u type string\n",
ref->offset);
dbg_printk("load field ref offset %u type string\n",
ref->offset);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.str =
*(const char * const *) &filter_stack_data[ref->offset];
if (unlikely(!estack_ax(stack, top)->u.s.str)) {
estack_ax(stack, top)->u.s.str =
*(const char * const *) &filter_stack_data[ref->offset];
if (unlikely(!estack_ax(stack, top)->u.s.str)) {
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 0;
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 0;
+ estack_ax(stack, top)->type = REG_STRING;
dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
dbg_printk("load field ref offset %u type sequence\n",
ref->offset);
dbg_printk("load field ref offset %u type sequence\n",
ref->offset);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.seq_len =
*(unsigned long *) &filter_stack_data[ref->offset];
estack_ax(stack, top)->u.s.str =
estack_ax(stack, top)->u.s.seq_len =
*(unsigned long *) &filter_stack_data[ref->offset];
estack_ax(stack, top)->u.s.str =
dbg_printk("load field ref offset %u type s64\n",
ref->offset);
dbg_printk("load field ref offset %u type s64\n",
ref->offset);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v =
((struct literal_numeric *) &filter_stack_data[ref->offset])->v;
estack_ax_v =
((struct literal_numeric *) &filter_stack_data[ref->offset])->v;
dbg_printk("ref load s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
dbg_printk("ref load s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
struct load_op *insn = (struct load_op *) pc;
dbg_printk("load string %s\n", insn->data);
struct load_op *insn = (struct load_op *) pc;
dbg_printk("load string %s\n", insn->data);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.str = insn->data;
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
estack_ax(stack, top)->u.s.str = insn->data;
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
struct load_op *insn = (struct load_op *) pc;
dbg_printk("load globbing pattern %s\n", insn->data);
struct load_op *insn = (struct load_op *) pc;
dbg_printk("load globbing pattern %s\n", insn->data);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.str = insn->data;
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
estack_ax(stack, top)->u.s.str = insn->data;
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
{
struct load_op *insn = (struct load_op *) pc;
{
struct load_op *insn = (struct load_op *) pc;
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = ((struct literal_numeric *) insn->data)->v;
estack_ax_v = ((struct literal_numeric *) insn->data)->v;
dbg_printk("load s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op)
dbg_printk("load s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op)
ref->offset);
ctx_field = <tng_static_ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
ref->offset);
ctx_field = <tng_static_ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
- estack_push(stack, top, ax, bx);
+ 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");
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");
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 0;
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 0;
+ estack_ax(stack, top)->type = REG_STRING;
dbg_printk("ref get context string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
dbg_printk("ref get context string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
ref->offset);
ctx_field = <tng_static_ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
ref->offset);
ctx_field = <tng_static_ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
dbg_printk("ref get context s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
dbg_printk("ref get context s64 %lld\n",
(long long) estack_ax_v);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
dbg_printk("load field ref offset %u type user string\n",
ref->offset);
dbg_printk("load field ref offset %u type user string\n",
ref->offset);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.user_str =
*(const char * const *) &filter_stack_data[ref->offset];
if (unlikely(!estack_ax(stack, top)->u.s.str)) {
estack_ax(stack, top)->u.s.user_str =
*(const char * const *) &filter_stack_data[ref->offset];
if (unlikely(!estack_ax(stack, top)->u.s.str)) {
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 1;
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.user = 1;
+ estack_ax(stack, top)->type = REG_STRING;
dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
dbg_printk("ref load string %s\n", estack_ax(stack, top)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
dbg_printk("load field ref offset %u type user sequence\n",
ref->offset);
dbg_printk("load field ref offset %u type user sequence\n",
ref->offset);
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.seq_len =
*(unsigned long *) &filter_stack_data[ref->offset];
estack_ax(stack, top)->u.s.user_str =
estack_ax(stack, top)->u.s.seq_len =
*(unsigned long *) &filter_stack_data[ref->offset];
estack_ax(stack, top)->u.s.user_str =
OP(FILTER_OP_GET_CONTEXT_ROOT):
{
dbg_printk("op get context root\n");
OP(FILTER_OP_GET_CONTEXT_ROOT):
{
dbg_printk("op get context root\n");
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_CONTEXT;
/* "field" only needed for variants. */
estack_ax(stack, top)->u.ptr.field = NULL;
estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_CONTEXT;
/* "field" only needed for variants. */
estack_ax(stack, top)->u.ptr.field = NULL;
+ estack_ax(stack, top)->type = REG_PTR;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
OP(FILTER_OP_GET_PAYLOAD_ROOT):
{
dbg_printk("op get app payload root\n");
OP(FILTER_OP_GET_PAYLOAD_ROOT):
{
dbg_printk("op get app payload root\n");
- estack_push(stack, top, ax, bx);
+ estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_PAYLOAD;
estack_ax(stack, top)->u.ptr.ptr = filter_stack_data;
/* "field" only needed for variants. */
estack_ax(stack, top)->u.ptr.field = NULL;
estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_PAYLOAD;
estack_ax(stack, top)->u.ptr.ptr = filter_stack_data;
/* "field" only needed for variants. */
estack_ax(stack, top)->u.ptr.field = NULL;
+ estack_ax(stack, top)->type = REG_PTR;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
+ estack_ax_t = estack_ax(stack, top)->type;
next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
PO;
}
next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
PO;
}
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
+ estack_ax_t = estack_ax(stack, top)->type;
next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
PO;
}
next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
PO;
}
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
if (ret)
goto end;
estack_ax_v = estack_ax(stack, top)->u.v;
+ estack_ax_t = estack_ax(stack, top)->type;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field s8\n");
estack_ax_v = *(int8_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field s8\n");
estack_ax_v = *(int8_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field s16\n");
estack_ax_v = *(int16_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field s16\n");
estack_ax_v = *(int16_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field s32\n");
estack_ax_v = *(int32_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field s32\n");
estack_ax_v = *(int32_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field s64\n");
estack_ax_v = *(int64_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field s64\n");
estack_ax_v = *(int64_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field u8\n");
estack_ax_v = *(uint8_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field u8\n");
estack_ax_v = *(uint8_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field u16\n");
estack_ax_v = *(uint16_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field u16\n");
estack_ax_v = *(uint16_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field u32\n");
estack_ax_v = *(uint32_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field u32\n");
estack_ax_v = *(uint32_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
dbg_printk("op load field u64\n");
estack_ax_v = *(uint64_t *) estack_ax(stack, top)->u.ptr.ptr;
dbg_printk("op load field u64\n");
estack_ax_v = *(uint64_t *) estack_ax(stack, top)->u.ptr.ptr;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
estack_ax(stack, top)->u.s.seq_len = LTTNG_SIZE_MAX;
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
+ estack_ax(stack, top)->type = REG_STRING;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}
}
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
}
estack_ax(stack, top)->u.s.literal_type =
ESTACK_STRING_LITERAL_TYPE_NONE;
+ estack_ax(stack, top)->type = REG_STRING;
next_pc += sizeof(struct load_op);
PO;
}
next_pc += sizeof(struct load_op);
PO;
}