X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-bytecode-interpreter.c;h=fcbfe0b133a4d44410b33e957dc347347c8236e8;hb=92bc1e2318d93c9072ae79d7fd6a7c5953cb739e;hp=950c0ba028fcc6ac619f27023ec9fb7dcf549d8f;hpb=80c2a69a8298768c9010052e6c3668914191b9e7;p=lttng-modules.git

diff --git a/src/lttng-bytecode-interpreter.c b/src/lttng-bytecode-interpreter.c
index 950c0ba0..fcbfe0b1 100644
--- a/src/lttng-bytecode-interpreter.c
+++ b/src/lttng-bytecode-interpreter.c
@@ -20,7 +20,7 @@
  * 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';
@@ -214,6 +214,14 @@ uint64_t lttng_bytecode_filter_interpret_false(void *filter_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)
+{
+	return LTTNG_INTERPRETER_DISCARD;
+}
+
 #ifdef INTERPRETER_USE_SWITCH
 
 /*
@@ -278,8 +286,8 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
 	/* field is only used for types nested within variants. */
 	ptr->field = NULL;
 
-	switch (field->type.atype) {
-	case atype_integer:
+	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) {
 			ptr->object_type = OBJECT_TYPE_S64;
@@ -291,29 +299,29 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
 			ptr->ptr = &ptr->u.u64;
 		}
 		break;
-	case atype_enum_nestable:
+	case lttng_kernel_type_enum_nestable:
 	{
 		const struct lttng_integer_type *itype =
 			&field->type.u.enum_nestable.container_type->u.integer;
 
 		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;
 		}
 		break;
 	}
-	case atype_array_nestable:
+	case lttng_kernel_type_array_nestable:
 		if (!lttng_is_bytewise_integer(field->type.u.array_nestable.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 (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_kernel_string_encoding_none) {
 			printk(KERN_WARNING "LTTng: bytecode: Only string arrays are supported for contexts.\n");
 			return -EINVAL;
 		}
@@ -321,12 +329,12 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
 		ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
 		ptr->ptr = v.str;
 		break;
-	case atype_sequence_nestable:
+	case lttng_kernel_type_sequence_nestable:
 		if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.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 (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_kernel_string_encoding_none) {
 			printk(KERN_WARNING "LTTng: bytecode: Only string sequences are supported for contexts.\n");
 			return -EINVAL;
 		}
@@ -334,19 +342,19 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx,
 		ctx_field->get_value(ctx_field, lttng_probe_ctx, &v);
 		ptr->ptr = v.str;
 		break;
-	case atype_string:
+	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;
 		break;
-	case atype_struct_nestable:
+	case lttng_kernel_type_struct_nestable:
 		printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n");
 		return -EINVAL;
-	case atype_variant_nestable:
+	case lttng_kernel_type_variant_nestable:
 		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.atype);
+		printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type.type);
 		return -EINVAL;
 	}
 	return 0;
@@ -374,7 +382,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.atype != atype_array_nestable);
+			BUG_ON(stack_top->u.ptr.field->type.type != lttng_kernel_type_array_nestable);
 			stack_top->u.ptr.field = NULL;
 			break;
 		}
@@ -393,7 +401,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.atype != atype_sequence_nestable);
+			BUG_ON(stack_top->u.ptr.field->type.type != lttng_kernel_type_sequence_nestable);
 			stack_top->u.ptr.field = NULL;
 			break;
 		}
@@ -496,6 +504,18 @@ static int dynamic_load_field(struct estack_entry *stack_top)
 		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;
@@ -537,6 +557,18 @@ static int dynamic_load_field(struct estack_entry *stack_top)
 		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;
@@ -649,6 +681,20 @@ again:
 			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:
@@ -665,6 +711,39 @@ again:
 	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
@@ -1458,7 +1537,7 @@ uint64_t bytecode_interpret(void *interpreter_data,
 			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;
@@ -1468,7 +1547,7 @@ uint64_t bytecode_interpret(void *interpreter_data,
 				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;
 		}
@@ -1486,7 +1565,7 @@ uint64_t bytecode_interpret(void *interpreter_data,
 			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;
@@ -1744,6 +1823,15 @@ uint64_t lttng_bytecode_filter_interpret(void *filter_data,
 			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