parse header_page from tracing/events directory

Parse out the header_page from the tracing/events directory to
get the page header offsets and sizes. We can also use the "commit"
field to get the long size of the kernel, incase the kernel
and the userspace have different word sizes.

Signed-off-by: Steven Rostedt <srostedt@redhat.com>

3 files changed, 85 insertions, 1 deletions

diff --git a/parse-events.c b/parse-events.c
index 81957cf..c5cf3b4 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -29,6 +29,13 @@
 
 #include "parse-events.h"
 
+int header_page_ts_offset;
+int header_page_ts_size;
+int header_page_size_offset;
+int header_page_size_size;
+int header_page_data_offset;
+int header_page_data_size;
+
 static char *input_buf;
 static unsigned long long input_buf_ptr;
 static unsigned long long input_buf_siz;
@@ -2413,6 +2420,64 @@ void print_args(struct print_arg *args)
         }
 }
 
+static void parse_header_field(char *type,
+                               int *offset, int *size)
+{
+        char *token;
+
+        if (read_expected(EVENT_ITEM, "field") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+
+        /* type */
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        free_token(token);
+
+        if (read_expected(EVENT_ITEM, type) < 0)
+                return;
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, "offset") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        *offset = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, "size") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                return;
+        *size = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        if (read_expect_type(EVENT_NEWLINE, &token) < 0)
+                return;
+        free_token(token);
+}
+
+int parse_header_page(char *buf, unsigned long size)
+{
+        init_input_buf(buf, size);
+
+        parse_header_field("timestamp", &header_page_ts_offset,
+                           &header_page_ts_size);
+        parse_header_field("commit", &header_page_size_offset,
+                           &header_page_size_size);
+        parse_header_field("data", &header_page_data_offset,
+                           &header_page_data_size);
+
+        return 0;
+}
+
 int parse_ftrace_file(char *buf, unsigned long size)
 {
         struct format_field *field;
diff --git a/parse-events.h b/parse-events.h
index c11139d..d41abd5 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -222,4 +222,13 @@ static inline unsigned long long __data2host8(unsigned long long data)
 #define data2host4(ptr)         __data2host4(*(unsigned int *)ptr)
 #define data2host8(ptr)         __data2host8(*(unsigned long long *)ptr)
 
+extern int header_page_ts_offset;
+extern int header_page_ts_size;
+extern int header_page_size_offset;
+extern int header_page_size_size;
+extern int header_page_data_offset;
+extern int header_page_data_size;
+
+int parse_header_page(char *buf, unsigned long size);
+
 #endif /* _PARSE_EVENTS_H */
diff --git a/trace-read.c b/trace-read.c
index 91054b8..7b3824c 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -162,8 +162,15 @@ static void read_header_files(void)
         size = read8();
         header_page = malloc_or_die(size);
         read_or_die(header_page, size);
+        parse_header_page(header_page, size);
         free(header_page);
 
+        /*
+         * The size field in the page is of type long,
+         * use that instead, since it represents the kernel.
+         */
+        long_size = header_page_size_size;
+
         read_or_die(buf, 13);
         if (memcmp(buf, "header_event", 13) != 0)
                 die("did not read header event");
@@ -377,9 +384,11 @@ struct record *peak_data(int cpu)
 
         if (!index) {
                 /* FIXME: handle header page */
+                if (header_page_ts_size != 8)
+                        die("expected a long long type for timestamp");
                 cpu_data[cpu].timestamp = data2host8(ptr);
                 ptr += 8;
-                switch (long_size) {
+                switch (header_page_size_size) {
                 case 4:
                         cpu_data[cpu].page_size = data2host4(ptr);
                         ptr += 4;
@@ -391,6 +400,7 @@ struct record *peak_data(int cpu)
                 default:
                         die("bad long size");
                 }
+                ptr = cpu_data[cpu].page + header_page_data_offset;
         }
 
 read_again: