trace-cmd: Correctly handle arrays

[
 Taken from a perf patch.
 I got the OK from Ian Musie to include this under LGPL
]

Previously, perf was assuming that an array from an ftrace event was an
array of longs, which will not always be the case. Additionally,
long_size is not even being initialised, so it would fail to read the
data and would erroneously report that the array was filled with zeroes.

This patch adds two extra entries into the field structure - arraylen
and elementsize, so that the code can easily look them up instead of
assuming that the elements are long_size. The element size is currently
derived by the size of the entire array and the number of elements
within the array.

This problem can be demonstrated with:
perf record -e raw_syscalls:sys_enter -a sleep 0.1
perf trace

Without this patch, output similar to the following is produced:
 perf-4355  [004]  1871.504685: sys_enter: NR 319 (0, 0, 0, 0, 0, 0)
 perf-4355  [004]  1871.504723: sys_enter: NR 3 (0, 0, 0, 0, 0, 0)
 perf-4355  [004]  1871.504733: sys_enter: NR 204 (0, 0, 0, 0, 0, 0)

After applying this patch, the output looks like:
 perf-4355  [004]  1871.504685: sys_enter: NR 319 (10247ac0, ffffffff, 5, ffffffff, 0, 107a80d8)
 perf-4355  [004]  1871.504723: sys_enter: NR 3 (a, ffb6fcf0, 20, ffffffff, 0, 10112c20)
 perf-4355  [004]  1871.504733: sys_enter: NR 204 (a, 4, 800, 6, 0, 10112c20)

Signed-off-by: Ian Munsie <imunsie@au1.ibm.com>
LKML-Reference: <1273730632-21008-3-git-send-email-imunsie@au1.ibm.com>

[ Fixed array handling ]

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

2 files changed, 23 insertions, 4 deletions

diff --git a/parse-events.c b/parse-events.c
index 59596ae..9873ef0 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -1248,6 +1248,12 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                         field->flags |= FIELD_IS_ARRAY;
 
                         type = read_token(&token);
+
+                        if (type == EVENT_ITEM)
+                                field->arraylen = strtoul(token, NULL, 0);
+                        else
+                                field->arraylen = 0;
+
                         while (strcmp(token, "]") != 0) {
                                 if (last_type == EVENT_ITEM &&
                                     type == EVENT_ITEM)
@@ -1262,6 +1268,8 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                 if (len == 2)
                                         strcat(brackets, " ");
                                 strcat(brackets, token);
+                                /* We only care about the last token */
+                                field->arraylen = strtoul(token, NULL, 0);
                                 free_token(token);
                                 type = read_token(&token);
                                 if (type == EVENT_NONE) {
@@ -1367,6 +1375,14 @@ static int event_read_fields(struct event_format *event, struct format_field **f
 
                 free_token(token);
 
+                if (field->flags & FIELD_IS_ARRAY) {
+                        if (field->arraylen)
+                                field->elementsize = field->size / field->arraylen;
+                        else
+                                field->elementsize = event->pevent->long_size;
+                } else
+                        field->elementsize = field->size;
+
                 *fields = field;
                 fields = &field->next;
 
@@ -2889,13 +2905,13 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                                                 die("field %s not found", larg->field.name);
                                 }
                                 offset = larg->field.field->offset +
-                                        right * pevent->long_size;
+                                        right * larg->field.field->elementsize;
                                 break;
                         default:
                                 goto default_op; /* oops, all bets off */
                         }
                         val = pevent_read_number(pevent,
-                                                 data + offset, pevent->long_size);
+                                                 data + offset, larg->field.field->elementsize);
                         if (typearg)
                                 val = eval_type(val, typearg, 1);
                         break;
@@ -4269,6 +4285,9 @@ int pevent_parse_event(struct pevent *pevent,
 
         event->system = strdup(sys);
 
+        /* Add pevent to event so that it can be referenced */
+        event->pevent = pevent;
+
         ret = event_read_format(event);
         if (ret < 0) {
                 do_warning("failed to read event format for %s", event->name);
@@ -4282,8 +4301,6 @@ int pevent_parse_event(struct pevent *pevent,
         if (find_event_handle(pevent, event))
                 show_warning = 0;
 
-        /* Add pevent to event so that function list can be referenced */
-        event->pevent = pevent;
         ret = event_read_print(event);
         if (ret < 0) {
                 do_warning("failed to read event print fmt for %s",
diff --git a/parse-events.h b/parse-events.h
index 0c6a330..0283f57 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -118,6 +118,8 @@ struct format_field {
         char                    *name;
         int                     offset;
         int                     size;
+        unsigned int            arraylen;
+        unsigned int            elementsize;
         unsigned long           flags;
 };