* to handle user-space read.
*/
static
-char get_char(struct estack_entry *reg, size_t offset)
+char get_char(const struct estack_entry *reg, size_t offset)
{
if (unlikely(offset >= reg->u.s.seq_len))
return '\0';
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)
+{
+ return LTTNG_INTERPRETER_DISCARD;
+}
+
#ifdef INTERPRETER_USE_SWITCH
/*
ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
if (itype->signedness) {
- ptr->object_type = OBJECT_TYPE_S64;
+ ptr->object_type = OBJECT_TYPE_SIGNED_ENUM;
ptr->u.s64 = v.s64;
ptr->ptr = &ptr->u.s64;
} else {
- ptr->object_type = OBJECT_TYPE_U64;
+ ptr->object_type = OBJECT_TYPE_UNSIGNED_ENUM;
ptr->u.u64 = v.s64; /* Cast. */
ptr->ptr = &ptr->u.u64;
}
stack_top->type = REG_S64;
break;
}
+ case OBJECT_TYPE_SIGNED_ENUM:
+ {
+ int64_t tmp;
+
+ dbg_printk("op load field signed enumeration\n");
+ tmp = *(int64_t *) stack_top->u.ptr.ptr;
+ 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;
stack_top->type = REG_U64;
break;
}
+ case OBJECT_TYPE_UNSIGNED_ENUM:
+ {
+ uint64_t tmp;
+
+ dbg_printk("op load field unsigned enumeration\n");
+ tmp = *(uint64_t *) stack_top->u.ptr.ptr;
+ if (stack_top->u.ptr.rev_bo)
+ __swab64s(&tmp);
+ stack_top->u.v = tmp;
+ stack_top->type = REG_U64;
+ break;
+ }
case OBJECT_TYPE_STRING:
{
const char *str;
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;
break;
+ case OBJECT_TYPE_SIGNED_ENUM:
+ ret = dynamic_load_field(ax);
+ if (ret)
+ return ret;
+ output->type = LTTNG_INTERPRETER_TYPE_SIGNED_ENUM;
+ output->u.s = ax->u.v;
+ break;
+ case OBJECT_TYPE_UNSIGNED_ENUM:
+ ret = dynamic_load_field(ax);
+ if (ret)
+ return ret;
+ output->type = LTTNG_INTERPRETER_TYPE_UNSIGNED_ENUM;
+ output->u.u = ax->u.v;
+ break;
case OBJECT_TYPE_STRUCT:
case OBJECT_TYPE_VARIANT:
default:
return LTTNG_INTERPRETER_RECORD_FLAG;
}
+#ifdef DEBUG
+
+#define DBG_USER_STR_CUTOFF 32
+
+/*
+ * In debug mode, print user string (truncated, if necessary).
+ */
+static inline
+void dbg_load_ref_user_str_printk(const struct estack_entry *user_str_reg)
+{
+ size_t pos = 0;
+ char last_char;
+ char user_str[DBG_USER_STR_CUTOFF];
+
+ pagefault_disable();
+ do {
+ last_char = get_char(user_str_reg, pos);
+ user_str[pos] = last_char;
+ pos++;
+ } while (last_char != '\0' && pos < sizeof(user_str));
+ pagefault_enable();
+
+ user_str[sizeof(user_str) - 1] = '\0';
+ dbg_printk("load field ref user string: '%s%s'\n", user_str,
+ last_char != '\0' ? "[...]" : "");
+}
+#else
+static inline
+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
estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.user_str =
*(const char * const *) &interpreter_stack_data[ref->offset];
- if (unlikely(!estack_ax(stack, top)->u.s.str)) {
+ if (unlikely(!estack_ax(stack, top)->u.s.user_str)) {
dbg_printk("Bytecode warning: loading a NULL string.\n");
ret = -EINVAL;
goto end;
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);
+ dbg_load_ref_user_str_printk(estack_ax(stack, top));
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
}
estack_ax(stack, top)->u.s.user_str =
*(const char **) (&interpreter_stack_data[ref->offset
+ sizeof(unsigned long)]);
- if (unlikely(!estack_ax(stack, top)->u.s.str)) {
+ if (unlikely(!estack_ax(stack, top)->u.s.user_str)) {
dbg_printk("Bytecode warning: loading a NULL sequence.\n");
ret = -EINVAL;
goto end;
filter_stack_data, NULL);
}
+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 bytecode_interpret(capture_data, lttng_probe_ctx,
+ capture_stack_data, output);
+}
+
#undef START_OP
#undef OP
#undef PO