This allows using parsing __print_hex_dump in user space tools. Print
format is aligned with debugfs tracing interface.
Signed-off-by: Piotr Maziarz <[email protected]>
Signed-off-by: Cezary Rojewski <[email protected]>
---
tools/lib/traceevent/event-parse.c | 123 +++++++++++++++++++++++++++++++++++++
tools/lib/traceevent/event-parse.h | 12 ++++
tools/lib/traceevent/trace-seq.c | 92 +++++++++++++++++++++++++++
tools/lib/traceevent/trace-seq.h | 3 +
4 files changed, 230 insertions(+)
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index d948475..b8f6686 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -898,6 +898,15 @@ static void free_arg(struct tep_print_arg *arg)
free_arg(arg->int_array.count);
free_arg(arg->int_array.el_size);
break;
+ case TEP_PRINT_HEX_DUMP:
+ free_arg(arg->hex_dump.prefix_str);
+ free_arg(arg->hex_dump.prefix_type);
+ free_arg(arg->hex_dump.rowsize);
+ free_arg(arg->hex_dump.groupsize);
+ free_arg(arg->hex_dump.buf);
+ free_arg(arg->hex_dump.len);
+ free_arg(arg->hex_dump.ascii);
+ break;
case TEP_PRINT_TYPE:
free(arg->typecast.type);
free_arg(arg->typecast.item);
@@ -2752,6 +2761,58 @@ process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok
}
static enum tep_event_type
+process_hex_dump(struct tep_event *event, struct tep_print_arg *arg, char **tok)
+{
+ memset(arg, 0, sizeof(*arg));
+ arg->type = TEP_PRINT_HEX_DUMP;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.prefix_str))
+ goto out;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.prefix_type))
+ goto free_prefix_str;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.rowsize))
+ goto free_prefix_type;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.groupsize))
+ goto free_rowsize;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.buf))
+ goto free_groupsize;
+
+ if (alloc_and_process_delim(event, ",", &arg->hex_dump.len))
+ goto free_buf;
+
+ if (alloc_and_process_delim(event, ")", &arg->hex_dump.ascii))
+ goto free_len;
+
+ return read_token_item(tok);
+
+free_len:
+ free_arg(arg->hex_dump.len);
+ arg->hex_dump.len = NULL;
+free_buf:
+ free_arg(arg->hex_dump.buf);
+ arg->hex_dump.buf = NULL;
+free_groupsize:
+ free_arg(arg->hex_dump.groupsize);
+ arg->hex_dump.groupsize = NULL;
+free_rowsize:
+ free_arg(arg->hex_dump.rowsize);
+ arg->hex_dump.rowsize = NULL;
+free_prefix_type:
+ free_arg(arg->hex_dump.prefix_type);
+ arg->hex_dump.prefix_type = NULL;
+free_prefix_str:
+ free_arg(arg->hex_dump.prefix_str);
+ arg->hex_dump.prefix_str = NULL;
+out:
+ *tok = NULL;
+ return TEP_EVENT_ERROR;
+}
+
+static enum tep_event_type
process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
{
struct tep_format_field *field;
@@ -3090,6 +3151,10 @@ process_function(struct tep_event *event, struct tep_print_arg *arg,
free_token(token);
return process_int_array(event, arg, tok);
}
+ if (strcmp(token, "__print_hex_dump") == 0) {
+ free_token(token);
+ return process_hex_dump(event, arg, tok);
+ }
if (strcmp(token, "__get_str") == 0) {
free_token(token);
return process_str(event, arg, tok);
@@ -3626,6 +3691,7 @@ eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg
case TEP_PRINT_FLAGS:
case TEP_PRINT_SYMBOL:
case TEP_PRINT_INT_ARRAY:
+ case TEP_PRINT_HEX_DUMP:
case TEP_PRINT_HEX:
case TEP_PRINT_HEX_STR:
break;
@@ -4124,6 +4190,46 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
}
break;
}
+ case TEP_PRINT_HEX_DUMP: {
+ void *buf;
+ char *prefix_str;
+ int prefix_type, rowsize, groupsize, ascii;
+
+ if (arg->hex_dump.buf->type == TEP_PRINT_DYNAMIC_ARRAY) {
+ unsigned long offset;
+
+ field = arg->hex_dump.buf->dynarray.field;
+ offset = tep_read_number(tep,
+ data + field->offset,
+ field->size);
+ buf = data + (offset & 0xffff);
+ } else {
+ field = arg->hex_dump.buf->field.field;
+ if (!field) {
+ str = arg->hex_dump.buf->field.name;
+ field = tep_find_any_field(event, str);
+ if (!field)
+ goto out_warning_field;
+ arg->hex_dump.buf->field.field = field;
+ }
+ buf = data + field->offset;
+ }
+ prefix_type = eval_num_arg(data, size, event,
+ arg->hex_dump.prefix_type);
+ rowsize = eval_num_arg(data, size, event,
+ arg->hex_dump.rowsize);
+ groupsize = eval_num_arg(data, size, event,
+ arg->hex_dump.groupsize);
+ len = eval_num_arg(data, size, event, arg->hex_dump.len);
+ ascii = eval_num_arg(data, size, event,
+ arg->hex_dump.ascii);
+ prefix_str = arg->hex_dump.prefix_str->atom.atom;
+
+ trace_seq_putc(s, '\n');
+ trace_seq_hex_dump(s, prefix_str, prefix_type,
+ rowsize, groupsize, buf, len, ascii);
+ break;
+ }
case TEP_PRINT_TYPE:
break;
case TEP_PRINT_STRING: {
@@ -5984,6 +6090,23 @@ static void print_args(struct tep_print_arg *args)
print_args(args->int_array.el_size);
printf(")");
break;
+ case TEP_PRINT_HEX_DUMP:
+ printf("__print_hex_dump(");
+ print_args(args->hex_dump.prefix_str);
+ printf(", ");
+ print_args(args->hex_dump.prefix_type);
+ printf(", ");
+ print_args(args->hex_dump.rowsize);
+ printf(", ");
+ print_args(args->hex_dump.groupsize);
+ printf(", ");
+ print_args(args->hex_dump.buf);
+ printf(", ");
+ print_args(args->hex_dump.len);
+ printf(", ");
+ print_args(args->hex_dump.ascii);
+ printf(")");
+ break;
case TEP_PRINT_STRING:
case TEP_PRINT_BSTRING:
printf("__get_str(%s)", args->string.string);
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index b77837f..9d4482f 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -213,6 +213,16 @@ struct tep_print_arg_int_array {
struct tep_print_arg *el_size;
};
+struct tep_print_arg_hex_dump {
+ struct tep_print_arg *prefix_str;
+ struct tep_print_arg *prefix_type;
+ struct tep_print_arg *rowsize;
+ struct tep_print_arg *groupsize;
+ struct tep_print_arg *buf;
+ struct tep_print_arg *len;
+ struct tep_print_arg *ascii;
+};
+
struct tep_print_arg_dynarray {
struct tep_format_field *field;
struct tep_print_arg *index;
@@ -242,6 +252,7 @@ enum tep_print_arg_type {
TEP_PRINT_SYMBOL,
TEP_PRINT_HEX,
TEP_PRINT_INT_ARRAY,
+ TEP_PRINT_HEX_DUMP,
TEP_PRINT_TYPE,
TEP_PRINT_STRING,
TEP_PRINT_BSTRING,
@@ -264,6 +275,7 @@ struct tep_print_arg {
struct tep_print_arg_symbol symbol;
struct tep_print_arg_hex hex;
struct tep_print_arg_int_array int_array;
+ struct tep_print_arg_hex_dump hex_dump;
struct tep_print_arg_func func;
struct tep_print_arg_string string;
struct tep_print_arg_bitmask bitmask;
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
index 8d5ecd2..05e5700 100644
--- a/tools/lib/traceevent/trace-seq.c
+++ b/tools/lib/traceevent/trace-seq.c
@@ -247,3 +247,95 @@ int trace_seq_do_printf(struct trace_seq *s)
{
return trace_seq_do_fprintf(s, stdout);
}
+
+enum {
+ DUMP_PREFIX_NONE,
+ DUMP_PREFIX_ADDRESS,
+ DUMP_PREFIX_OFFSET
+};
+
+int hex_dump_line(const unsigned char *buf, size_t len, int rowsize,
+ int groupsize, struct trace_seq *s, bool ascii)
+{
+ unsigned long long val;
+ int i, ret, pos = 0;
+ const char *format;
+ int ascii_pos = rowsize * 2 + rowsize / groupsize + 1;
+
+ len = min(len, (size_t)rowsize);
+ if ((groupsize != 2 && groupsize != 4 && groupsize != 8)
+ || (len % groupsize) != 0) {
+ groupsize = 1;
+ }
+
+ for (i = 0; i < len / groupsize; i++) {
+ if (groupsize == 8) {
+ const unsigned long long *ptr8 = (void *)buf;
+
+ val = *(ptr8 + i);
+ format = "%s%16.16llx";
+ } else if (groupsize == 4) {
+ const unsigned int *ptr4 = (void *)buf;
+
+ val = *(ptr4 + i);
+ format = "%s%8.8x";
+ } else if (groupsize == 2) {
+ const unsigned short *ptr2 = (void *)buf;
+
+ val = *(ptr2 + i);
+ format = "%s%4.4x";
+ } else {
+ const unsigned char *ptr1 = (void *)buf;
+
+ val = *(ptr1 + i);
+ format = "%s%2.2x";
+ }
+ ret = trace_seq_printf(s,
+ format, i ? " " : "",
+ val);
+ if (ret <= 0)
+ return ret;
+ pos += ret;
+ }
+ if (!ascii)
+ return 0;
+ ret = trace_seq_printf(s, "%*s", ascii_pos - pos, "");
+ if (ret <= 0)
+ return ret;
+ for (i = 0; i < len; i++)
+ trace_seq_putc(s, (isprint(buf[i])) ? buf[i] : '.');
+ return 0;
+}
+
+int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str,
+ int prefix_type, int rowsize, int groupsize,
+ const void *buf, size_t len, int ascii)
+{
+ const unsigned char *ptr = buf;
+ int i, linelen, remaining = len;
+ int ret;
+
+ if (rowsize != 16 && rowsize != 32)
+ rowsize = 16;
+
+ for (i = 0; i < len; i += rowsize) {
+ linelen = min(remaining, rowsize);
+ remaining -= linelen;
+
+ if (prefix_type == DUMP_PREFIX_ADDRESS)
+ ret = trace_seq_printf(s, "%s%p: ",
+ prefix_str, ptr + i);
+ else if (prefix_type == DUMP_PREFIX_OFFSET)
+ ret = trace_seq_printf(s, "%s%.8x: ",
+ prefix_str, i);
+ else
+ ret = trace_seq_printf(s, "%s",
+ prefix_str);
+ if (ret <= 0)
+ return ret;
+ hex_dump_line(ptr + i, linelen, rowsize, groupsize,
+ s, ascii);
+ trace_seq_putc(s, '\n');
+ }
+ return 0;
+}
diff --git a/tools/lib/traceevent/trace-seq.h b/tools/lib/traceevent/trace-seq.h
index d68ec69..7b7d72e 100644
--- a/tools/lib/traceevent/trace-seq.h
+++ b/tools/lib/traceevent/trace-seq.h
@@ -51,5 +51,8 @@ extern void trace_seq_terminate(struct trace_seq *s);
extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp);
extern int trace_seq_do_printf(struct trace_seq *s);
+extern int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str,
+ int prefix_type, int rowsize, int groupsize,
+ const void *buf, size_t len, int ascii);
#endif /* _TRACE_SEQ_H */
--
2.7.4
On Fri, Dec 06, 2019 at 10:00:51AM +0100, Piotr Maziarz wrote:
> This allows using parsing __print_hex_dump in user space tools. Print
> format is aligned with debugfs tracing interface.
> +int hex_dump_line(const unsigned char *buf, size_t len, int rowsize,
> + int groupsize, struct trace_seq *s, bool ascii)
> +{
> + unsigned long long val;
> + int i, ret, pos = 0;
> + const char *format;
> + int ascii_pos = rowsize * 2 + rowsize / groupsize + 1;
> +
> + len = min(len, (size_t)rowsize);
> + if ((groupsize != 2 && groupsize != 4 && groupsize != 8)
> + || (len % groupsize) != 0) {
Tools have an implemented is_power_of_2().
I guess you may go thru tools headers and check what else can be un-open-coded
here, in this change.
> + groupsize = 1;
> + }
> +
> + for (i = 0; i < len / groupsize; i++) {
> + if (groupsize == 8) {
> + const unsigned long long *ptr8 = (void *)buf;
> +
> + val = *(ptr8 + i);
> + format = "%s%16.16llx";
> + } else if (groupsize == 4) {
> + const unsigned int *ptr4 = (void *)buf;
> +
> + val = *(ptr4 + i);
> + format = "%s%8.8x";
> + } else if (groupsize == 2) {
> + const unsigned short *ptr2 = (void *)buf;
> +
> + val = *(ptr2 + i);
> + format = "%s%4.4x";
> + } else {
> + const unsigned char *ptr1 = (void *)buf;
> +
> + val = *(ptr1 + i);
> + format = "%s%2.2x";
> + }
> + ret = trace_seq_printf(s,
> + format, i ? " " : "",
> + val);
> + if (ret <= 0)
> + return ret;
> + pos += ret;
> + }
> + if (!ascii)
> + return 0;
> + ret = trace_seq_printf(s, "%*s", ascii_pos - pos, "");
> + if (ret <= 0)
> + return ret;
> + for (i = 0; i < len; i++)
> + trace_seq_putc(s, (isprint(buf[i])) ? buf[i] : '.');
> + return 0;
> +}
> +
> +int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str,
> + int prefix_type, int rowsize, int groupsize,
> + const void *buf, size_t len, int ascii)
> +{
> + const unsigned char *ptr = buf;
> + int i, linelen, remaining = len;
> + int ret;
> +
> + if (rowsize != 16 && rowsize != 32)
> + rowsize = 16;
> +
> + for (i = 0; i < len; i += rowsize) {
> + linelen = min(remaining, rowsize);
> + remaining -= linelen;
> +
> + if (prefix_type == DUMP_PREFIX_ADDRESS)
> + ret = trace_seq_printf(s, "%s%p: ",
> + prefix_str, ptr + i);
> + else if (prefix_type == DUMP_PREFIX_OFFSET)
> + ret = trace_seq_printf(s, "%s%.8x: ",
> + prefix_str, i);
> + else
> + ret = trace_seq_printf(s, "%s",
> + prefix_str);
> + if (ret <= 0)
> + return ret;
> + hex_dump_line(ptr + i, linelen, rowsize, groupsize,
> + s, ascii);
> + trace_seq_putc(s, '\n');
> + }
> + return 0;
> +}
--
With Best Regards,
Andy Shevchenko