perf: Convert perf tracing data into a tracing_data event

Bypasses the tracing_data perf header code and replaces it with
a synthesized event and processing function that accomplishes
the same thing, used when reading/writing perf data to/from a
pipe.

The tracing data is pretty large, and this patch doesn't attempt
to break it down into component events.  The tracing_data event
itself doesn't actually contain the tracing data, rather it
arranges for the event processing code to skip over it after
it's read, using the skip return value added to the event
processing loop in a previous patch.

Signed-off-by: Tom Zanussi <tzanussi@gmail.com>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Cc: fweisbec@gmail.com
Cc: rostedt@goodmis.org
Cc: k-keiichi@bx.jp.nec.com
Cc: acme@ghostprotocols.net
LKML-Reference: <1270184365-8281-8-git-send-email-tzanussi@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 45 insertions, 44 deletions

diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 7cd1193918c7..44889c9b5630 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -50,14 +50,37 @@ static int long_size;
 
 static unsigned long    page_size;
 
+static ssize_t calc_data_size;
+
+static int do_read(int fd, void *buf, int size)
+{
+        int rsize = size;
+
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret <= 0)
+                        return -1;
+
+                size -= ret;
+                buf += ret;
+        }
+
+        return rsize;
+}
+
 static int read_or_die(void *data, int size)
 {
         int r;
 
-        r = read(input_fd, data, size);
-        if (r != size)
+        r = do_read(input_fd, data, size);
+        if (r <= 0)
                 die("reading input file (size expected=%d received=%d)",
                     size, r);
+
+        if (calc_data_size)
+                calc_data_size += r;
+
         return r;
 }
 
@@ -82,56 +105,28 @@ static char *read_string(void)
         char buf[BUFSIZ];
         char *str = NULL;
         int size = 0;
-        int i;
         off_t r;
+        char c;
 
         for (;;) {
-                r = read(input_fd, buf, BUFSIZ);
+                r = read(input_fd, &c, 1);
                 if (r < 0)
                         die("reading input file");
 
                 if (!r)
                         die("no data");
 
-                for (i = 0; i < r; i++) {
-                        if (!buf[i])
-                                break;
-                }
-                if (i < r)
-                        break;
+                buf[size++] = c;
 
-                if (str) {
-                        size += BUFSIZ;
-                        str = realloc(str, size);
-                        if (!str)
-                                die("malloc of size %d", size);
-                        memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
-                } else {
-                        size = BUFSIZ;
-                        str = malloc_or_die(size);
-                        memcpy(str, buf, size);
-                }
+                if (!c)
+                        break;
         }
 
-        /* trailing \0: */
-        i++;
-
-        /* move the file descriptor to the end of the string */
-        r = lseek(input_fd, -(r - i), SEEK_CUR);
-        if (r == (off_t)-1)
-                die("lseek");
-
-        if (str) {
-                size += i;
-                str = realloc(str, size);
-                if (!str)
-                        die("malloc of size %d", size);
-                memcpy(str + (size - i), buf, i);
-        } else {
-                size = i;
-                str = malloc_or_die(i);
-                memcpy(str, buf, i);
-        }
+        if (calc_data_size)
+                calc_data_size += size;
+
+        str = malloc_or_die(size);
+        memcpy(str, buf, size);
 
         return str;
 }
@@ -459,7 +454,7 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report(int fd)
+ssize_t trace_report(int fd)
 {
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
@@ -467,6 +462,9 @@ void trace_report(int fd)
         int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
+        ssize_t size;
+
+        calc_data_size = 1;
 
         input_fd = fd;
 
@@ -499,14 +497,17 @@ void trace_report(int fd)
         read_proc_kallsyms();
         read_ftrace_printk();
 
+        size = calc_data_size - 1;
+        calc_data_size = 0;
+
         if (show_funcs) {
                 print_funcs();
-                return;
+                return size;
         }
         if (show_printk) {
                 print_printk();
-                return;
+                return size;
         }
 
-        return;
+        return size;
 }