Move cpu_data into tracecmd_handle structure

Make the cpu_data part of the tracecmd handle.

Also did some more clean ups in returns.

Added the libparsevent hack for trace_read_data to handle the
function graph output.

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

3 files changed, 89 insertions, 65 deletions

diff --git a/trace-cmd.h b/trace-cmd.h
index 162cd66..e9e3b1e 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -39,5 +39,8 @@ int tracecmd_init_data(struct tracecmd_handle *handle);
 struct record *
 tracecmd_peek_data(struct tracecmd_handle *handle, int cpu);
 
+struct record *
+tracecmd_read_data(struct tracecmd_handle *handle, int cpu);
+
 
 #endif /* _TRACE_CMD_H */
diff --git a/trace-input.c b/trace-input.c
index 7e9d4c6..99d24e4 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -18,15 +18,6 @@
 
 #include "trace-cmd.h"
 
-struct tracecmd_handle {
-        int             fd;
-        int             long_size;
-        int             page_size;
-        int             print_events;
-        int             read_page;
-        int             cpus;
-};
-
 struct cpu_data {
         unsigned long long      offset;
         unsigned long long      size;
@@ -38,7 +29,16 @@ struct cpu_data {
         int                     page_size;
 };
 
-static struct cpu_data *cpu_data;
+struct tracecmd_handle {
+        int             fd;
+        int             long_size;
+        int             page_size;
+        int             print_events;
+        int             read_page;
+        int             cpus;
+        struct cpu_data *cpu_data;
+};
+
 
 static int do_read(struct tracecmd_handle *handle, void *data, int size)
 {
@@ -437,17 +437,18 @@ static unsigned int ts4host(unsigned int type_len_ts)
                 return type_len_ts >> 5;
 }
 
-static int calc_index(void *ptr, int cpu)
+static int calc_index(struct tracecmd_handle *handle,
+                      void *ptr, int cpu)
 {
-        return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
+        return (unsigned long)ptr - (unsigned long)handle->cpu_data[cpu].page;
 }
 
 static void
 update_cpu_data_index(struct tracecmd_handle *handle, int cpu)
 {
-        cpu_data[cpu].offset += handle->page_size;
-        cpu_data[cpu].size -= handle->page_size;
-        cpu_data[cpu].index = 0;
+        handle->cpu_data[cpu].offset += handle->page_size;
+        handle->cpu_data[cpu].size -= handle->page_size;
+        handle->cpu_data[cpu].index = 0;
 }
 
 static void get_next_page(struct tracecmd_handle *handle, int cpu)
@@ -455,13 +456,13 @@ static void get_next_page(struct tracecmd_handle *handle, int cpu)
         off64_t save_seek;
         off64_t ret;
 
-        if (!cpu_data[cpu].page)
+        if (!handle->cpu_data[cpu].page)
                 return;
 
         if (handle->read_page) {
-                if (cpu_data[cpu].size <= handle->page_size) {
-                        free(cpu_data[cpu].page);
-                        cpu_data[cpu].page = NULL;
+                if (handle->cpu_data[cpu].size <= handle->page_size) {
+                        free(handle->cpu_data[cpu].page);
+                        handle->cpu_data[cpu].page = NULL;
                         return;
                 }
 
@@ -470,10 +471,10 @@ static void get_next_page(struct tracecmd_handle *handle, int cpu)
                 /* other parts of the code may expect the pointer to not move */
                 save_seek = lseek64(input_fd, 0, SEEK_CUR);
 
-                ret = lseek64(handle->fd, cpu_data[cpu].offset, SEEK_SET);
+                ret = lseek64(handle->fd, handle->cpu_data[cpu].offset, SEEK_SET);
                 if (ret < 0)
                         die("failed to lseek");
-                ret = read(handle->fd, cpu_data[cpu].page, handle->page_size);
+                ret = read(handle->fd, handle->cpu_data[cpu].page, handle->page_size);
                 if (ret < 0)
                         die("failed to read page");
 
@@ -483,19 +484,19 @@ static void get_next_page(struct tracecmd_handle *handle, int cpu)
                 return;
         }
 
-        munmap(cpu_data[cpu].page, handle->page_size);
-        cpu_data[cpu].page = NULL;
+        munmap(handle->cpu_data[cpu].page, handle->page_size);
+        handle->cpu_data[cpu].page = NULL;
 
-        if (cpu_data[cpu].size <= handle->page_size)
+        if (handle->cpu_data[cpu].size <= handle->page_size)
                 return;
 
         update_cpu_data_index(handle, cpu);
         
-        cpu_data[cpu].page = mmap(NULL, handle->page_size, PROT_READ, MAP_PRIVATE,
-                                  input_fd, cpu_data[cpu].offset);
-        if (cpu_data[cpu].page == MAP_FAILED)
+        handle->cpu_data[cpu].page = mmap(NULL, handle->page_size, PROT_READ, MAP_PRIVATE,
+                                  input_fd, handle->cpu_data[cpu].offset);
+        if (handle->cpu_data[cpu].page == MAP_FAILED)
                 die("failed to mmap cpu %d at offset 0x%llx",
-                    cpu, cpu_data[cpu].offset);
+                    cpu, handle->cpu_data[cpu].offset);
 }
 
 enum old_ring_buffer_type {
@@ -533,7 +534,7 @@ read_old_format(struct tracecmd_handle *handle, void **ptr, int cpu)
                 extend = data2host4(ptr);
                 extend <<= TS_SHIFT;
                 extend += delta;
-                cpu_data[cpu].timestamp += extend;
+                handle->cpu_data[cpu].timestamp += extend;
                 *ptr += 4;
                 return NULL;
 
@@ -551,19 +552,19 @@ read_old_format(struct tracecmd_handle *handle, void **ptr, int cpu)
                 break;
         }
 
-        cpu_data[cpu].timestamp += delta;
+        handle->cpu_data[cpu].timestamp += delta;
 
         data = malloc_or_die(sizeof(*data));
         memset(data, 0, sizeof(*data));
 
-        data->ts = cpu_data[cpu].timestamp;
+        data->ts = handle->cpu_data[cpu].timestamp;
         data->size = length;
         data->data = *ptr;
 
         *ptr += ((length+3)/4) * 4;
 
-        cpu_data[cpu].index = calc_index(*ptr, cpu);
-        cpu_data[cpu].next = data;
+        handle->cpu_data[cpu].index = calc_index(handle, *ptr, cpu);
+        handle->cpu_data[cpu].next = data;
 
         return data;
 }
@@ -572,8 +573,8 @@ struct record *
 tracecmd_peek_data(struct tracecmd_handle *handle, int cpu)
 {
         struct record *data;
-        void *page = cpu_data[cpu].page;
-        int index = cpu_data[cpu].index;
+        void *page = handle->cpu_data[cpu].page;
+        int index = handle->cpu_data[cpu].index;
         void *ptr = page + index;
         unsigned long long extend;
         unsigned int type_len_ts;
@@ -581,8 +582,8 @@ tracecmd_peek_data(struct tracecmd_handle *handle, int cpu)
         unsigned int delta;
         unsigned int length;
 
-        if (cpu_data[cpu].next)
-                return cpu_data[cpu].next;
+        if (handle->cpu_data[cpu].next)
+                return handle->cpu_data[cpu].next;
 
         if (!page)
                 return NULL;
@@ -591,27 +592,27 @@ tracecmd_peek_data(struct tracecmd_handle *handle, int cpu)
                 /* FIXME: handle header page */
                 if (header_page_ts_size != 8)
                         die("expected a long long type for timestamp");
-                cpu_data[cpu].timestamp = data2host8(ptr);
+                handle->cpu_data[cpu].timestamp = data2host8(ptr);
                 ptr += 8;
                 switch (header_page_size_size) {
                 case 4:
-                        cpu_data[cpu].page_size = data2host4(ptr);
+                        handle->cpu_data[cpu].page_size = data2host4(ptr);
                         ptr += 4;
                         break;
                 case 8:
-                        cpu_data[cpu].page_size = data2host8(ptr);
+                        handle->cpu_data[cpu].page_size = data2host8(ptr);
                         ptr += 8;
                         break;
                 default:
                         die("bad long size");
                 }
-                ptr = cpu_data[cpu].page + header_page_data_offset;
+                ptr = handle->cpu_data[cpu].page + header_page_data_offset;
         }
 
 read_again:
-        index = calc_index(ptr, cpu);
+        index = calc_index(handle, ptr, cpu);
 
-        if (index >= cpu_data[cpu].page_size) {
+        if (index >= handle->cpu_data[cpu].page_size) {
                 get_next_page(handle, cpu);
                 return trace_peek_data(cpu);
         }
@@ -648,7 +649,7 @@ read_again:
                 ptr += 4;
                 extend <<= TS_SHIFT;
                 extend += delta;
-                cpu_data[cpu].timestamp += extend;
+                handle->cpu_data[cpu].timestamp += extend;
                 goto read_again;
 
         case RINGBUF_TYPE_TIME_STAMP:
@@ -664,28 +665,29 @@ read_again:
                 break;
         }
 
-        cpu_data[cpu].timestamp += delta;
+        handle->cpu_data[cpu].timestamp += delta;
 
         data = malloc_or_die(sizeof(*data));
         memset(data, 0, sizeof(*data));
 
-        data->ts = cpu_data[cpu].timestamp;
+        data->ts = handle->cpu_data[cpu].timestamp;
         data->size = length;
         data->data = ptr;
         ptr += length;
 
-        cpu_data[cpu].index = calc_index(ptr, cpu);
-        cpu_data[cpu].next = data;
+        handle->cpu_data[cpu].index = calc_index(handle, ptr, cpu);
+        handle->cpu_data[cpu].next = data;
 
         return data;
 }
 
-struct record *trace_read_data(int cpu)
+struct record *
+tracecmd_read_data(struct tracecmd_handle *handle, int cpu)
 {
         struct record *data;
 
         data = trace_peek_data(cpu);
-        cpu_data[cpu].next = NULL;
+        handle->cpu_data[cpu].next = NULL;
 
         return data;
 }
@@ -695,15 +697,15 @@ static void init_read(struct tracecmd_handle *handle, int cpu)
         off64_t ret;
         off64_t save_seek;
 
-        cpu_data[cpu].page = malloc_or_die(handle->page_size);
+        handle->cpu_data[cpu].page = malloc_or_die(handle->page_size);
 
         /* other parts of the code may expect the pointer to not move */
         save_seek = lseek64(input_fd, 0, SEEK_CUR);
 
-        ret = lseek64(input_fd, (off64_t)cpu_data[cpu].offset, SEEK_SET);
+        ret = lseek64(input_fd, (off64_t)handle->cpu_data[cpu].offset, SEEK_SET);
         if (ret < 0)
                 die("failed to lseek");
-        ret = read(input_fd, cpu_data[cpu].page, handle->page_size);
+        ret = read(input_fd, handle->cpu_data[cpu].page, handle->page_size);
         if (ret < 0)
                 die("failed to read page");
 
@@ -713,7 +715,7 @@ static void init_read(struct tracecmd_handle *handle, int cpu)
 
 static void init_cpu(struct tracecmd_handle *handle, int cpu)
 {
-        if (!cpu_data[cpu].size) {
+        if (!handle->cpu_data[cpu].size) {
                 printf("CPU %d is empty\n", cpu);
                 return;
         }
@@ -723,9 +725,9 @@ static void init_cpu(struct tracecmd_handle *handle, int cpu)
                 return;
         }
 
-        cpu_data[cpu].page = mmap(NULL, handle->page_size, PROT_READ,
-                                  MAP_PRIVATE, input_fd, cpu_data[cpu].offset);
-        if (cpu_data[cpu].page == MAP_FAILED) {
+        handle->cpu_data[cpu].page = mmap(NULL, handle->page_size, PROT_READ,
+                                  MAP_PRIVATE, input_fd, handle->cpu_data[cpu].offset);
+        if (handle->cpu_data[cpu].page == MAP_FAILED) {
                 /* fall back to just reading pages */
                 fprintf(stderr, "Can not mmap file, will read instead\n");
                 handle->read_page = 1;
@@ -742,29 +744,41 @@ int tracecmd_init_data(struct tracecmd_handle *handle)
         int cpu;
 
         size = read8(handle);
-        cmdlines = malloc_or_die(size);
-        do_read_check(handle, cmdlines, size);
+        if (size < 0)
+                return -1;
+        cmdlines = malloc(size);
+        if (!cmdlines)
+                return -1;
+        if (do_read_check(handle, cmdlines, size)) {
+                free(cmdlines);
+                return -1;
+        }
         parse_cmdlines(cmdlines, size);
         free(cmdlines);
 
         handle->cpus = read4(handle);
+        if (handle->cpus < 0)
+                return -1;
 
         parse_set_info(handle->cpus, handle->long_size);
 
         /*
          * Check if this is a latency report or not.
          */
-        do_read_check(handle, buf, 10);
+        if (do_read_check(handle, buf, 10))
+                return -1;
         if (strncmp(buf, "latency", 7) == 0)
                 return 1;
 
-        cpu_data = malloc_or_die(sizeof(*cpu_data) * handle->cpus);
-        memset(cpu_data, 0, sizeof(*cpu_data) * handle->cpus);
+        handle->cpu_data = malloc(sizeof(*handle->cpu_data) * handle->cpus);
+        if (!handle->cpu_data)
+                return -1;
+        memset(handle->cpu_data, 0, sizeof(*handle->cpu_data) * handle->cpus);
 
         for (cpu = 0; cpu < handle->cpus; cpu++) {
-                cpu_data[cpu].cpu = cpu;
-                cpu_data[cpu].offset = read8(handle);
-                cpu_data[cpu].size = read8(handle);
+                handle->cpu_data[cpu].cpu = cpu;
+                handle->cpu_data[cpu].offset = read8(handle);
+                handle->cpu_data[cpu].size = read8(handle);
 
                 init_cpu(handle, cpu);
         }
diff --git a/trace-read.c b/trace-read.c
index aab17d2..1c30f46 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -55,6 +55,13 @@ struct record *trace_peek_data(int cpu)
         return tracecmd_peek_data(trace_handle, cpu);
 }
 
+struct record *trace_read_data(int cpu)
+{
+        /* work around for libparsevent */
+
+        return tracecmd_read_data(trace_handle, cpu);
+}
+
 static void show_data(int cpu)
 {
         struct record *record;