Skip to contentSkip to conversation

Add array printing helper to ftrace

PATCH In review Javi Merino 2 participants 11 messages Jan 29, 2015 – Jul 13, 2015

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

v5 cover Add array printing helper to ftrace

This series add a helper to the tracing framework to trace arrays. Patch 1 add the helper and patches 2 and 3 update the traceevent library to parse them. They've been tested with trace-cmd.

Changes since v4[0]:
- Specify the element size in __print_array() as bytes instead of bits

Changes since v3:
- use %zu to print size_t

Changes since v2:
- Changed BUG() into a trace_seq_printf()
- Add BUILD_BUG_ON() to chase mistakes in element sizes on build
- Add patch 2 to avoid repeating code in patch 3.
- print a warning in traeevent if the size of the array is not valid

[0] http://thread.gmane.org/gmane.linux.kernel/1874250

Dave Martin (1):
tracing: Add array printing helper

Javi Merino (2):
tools lib traceevent: factor out allocating and processing args tools lib traceevent: Add support for __print_array()

 include/linux/ftrace_event.h       |   4 +
 include/trace/ftrace.h             |   9 +++
 kernel/trace/trace_output.c        |  44 +++++++++++
 tools/lib/traceevent/event-parse.c | 158 +++++++++++++++++++++++++++++--------
 tools/lib/traceevent/event-parse.h |   8 ++
 5 files changed, 192 insertions(+), 31 deletions(-)
Signature · 1 line
1.9.1
#1 lore raw

PATCH v5 1/3 tracing: Add array printing helper

From: Dave Martin <[email protected]>

If a trace event contains an array, there is currently no standard way to format this for text output. Drivers are currently hacking around this by a) local hacks that use the trace_seq functionailty directly, or b) just not printing that information. For fixed size arrays, formatting of the elements can be open-coded, but this gets cumbersome for arrays of non-trivial size.

These approaches result in non-standard content of the event format description delivered to userspace, so userland tools needs to be taught to understand and parse each array printing method individually.

This patch implements a __print_array() helper that tracepoint implementations can use instead of reinventing it. A simple C-style syntax is used to delimit the array and its elements {like,this}.

So that the helpers can be used with large static arrays as well as dynamic arrays, they take a pointer and element count: they can be used with __get_dynamic_array() for use with dynamic arrays.

---
 include/linux/ftrace_event.h |  4 ++++
 include/trace/ftrace.h       |  9 +++++++++
 kernel/trace/trace_output.c  | 44 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+)
include/linux/ftrace_event.h +4 -0
index 0bebb5c348b8..5aa4a9269547 100644
@@ -44,6 +44,10 @@ const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
 const char *ftrace_print_hex_seq(struct trace_seq *p,
 				 const unsigned char *buf, int len);
 
+const char *ftrace_print_array_seq(struct trace_seq *p,
+				   const void *buf, int buf_len,
+				   size_t el_size);
+
 struct trace_iterator;
 struct trace_event;
 
include/trace/ftrace.h +9 -0
index 139b5067345b..304901fc5f34 100644
@@ -263,6 +263,14 @@
 #undef __print_hex
 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
 
+#undef __print_array
+#define __print_array(array, count, el_size)				\
+	({								\
+		BUILD_BUG_ON(el_size != 1 && el_size != 2 &&		\
+			     el_size != 4 && el_size != 8);		\
+		ftrace_print_array_seq(p, array, count, el_size);	\
+	})
+
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\
 static notrace enum print_line_t					\
@@ -674,6 +682,7 @@ static inline void ftrace_test_probe_##call(void)			\
 #undef __get_dynamic_array_len
 #undef __get_str
 #undef __get_bitmask
+#undef __print_array
 
 #undef TP_printk
 #define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)
kernel/trace/trace_output.c +44 -0

50 lines not on this page · raw message

Signature · 1 line
1.9.1
#2 lore raw

PATCH v5 2/3 tools lib traceevent: factor out allocating and processing args

In reply to Javi Merino

The sequence of allocating the print_arg field, calling process_arg() and verifying that the next event delimiter is repeated twice in process_hex() and will also be used for process_int_array(). Factor it out to a function to avoid writing the same code again and again.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
---
 tools/lib/traceevent/event-parse.c | 77 ++++++++++++++++++++------------------
 1 file changed, 40 insertions(+), 37 deletions(-)
tools/lib/traceevent/event-parse.c +40 -37
index cf3a44bf1ec3..dabd8f5c6398 100644
@@ -2013,6 +2013,38 @@ process_entry(struct event_format *event __maybe_unused, struct print_arg *arg,
 	return EVENT_ERROR;
 }
 
+static int alloc_and_process_arg(struct event_format *event, char *next_token,
+				 struct print_arg **print_arg)
+{
+	struct print_arg *field;
+	enum event_type type;
+	char *token;
+	int ret = 0;
+
+	field = alloc_arg();
+	if (!field) {
+		do_warning_event(event, "%s: not enough memory!", __func__);
+		errno = ENOMEM;
+		return -1;
+	}
+
+	type = process_arg(event, field, &token);
+
+	if (test_type_token(type, token, EVENT_DELIM, next_token)) {
+		errno = EINVAL;
+		ret = -1;
+		free_arg(field);
+		goto out_free_token;
+	}
+
+	*print_arg = field;
+
+out_free_token:
+	free_token(token);
+
+	return ret;
+}
+
 static char *arg_eval (struct print_arg *arg);
 
 static unsigned long long
@@ -2485,49 +2517,20 @@ out_free:
 static enum event_type
 process_hex(struct event_format *event, struct print_arg *arg, char **tok)
 {
-	struct print_arg *field;
-	enum event_type type;
-	char *token = NULL;
-
 	memset(arg, 0, sizeof(*arg));
 	arg->type = PRINT_HEX;
 
-	field = alloc_arg();
-	if (!field) {
-		do_warning_event(event, "%s: not enough memory!", __func__);
-		goto out_free;
-	}
-
-	type = process_arg(event, field, &token);
-
-	if (test_type_token(type, token, EVENT_DELIM, ","))
-		goto out_free;
-
-	arg->hex.field = field;
-
-	free_token(token);
-
-	field = alloc_arg();
-	if (!field) {
-		do_warning_event(event, "%s: not enough memory!", __func__);
-		*tok = NULL;
-		return EVENT_ERROR;
-	}
-
-	type = process_arg(event, field, &token);
-
-	if (test_type_token(type, token, EVENT_DELIM, ")"))
-		goto out_free;
+	if (alloc_and_process_arg(event, ",", &arg->hex.field))
+		goto out;
 
-	arg->hex.size = field;
+	if (alloc_and_process_arg(event, ")", &arg->hex.size))
+		goto free_field;
 
-	free_token(token);
-	type = read_token_item(tok);
-	return type;
+	return read_token_item(tok);
 
- out_free:
-	free_arg(field);
-	free_token(token);
+free_field:
+	free_arg(arg->hex.field);
+out:
 	*tok = NULL;
 	return EVENT_ERROR;
 }
Signature · 1 line
1.9.1
#3 lore raw

PATCH v5 3/3 tools lib traceevent: Add support for __print_array()

In reply to Javi Merino

Trace can now generate traces with variable element size arrays. Add support to parse them.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
---
 tools/lib/traceevent/event-parse.c | 93 ++++++++++++++++++++++++++++++++++++++
 tools/lib/traceevent/event-parse.h |  8 ++++
 2 files changed, 101 insertions(+)
tools/lib/traceevent/event-parse.c +93 -0
index dabd8f5c6398..ab5a4998d54b 100644
@@ -757,6 +757,11 @@ static void free_arg(struct print_arg *arg)
 		free_arg(arg->hex.field);
 		free_arg(arg->hex.size);
 		break;
+	case PRINT_INT_ARRAY:
+		free_arg(arg->int_array.field);
+		free_arg(arg->int_array.size);
+		free_arg(arg->int_array.el_size);
+		break;
 	case PRINT_TYPE:
 		free(arg->typecast.type);
 		free_arg(arg->typecast.item);
@@ -2536,6 +2541,32 @@ out:
 }
 
 static enum event_type
+process_int_array(struct event_format *event, struct print_arg *arg, char **tok)
+{
+	memset(arg, 0, sizeof(*arg));
+	arg->type = PRINT_INT_ARRAY;
+
+	if (alloc_and_process_arg(event, ",", &arg->int_array.field))
+		goto out;
+
+	if (alloc_and_process_arg(event, ",", &arg->int_array.size))
+		goto free_field;
+
+	if (alloc_and_process_arg(event, ")", &arg->int_array.el_size))
+		goto free_size;
+
+	return read_token_item(tok);
+
+free_size:
+	free_arg(arg->int_array.size);
+free_field:
+	free_arg(arg->int_array.field);
+out:
+	*tok = NULL;
+	return EVENT_ERROR;
+}
+
+static enum event_type
 process_dynamic_array(struct event_format *event, struct print_arg *arg, char **tok)
 {
 	struct format_field *field;
@@ -2830,6 +2861,10 @@ process_function(struct event_format *event, struct print_arg *arg,
 		free_token(token);
 		return process_hex(event, arg, tok);
 	}
+	if (strcmp(token, "__print_array") == 0) {
+		free_token(token);
+		return process_int_array(event, arg, tok);
+	}
 	if (strcmp(token, "__get_str") == 0) {
 		free_token(token);
 		return process_str(event, arg, tok);
@@ -3358,6 +3393,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
 		break;
 	case PRINT_FLAGS:
 	case PRINT_SYMBOL:
+	case PRINT_INT_ARRAY:
 	case PRINT_HEX:
 		break;
 	case PRINT_TYPE:
@@ -3768,6 +3804,54 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
 		}
 		break;
 
+	case PRINT_INT_ARRAY: {
+		void *num;
+		int el_size;
+
+		if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
+			unsigned long offset;
+			struct format_field *field =
+				arg->int_array.field->dynarray.field;
+			offset = pevent_read_number(pevent,
+						    data + field->offset,
+						    field->size);
+			num = data + (offset & 0xffff);
+		} else {
+			field = arg->int_array.field->field.field;
+			if (!field) {
+				str = arg->int_array.field->field.name;
+				field = pevent_find_any_field(event, str);
+				if (!field)
+					goto out_warning_field;
+				arg->int_array.field->field.field = field;
+			}
+			num = data + field->offset;
+		}
+		len = eval_num_arg(data, size, event, arg->int_array.size);
+		el_size = eval_num_arg(data, size, event,
+				       arg->int_array.el_size);
+		for (i = 0; i < len; i++) {
+			if (i)
+				trace_seq_putc(s, ' ');
+
+			if (el_size == 1) {
+				trace_seq_printf(s, "%u", *(uint8_t *)num);
+			} else if (el_size == 2) {
+				trace_seq_printf(s, "%u", *(uint16_t *)num);
+			} else if (el_size == 4) {
+				trace_seq_printf(s, "%u", *(uint32_t *)num);
+			} else if (el_size == 8) {
+				trace_seq_printf(s, "%llu", *(uint64_t *)num);
+			} else {
+				trace_seq_printf(s, "BAD SIZE:%d 0x%x",
+						 el_size, *(uint8_t *)num);
+				el_size = 1;
+			}
+
+			num += el_size;
+		}
+		break;
+	}
 	case PRINT_TYPE:
 		break;
 	case PRINT_STRING: {
@@ -4931,6 +5015,15 @@ static void print_args(struct print_arg *args)
 		print_args(args->hex.size);
 		printf(")");
 		break;
+	case PRINT_INT_ARRAY:
+		printf("__print_array(");
+		print_args(args->int_array.field);
+		printf(", ");
+		print_args(args->int_array.size);
+		printf(", ");
+		print_args(args->int_array.el_size);
+		printf(")");
+		break;
 	case PRINT_STRING:
 	case PRINT_BSTRING:
 		printf("__get_str(%s)", args->string.string);
tools/lib/traceevent/event-parse.h +8 -0
index 7a3873ff9a4f..5ac3e3c00389 100644
@@ -245,6 +245,12 @@ struct print_arg_hex {
 	struct print_arg	*size;
 };
 
+struct print_arg_int_array {
+	struct print_arg	*field;
+	struct print_arg	*size;
+	struct print_arg	*el_size;
+};
+
 struct print_arg_dynarray {
 	struct format_field	*field;
 	struct print_arg	*index;
@@ -273,6 +279,7 @@ enum print_arg_type {
 	PRINT_FLAGS,
 	PRINT_SYMBOL,
 	PRINT_HEX,
+	PRINT_INT_ARRAY,
 	PRINT_TYPE,
 	PRINT_STRING,
 	PRINT_BSTRING,
@@ -292,6 +299,7 @@ struct print_arg {
 		struct print_arg_flags		flags;
 		struct print_arg_symbol		symbol;
 		struct print_arg_hex		hex;
+		struct print_arg_int_array	int_array;
 		struct print_arg_func		func;
 		struct print_arg_string		string;
 		struct print_arg_bitmask	bitmask;
Signature · 1 line
1.9.1
#4 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

Hi Steve,

Quoted 8 lines · Javi Merino

Trace can now generate traces with variable element size arrays. Add support to parse them.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
Quoted 4 lines
---
 tools/lib/traceevent/event-parse.c | 93 ++++++++++++++++++++++++++++++++++++++
 tools/lib/traceevent/event-parse.h |  8 ++++
 2 files changed, 101 insertions(+)

I've seen that patch 1 of this series is now in mainline. What about patches 2 and 3 (the updates to tools/lib/traceevent)? Shall I resend them?

These two patches should also be applied to trace-cmd. Do you want me to send patches for that to linux-kernel or will you take care of applying them there?

Incidentally, why are there two copies of libtraceevent? Shouldn't this live only in one place (either kernel or trace-cmd)?

Cheers,
Javi

maintainer
#5 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

Quoted 16 lines · On Fri, 27 Feb 2015 12:32:32 +0000 Javi Merino <[email protected]> wrote:

Hi Steve,

Quoted 8 lines · Javi Merino

Trace can now generate traces with variable element size arrays. Add support to parse them.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
Quoted 4 lines
---
 tools/lib/traceevent/event-parse.c | 93 ++++++++++++++++++++++++++++++++++++++
 tools/lib/traceevent/event-parse.h |  8 ++++
 2 files changed, 101 insertions(+)
Quoted 3 lines

I've seen that patch 1 of this series is now in mainline. What about patches 2 and 3 (the updates to tools/lib/traceevent)? Shall I resend them?

Patches 2 and 3 are in tools/lib and need to go through Jiri and Arnaldo. Please repost them again. I can give them acks.

Quoted 4 lines

These two patches should also be applied to trace-cmd. Do you want me to send patches for that to linux-kernel or will you take care of applying them there?

No need, I can pull them from here. I just been a bit busy to do so.

Quoted 3 lines

Incidentally, why are there two copies of libtraceevent? Shouldn't this live only in one place (either kernel or trace-cmd)?

Actually, libtraceevent does not exist in trace-cmd, just the event parsing code. libtraceevent needs to be packaged up and supplied as a library. That's on our todo list, but never seems to get done :-/

Until libtraceevent is provided by all distros, there will continue to be duplicate code. And it's not just with these two tools. I can think of two other tools that also share this code for parsing. It really does need to get packaged up.

-- Steve

#6 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

Quoted 19 lines · Steven Rostedt
Quoted 16 lines · On Fri, 27 Feb 2015 12:32:32 +0000 Javi Merino <[email protected]> wrote:

Hi Steve,

Quoted 12 lines · Javi Merino

Trace can now generate traces with variable element size arrays. Add support to parse them.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
---
 tools/lib/traceevent/event-parse.c | 93 ++++++++++++++++++++++++++++++++++++++
 tools/lib/traceevent/event-parse.h |  8 ++++
 2 files changed, 101 insertions(+)
Quoted 6 lines
Quoted 3 lines

I've seen that patch 1 of this series is now in mainline. What about patches 2 and 3 (the updates to tools/lib/traceevent)? Shall I resend them?

Patches 2 and 3 are in tools/lib and need to go through Jiri and Arnaldo. Please repost them again. I can give them acks.

Cool, done.

Quoted 5 lines
Quoted 3 lines

These two patches should also be applied to trace-cmd. Do you want me to send patches for that to linux-kernel or will you take care of applying them there?

No need, I can pull them from here. I just been a bit busy to do so.

No worries. I was just unsure about the process.

Quoted 6 lines
Quoted 3 lines

Incidentally, why are there two copies of libtraceevent? Shouldn't this live only in one place (either kernel or trace-cmd)?

Actually, libtraceevent does not exist in trace-cmd, just the event parsing code.

Right, that's what I meant. I was wondering about the duplicated code.

Thanks,
Javi

#7 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

In reply to Steven Rostedt

Hi Steve,

Quoted 24 lines · Steven Rostedt
Quoted 14 lines · On Fri, 27 Feb 2015 12:32:32 +0000 Javi Merino <[email protected]> wrote:
Quoted 8 lines · Javi Merino

Trace can now generate traces with variable element size arrays. Add support to parse them.

Cc Namhyung Kim <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Steven Rostedt <[email protected]>
Cc Jiri Olsa <[email protected]>
Quoted 4 lines
---
 tools/lib/traceevent/event-parse.c | 93 ++++++++++++++++++++++++++++++++++++++
 tools/lib/traceevent/event-parse.h |  8 ++++
 2 files changed, 101 insertions(+)
Quoted 3 lines

I've seen that patch 1 of this series is now in mainline. What about patches 2 and 3 (the updates to tools/lib/traceevent)? Shall I resend them?

Patches 2 and 3 are in tools/lib and need to go through Jiri and Arnaldo. Please repost them again. I can give them acks.

Quoted 1 line
Quoted 5 lines
Quoted 3 lines

These two patches should also be applied to trace-cmd. Do you want me to send patches for that to linux-kernel or will you take care of applying them there?

No need, I can pull them from here. I just been a bit busy to do so.

These two patches (b839e1e846ed ("tools lib traceevent: Add support for __print_array()") and 929a6bb71aa5 ("tools lib traceevent: Factor out allocating and processing args")) went in as of 4.1-rc1. Any estimate of when can we have a trace-cmd that have them?

Thanks,
Javi

maintainer
#8 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

Quoted 5 lines · On Thu, 4 Jun 2015 15:25:48 +0100 Javi Merino <[email protected]> wrote:

These two patches (b839e1e846ed ("tools lib traceevent: Add support for __print_array()") and 929a6bb71aa5 ("tools lib traceevent: Factor out allocating and processing args")) went in as of 4.1-rc1. Any estimate of when can we have a trace-cmd that have them?

I just came back from some time off, and I'm currently trying to catch up. I have a bunch of patches in trace-cmd right now that hasn't gone mainline yet.

I may push them to master, but not for the release yet. I'll try to get to them this week.

-- Steve

maintainer
#9 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

In reply to Javi Merino
Quoted 4 lines · On Thu, 4 Jun 2015 15:25:48 +0100 Javi Merino <[email protected]> wrote:

These two patches (b839e1e846ed ("tools lib traceevent: Add support for __print_array()") and 929a6bb71aa5 ("tools lib traceevent: Factor out allocating and processing args")) went in as of 4.1-rc1. Any estimate of when can we have a trace-cmd that have them?

I finally got around to syncing trace-cmd with lib/traceevent. I just pushed it out.

Thanks,

-- Steve

#10 lore raw

Re: [PATCH v5 3/3] tools lib traceevent: Add support for __print_array()

Quoted 11 lines · Steven Rostedt
Quoted 4 lines · On Thu, 4 Jun 2015 15:25:48 +0100 Javi Merino <[email protected]> wrote:

These two patches (b839e1e846ed ("tools lib traceevent: Add support for __print_array()") and 929a6bb71aa5 ("tools lib traceevent: Factor out allocating and processing args")) went in as of 4.1-rc1. Any estimate of when can we have a trace-cmd that have them?

I finally got around to syncing trace-cmd with lib/traceevent. I just pushed it out.

Good news, thank you!
Javi