Convert libtracecmd to be more self sufficient

Convent the API to use the handler for tracecmd. Also convert
the read code to not die on error. A library should not kill the app.

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

5 files changed, 306 insertions, 113 deletions

diff --git a/parse-events.c b/parse-events.c
index d27e7f1..df8c614 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -37,6 +37,9 @@ int header_page_size_size;
 int header_page_data_offset;
 int header_page_data_size;
 
+int file_bigendian;
+int host_bigendian;
+
 int latency_format;
 
 int old_format;
diff --git a/trace-cmd.h b/trace-cmd.h
index 4e1d900..223e12f 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -6,17 +6,10 @@
 extern int input_fd;
 extern const char *input_file;
 
-extern unsigned int page_size;
-
 #ifndef PAGE_MASK
 #define PAGE_MASK (page_size - 1)
 #endif
 
-int read_trace_header(void);
-int read_trace_files(void);
-
-void trace_report(int argc, char **argv);
-
 void parse_cmdlines(char *file, int size);
 void parse_proc_kallsyms(char *file, unsigned int size);
 void parse_ftrace_printk(char *file, unsigned int size);
@@ -37,5 +30,7 @@ struct tracecmd_handle;
 
 struct tracecmd_handle *tracecmd_open(int fd);
 int tracecmd_read_headers(struct tracecmd_handle *handle);
+int tracecmd_long_size(struct tracecmd_handle *handle);
+int tracecmd_page_size(struct tracecmd_handle *handle);
 
 #endif /* _TRACE_CMD_H */
diff --git a/trace-input.c b/trace-input.c
index e2c089b..5f28214 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -18,28 +18,46 @@
 
 #include "trace-cmd.h"
 
-extern int show_events;
-
 struct tracecmd_handle {
         int             fd;
+        int             long_size;
+        int             page_size;
+        int             print_events;
 };
 
-int file_bigendian;
-int host_bigendian;
-int long_size;
-
-int read_or_die(void *data, int size)
+static int do_read(struct tracecmd_handle *handle, void *data, int size)
 {
+        int tot = 0;
         int r;
 
-        r = read(input_fd, data, size);
-        if (r != size)
-                die("reading input file (size expected=%d received=%d)",
-                    size, r);
-        return r;
+        do {
+                r = read(handle->fd, data, size);
+                tot += r;
+
+                if (!r)
+                        break;
+                if (r < 0)
+                        return r;
+        } while (tot != size);
+
+        return tot;
+}
+
+static int
+do_read_check(struct tracecmd_handle *handle, void *data, int size)
+{
+        int ret;
+
+        ret = do_read(handle, data, size);
+        if (ret < 0)
+                return ret;
+        if (ret != size)
+                return -1;
+
+        return 0;
 }
 
-static char *read_string(void)
+static char *read_string(struct tracecmd_handle *handle)
 {
         char buf[BUFSIZ];
         char *str = NULL;
@@ -48,12 +66,11 @@ static char *read_string(void)
         int r;
 
         for (;;) {
-                r = read(input_fd, buf, BUFSIZ);
+                r = do_read(handle, buf, BUFSIZ);
                 if (r < 0)
-                        die("reading input file");
-
+                        goto fail;
                 if (!r)
-                        die("no data");
+                        goto fail;
 
                 for (i = 0; i < r; i++) {
                         if (!buf[i])
@@ -66,185 +83,307 @@ static char *read_string(void)
                         size += BUFSIZ;
                         str = realloc(str, size);
                         if (!str)
-                                die("malloc of size %d", size);
+                                return NULL;
                         memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
                 } else {
                         size = BUFSIZ;
-                        str = malloc_or_die(size);
+                        str = malloc(size);
+                        if (!str)
+                                return NULL;
                         memcpy(str, buf, size); 
                 }
         }
 
         /* move the file descriptor to the end of the string */
-        r = lseek(input_fd, -(r - (i+1)), SEEK_CUR);
+        r = lseek(handle->fd, -(r - (i+1)), SEEK_CUR);
         if (r < 0)
-                die("lseek");
+                goto fail;
 
         if (str) {
                 size += i + 1;
                 str = realloc(str, size);
                 if (!str)
-                        die("malloc of size %d", size);
+                        return NULL;
                 memcpy(str + (size - i), buf, i);
                 str[size] = 0;
         } else {
                 size = i + 1;
-                str = malloc_or_die(i);
+                str = malloc(i);
+                if (!str)
+                        return NULL;
                 memcpy(str, buf, i);
                 str[i] = 0;
         }
 
         return str;
+
+ fail:
+        if (str)
+                free(str);
+        return NULL;
 }
 
-unsigned int read4(void)
+static unsigned int read4(struct tracecmd_handle *handle)
 {
         unsigned int data;
 
-        read_or_die(&data, 4);
+        if (do_read_check(handle, &data, 4))
+                return -1;
+
         return __data2host4(data);
 }
 
-unsigned long long read8(void)
+static unsigned long long read8(struct tracecmd_handle *handle)
 {
         unsigned long long data;
 
-        read_or_die(&data, 8);
+        if (do_read_check(handle, &data, 8))
+                return -1;
+
         return __data2host8(data);
 }
 
-static void read_header_files(void)
+static int read_header_files(struct tracecmd_handle *handle)
 {
-        unsigned long long size;
-        char *header_page;
-        char *header_event;
+        long long size;
+        char *header;
         char buf[BUFSIZ];
 
-        read_or_die(buf, 12);
+        if (do_read_check(handle, buf, 12))
+                return -1;
+
         if (memcmp(buf, "header_page", 12) != 0)
-                die("did not read header page");
+                return -1;
+
+        size = read8(handle);
+        if (size < 0)
+                return -1;
+
+        header = malloc(size);
+        if (!header)
+                return -1;
 
-        size = read8();
-        header_page = malloc_or_die(size);
-        read_or_die(header_page, size);
-        pevent_parse_header_page(header_page, size);
-        free(header_page);
+        if (do_read_check(handle, header, size))
+                goto failed_read;
+
+        pevent_parse_header_page(header, size);
+        free(header);
 
         /*
          * The size field in the page is of type long,
          * use that instead, since it represents the kernel.
          */
-        long_size = header_page_size_size;
+        handle->long_size = header_page_size_size;
+
+        if (do_read_check(handle, buf, 13))
+                return -1;
 
-        read_or_die(buf, 13);
         if (memcmp(buf, "header_event", 13) != 0)
-                die("did not read header event");
+                return -1;
+
+        size = read8(handle);
+        if (size < 0)
+                return -1;
+
+        header = malloc(size);
+        if (!header)
+                return -1;
 
-        size = read8();
-        header_event = malloc_or_die(size);
-        read_or_die(header_event, size);
-        free(header_event);
+        if (do_read_check(handle, header, size))
+                goto failed_read;
+
+        free(header);
+
+        return 0;
+
+ failed_read:
+        free(header);
+        return -1;
 }
 
-static void read_ftrace_file(unsigned long long size)
+static int read_ftrace_file(struct tracecmd_handle *handle,
+                            unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        buf = malloc(size);
+        if (!buf)
+                return -1;
+        if (do_read_check(handle, buf, size)) {
+                free(buf);
+                return -1;
+        }
+
         pevent_parse_event(buf, size, "ftrace");
         free(buf);
+
+        return 0;
 }
 
-static void read_event_file(char *system, unsigned long long size)
+static int read_event_file(struct tracecmd_handle *handle,
+                           char *system, unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size+1);
-        read_or_die(buf, size);
+        buf = malloc(size+1);
+        if (!buf)
+                return -1;
+
+        if (do_read_check(handle,buf, size)) {
+                free(buf);
+                return -1;
+        }
+
         buf[size] = 0;
-        if (show_events)
+        if (handle->print_events)
                 printf("%s\n", buf);
         pevent_parse_event(buf, size, system);
         free(buf);
+
+        return 0;
 }
 
-static void read_ftrace_files(void)
+static int read_ftrace_files(struct tracecmd_handle *handle)
 {
         unsigned long long size;
         int count;
+        int ret;
         int i;
 
-        count = read4();
+        count = read4(handle);
+        if (count < 0)
+                return -1;
 
         for (i = 0; i < count; i++) {
-                size = read8();
-                read_ftrace_file(size);
+                size = read8(handle);
+                if (size < 0)
+                        return -1;
+                ret = read_ftrace_file(handle, size);
+                if (ret < 0)
+                        return -1;
         }
+
+        return 0;
 }
 
-static void read_event_files(void)
+static int read_event_files(struct tracecmd_handle *handle)
 {
         unsigned long long size;
         char *system;
         int systems;
         int count;
+        int ret;
         int i,x;
 
-        systems = read4();
+        systems = read4(handle);
+        if (systems < 0)
+                return -1;
 
         for (i = 0; i < systems; i++) {
-                system = read_string();
+                system = read_string(handle);
+                if (!system)
+                        return -1;
+
+                count = read4(handle);
+                if (count < 0)
+                        goto failed;
 
-                count = read4();
                 for (x=0; x < count; x++) {
-                        size = read8();
-                        read_event_file(system, size);
+                        size = read8(handle);
+                        if (size < 0)
+                                goto failed;
+
+                        ret = read_event_file(handle, system, size);
+                        if (ret < 0)
+                                goto failed;
                 }
+                free(system);
         }
+
+        return 0;
+
+ failed:
+        free(system);
+        return -1;
 }
 
-static void read_proc_kallsyms(void)
+static int read_proc_kallsyms(struct tracecmd_handle *handle)
 {
-        unsigned int size;
+        int size;
         char *buf;
 
-        size = read4();
+        size = read4(handle);
         if (!size)
-                return;
+                return 0; /* OK? */
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        if (size < 0)
+                return -1;
+
+        buf = malloc(size);
+        if (!buf)
+                return -1;
+        if (do_read_check(handle, buf, size)){
+                free(buf);
+                return -1;
+        }
 
         parse_proc_kallsyms(buf, size);
 
         free(buf);
+        return 0;
 }
 
-static void read_ftrace_printk(void)
+static int read_ftrace_printk(struct tracecmd_handle *handle)
 {
-        unsigned int size;
+        int size;
         char *buf;
 
-        size = read4();
+        size = read4(handle);
         if (!size)
-                return;
+                return 0; /* OK? */
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        if (size < 0)
+                return -1;
+
+        buf = malloc(size);
+        if (!buf)
+                return -1;
+        if (do_read_check(handle, buf, size)) {
+                free(buf);
+                return -1;
+        }
 
         parse_ftrace_printk(buf, size);
 
         free(buf);
+
+        return 0;
 }
 
-int read_trace_files(void)
+int tracecmd_read_headers(struct tracecmd_handle *handle)
 {
-        read_header_files();
-        read_ftrace_files();
-        read_event_files();
-        read_proc_kallsyms();
-        read_ftrace_printk();
+        int ret;
+
+        ret = read_header_files(handle);
+        if (ret < 0)
+                return -1;
+
+        ret = read_ftrace_files(handle);
+        if (ret < 0)
+                return -1;
+
+        ret = read_event_files(handle);
+        if (ret < 0)
+                return -1;
+
+        ret = read_proc_kallsyms(handle);
+        if (ret < 0)
+                return -1;
+
+        ret = read_ftrace_printk(handle);
+        if (ret < 0)
+                return -1;
+
 
         trace_load_plugins();
 
@@ -264,30 +403,54 @@ struct tracecmd_handle *tracecmd_open(int fd)
 
         handle->fd = fd;
 
-        input_fd = open(input_file, O_RDONLY);
-        if (input_fd < 0)
-                die("opening '%s'\n", input_file);
+        if (do_read_check(handle, buf, 3))
+                goto failed_read;
 
-        read_or_die(buf, 3);
         if (memcmp(buf, test, 3) != 0)
-                die("not an trace data file");
+                goto failed_read;
 
-        read_or_die(buf, 7);
+        if (do_read_check(handle, buf, 7))
+                goto failed_read;
         if (memcmp(buf, "tracing", 7) != 0)
-                die("not a trace file (missing tracing)");
+                goto failed_read;
 
-        version = read_string();
+        version = read_string(handle);
+        if (!version)
+                goto failed_read;
         printf("version = %s\n", version);
         free(version);
 
-        read_or_die(buf, 1);
+        if (do_read_check(handle, buf, 1))
+                goto failed_read;
+
+        /*
+         * TODO:
+         *  Need to make these part of the handle.
+         *  But they are currently used by parsevent.
+         *  That may need a handler too.
+         */ 
         file_bigendian = buf[0];
         host_bigendian = bigendian();
 
-        read_or_die(buf, 1);
-        long_size = buf[0];
+        do_read_check(handle, buf, 1);
+        handle->long_size = buf[0];
 
-        page_size = read4();
+        handle->page_size = read4(handle);
 
-        return 0;
+        return handle;
+
+ failed_read:
+        free(handle);
+
+        return NULL;
+}
+
+int tracecmd_long_size(struct tracecmd_handle *handle)
+{
+        return handle->long_size;
+}
+
+int tracecmd_page_size(struct tracecmd_handle *handle)
+{
+        return handle->page_size;
 }
diff --git a/trace-local.h b/trace-local.h
index d3fddff..83fe077 100644
--- a/trace-local.h
+++ b/trace-local.h
@@ -7,5 +7,10 @@
 
 void usage(char **argv);
 
+struct tracecmd_handle *read_trace_header(void);
+int read_trace_files(void);
+
+void trace_report(int argc, char **argv);
+
 
 #endif /* __TRACE_LOCAL_H */
diff --git a/trace-read.c b/trace-read.c
index 395eeef..a3e5d66 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -38,6 +38,7 @@
 
 #include "trace-local.h"
 
+unsigned int page_size;
 int input_fd;
 const char *input_file = "trace.dat";
 
@@ -415,12 +416,34 @@ static void read_rest(void)
         } while (r > 0);
 }
 
-unsigned int read4(void);
-unsigned long long read8(void);
-int read_or_die(void *data, int size);
-extern int long_size;
+static int read_or_die(void *data, int size)
+{
+        int r;
+
+        r = read(input_fd, data, size);
+        if (r != size)
+                die("reading input file (size expected=%d received=%d)",
+                    size, r);
+        return r;
+}
+
+static unsigned int read4(void)
+{
+        unsigned int data;
+
+        read_or_die(&data, 4);
+        return __data2host4(data);
+}
 
-static void read_data_info(void)
+static unsigned long long read8(void)
+{
+        unsigned long long data;
+
+        read_or_die(&data, 8);
+        return __data2host8(data);
+}
+
+static void read_data_info(struct tracecmd_handle *handle)
 {
         unsigned long long ts;
         unsigned long long size;
@@ -439,7 +462,7 @@ static void read_data_info(void)
         cpus = read4();
         printf("cpus=%d\n", cpus);
 
-        parse_set_info(cpus, long_size);
+        parse_set_info(cpus, tracecmd_long_size(handle));
 
         /*
          * Check if this is a latency report or not.
@@ -484,19 +507,18 @@ static void read_data_info(void)
         } while (next >= 0);
 }
 
-int read_trace_header(void)
+struct tracecmd_handle *read_trace_header(void)
 {
         input_fd = open(input_file, O_RDONLY);
         if (input_fd < 0)
                 die("opening '%s'\n", input_file);
 
-        tracecmd_open(input_fd);
-
-        return 0;
+        return tracecmd_open(input_fd);
 }
 
 void trace_report (int argc, char **argv)
 {
+        struct tracecmd_handle *handle;
         int show_funcs = 0;
         int show_endian = 0;
         int show_page_size = 0;
@@ -560,7 +582,11 @@ void trace_report (int argc, char **argv)
                 }
         }
 
-        read_trace_header();
+        handle = read_trace_header();
+        if (!handle)
+                die("error reading header");
+
+        page_size = tracecmd_page_size(handle);
 
         if (show_page_size) {
                 printf("file page size is %d, and host page size is %d\n",
@@ -576,7 +602,8 @@ void trace_report (int argc, char **argv)
                 return;
         }
 
-        read_trace_files();
+        if (tracecmd_read_headers(handle) < 0)
+                return;
 
         if (show_funcs) {
                 pevent_print_funcs();
@@ -590,7 +617,7 @@ void trace_report (int argc, char **argv)
         if (show_events)
                 return;
 
-        read_data_info();
+        read_data_info(handle);
 
         return;
 }