Move writing to data file to library

We need a way to have other applications easily make the output
file. This moves the recording of the trace.dat file to the trace-cmd
library.

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

8 files changed, 1000 insertions, 563 deletions

diff --git a/Makefile b/Makefile
index f159a46..42cb7ad 100644
--- a/Makefile
+++ b/Makefile
@@ -39,6 +39,12 @@ trace-util.o:: trace-util.c
 trace-input.o:: trace-input.c
         $(CC) -c $(CFLAGS) $(EXT) $(INCLUDES) -fPIC $< -o $@
 
+trace-output.o:: trace-output.c
+        $(CC) -c $(CFLAGS) $(EXT) $(INCLUDES) -fPIC $< -o $@
+
+trace-record.o:: trace-record.c
+        $(CC) -c $(CFLAGS) $(EXT) $(INCLUDES) -fPIC $< -o $@
+
 trace-ftrace.o:: trace-ftrace.c
         $(CC) -c $(CFLAGS) $(EXT) $(INCLUDES) -fPIC $< -o $@
 
@@ -50,7 +56,8 @@ libparsevent.so: $(PEVENT_LIB_OBJS)
 libparsevent.a: $(PEVENT_LIB_OBJS)
         $(RM) $@;  $(AR) rcs $@ $^
 
-TCMD_LIB_OBJS = $(PEVENT_LIB_OBJS) trace-util.o trace-input.o trace-ftrace.o
+TCMD_LIB_OBJS = $(PEVENT_LIB_OBJS) trace-util.o trace-input.o trace-ftrace.o \
+                        trace-output.o trace-record.o
 
 libtracecmd.so: $(TCMD_LIB_OBJS)
         $(CC) --shared $^ -o $@
diff --git a/parse-events.h b/parse-events.h
index db7e259..9b5ba0d 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -273,8 +273,6 @@ void die(char *fmt, ...);
 void *malloc_or_die(unsigned int size);
 void warning(char *fmt, ...);
 
-int bigendian(void);
-
 static inline unsigned short
 __data2host2(struct pevent *pevent, unsigned short data)
 {
diff --git a/trace-cmd.c b/trace-cmd.c
index aca6f90..aada9a4 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -35,8 +35,6 @@
 
 #include "trace-local.h"
 
-#define VERSION "0.5"
-
 #define _STR(x) #x
 #define STR(x) _STR(x)
 #define MAX_PATH 256
@@ -51,7 +49,6 @@
 unsigned int page_size;
 
 static const char *output_file = "trace.dat";
-static int output_fd;
 
 static int latency;
 
@@ -72,6 +69,25 @@ struct events {
         char *name;
 };
 
+static struct tracecmd_recorder *recorder;
+
+static char *get_temp_file(int cpu)
+{
+        char *file = NULL;
+        int size;
+
+        size = snprintf(file, 0, "%s.cpu%d", output_file, cpu);
+        file = malloc_or_die(size + 1);
+        sprintf(file, "%s.cpu%d", output_file, cpu);
+
+        return file;
+}
+
+static void put_temp_file(char *file)
+{
+        free(file);
+}
+
 static void delete_temp_file(int cpu)
 {
         char file[MAX_PATH];
@@ -174,79 +190,6 @@ void *malloc_or_die(unsigned int size)
         return data;
 }
 
-static const char *find_debugfs(void)
-{
-        static char debugfs[MAX_PATH+1];
-        static int debugfs_found;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return debugfs;
-
-        if ((fp = fopen("/proc/mounts","r")) == NULL)
-                die("Can't open /proc/mounts for read");
-
-        while (fscanf(fp, "%*s %"
-                      STR(MAX_PATH)
-                      "s %99s %*s %*d %*d\n",
-                      debugfs, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                die("debugfs not mounted, please mount");
-
-        debugfs_found = 1;
-
-        return debugfs;
-}
-
-/*
- * Finds the path to the debugfs/tracing
- * Allocates the string and stores it.
- */
-static const char *find_tracing_dir(void)
-{
-        static char *tracing;
-        static int tracing_found;
-        const char *debugfs;
-
-        if (tracing_found)
-                return tracing;
-
-        debugfs = find_debugfs();
-
-        tracing = malloc_or_die(strlen(debugfs) + 9);
-
-        sprintf(tracing, "%s/tracing", debugfs);
-
-        tracing_found = 1;
-        return tracing;
-}
-
-static char *get_tracing_file(const char *name)
-{
-        const char *tracing;
-        char *file;
-
-        tracing = find_tracing_dir();
-        if (!tracing)
-                return NULL;
-
-        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
-
-        sprintf(file, "%s/%s", tracing, name);
-        return file;
-}
-
-static void put_tracing_file(char *file)
-{
-        free(file);
-}
-
 static int set_ftrace(int set)
 {
         struct stat buf;
@@ -284,6 +227,30 @@ void run_cmd(int argc, char **argv)
         waitpid(pid, &status, 0);
 }
 
+static char *get_tracing_file(const char *name)
+{
+        static const char *tracing;
+        char *file;
+
+        if (!tracing) {
+                tracing = tracecmd_find_tracing_dir();
+                if (!tracing)
+                        die("Can't find tracing dir");
+        }
+
+        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
+        if (!file)
+                return NULL;
+
+        sprintf(file, "%s/%s", tracing, name);
+        return file;
+}
+
+static void put_tracing_file(char *file)
+{
+        free(file);
+}
+
 static void show_events(void)
 {
         char buf[BUFSIZ];
@@ -572,20 +539,15 @@ static int finished;
 static void finish(int sig)
 {
         /* all done */
+        if (recorder)
+                tracecmd_stop_recording(recorder);
         finished = 1;
 }
 
 static int create_recorder(int cpu)
 {
-        char file[MAX_PATH];
-        const char *tracing;
-        char *path;
-        int out_fd;
-        int in_fd;
-        int brass[2];
+        char *file;
         int pid;
-        int ret;
-        char buf[page_size];
 
         pid = fork();
         if (pid < 0)
@@ -599,40 +561,15 @@ static int create_recorder(int cpu)
         /* do not kill tasks on error */
         cpu_count = 0;
 
-        snprintf(file, MAX_PATH, "%s.cpu%d", output_file, cpu);
+        file = get_temp_file(cpu);
 
-        out_fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
-        if (out_fd < 0)
-                die("can't create file '%s'", file);
+        recorder = tracecmd_create_recorder(file, cpu);
+        put_temp_file(file);
 
-        tracing = find_tracing_dir();
-
-        path = malloc_or_die(strlen(tracing) + 40);
-
-        sprintf(path, "%s/per_cpu/cpu%d/trace_pipe_raw", tracing, cpu);
-        in_fd = open(path, O_RDONLY);
-        if (in_fd < 0)
-                die("can not read '%s'", path);
-
-        ret = pipe(brass);
-        if (ret < 0)
-                die("can not create pipe");
-
-        do {
-                ret = splice(in_fd, NULL, brass[1], NULL, page_size, 1 /* SPLICE_F_MOVE */);
-                if (ret < 0)
-                        die("splice in");
-                ret = splice(brass[0], NULL, out_fd, NULL, page_size, 3 /* and NON_BLOCK */);
-                if (ret < 0 && errno != EAGAIN)
-                        die("splice out");
-        } while (!finished);
-
-        /* splice only reads full pages */
-        do {
-                ret = read(in_fd, buf, page_size);
-                if (ret > 0)
-                        write(out_fd, buf, ret);
-        } while (ret > 0);
+        if (!recorder)
+                die ("can't create recorder");
+        tracecmd_start_recording(recorder);
+        tracecmd_free_recorder(recorder);
 
         exit(0);
 }
@@ -656,442 +593,32 @@ static void start_threads(void)
         }
 }
 
-static ssize_t write_or_die(const void *buf, size_t len)
-{
-        int ret;
-
-        ret = write(output_fd, buf, len);
-        if (ret < 0)
-                die("writing to '%s'", output_file);
-
-        return ret;
-}
-
-int bigendian(void)
-{
-        unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
-        unsigned int *ptr;
-
-        ptr = (unsigned int *)str;
-        return *ptr == 0x01020304;
-}
-
-static unsigned long long copy_file_fd(int fd)
-{
-        unsigned long long size = 0;
-        char buf[BUFSIZ];
-        int r;
-
-        do {
-                r = read(fd, buf, BUFSIZ);
-                if (r > 0) {
-                        size += r;
-                        write_or_die(buf, r);
-                }
-        } while (r > 0);
-
-        return size;
-}
-
-static unsigned long long copy_file(const char *file)
+static void record_data(void)
 {
-        unsigned long long size = 0;
-        int fd;
-
-        fd = open(file, O_RDONLY);
-        if (fd < 0)
-                die("Can't read '%s'", file);
-        size = copy_file_fd(fd);
-        close(fd);
-
-        return size;
-}
-
-static unsigned long get_size_fd(int fd)
-{
-        unsigned long long size = 0;
-        char buf[BUFSIZ];
-        int r;
-
-        do {
-                r = read(fd, buf, BUFSIZ);
-                if (r > 0)
-                        size += r;
-        } while (r > 0);
-
-        lseek(fd, 0, SEEK_SET);
-
-        return size;
-}
-
-static unsigned long get_size(const char *file)
-{
-        unsigned long long size = 0;
-        int fd;
-
-        fd = open(file, O_RDONLY);
-        if (fd < 0)
-                die("Can't read '%s'", file);
-        size = get_size_fd(fd);
-        close(fd);
-
-        return size;
-}
-
-static void read_header_files(void)
-{
-        unsigned long long size, check_size;
-        struct stat st;
-        char *path;
-        int fd;
-        int ret;
-
-        path = get_tracing_file("events/header_page");
-
-        ret = stat(path, &st);
-        if (ret < 0) {
-                /* old style did not show this info, just add zero */
-                put_tracing_file(path);
-                write_or_die("header_page", 12);
-                size = 0;
-                write_or_die(&size, 8);
-                write_or_die("header_event", 13);
-                write_or_die(&size, 8);
-                return;
-        }
-
-        fd = open(path, O_RDONLY);
-        if (fd < 0)
-                die("can't read '%s'", path);
-
-        /* unfortunately, you can not stat debugfs files for size */
-        size = get_size_fd(fd);
-
-        write_or_die("header_page", 12);
-        write_or_die(&size, 8);
-        check_size = copy_file_fd(fd);
-        if (size != check_size)
-                die("wrong size for '%s' size=%lld read=%lld",
-                    path, size, check_size);
-        put_tracing_file(path);
-
-        path = get_tracing_file("events/header_event");
-        fd = open(path, O_RDONLY);
-        if (fd < 0)
-                die("can't read '%s'", path);
-
-        size = get_size_fd(fd);
-
-        write_or_die("header_event", 13);
-        write_or_die(&size, 8);
-        check_size = copy_file_fd(fd);
-        if (size != check_size)
-                die("wrong size for '%s'", path);
-        put_tracing_file(path);
-}
-
-static void copy_event_system(const char *sys)
-{
-        unsigned long long size, check_size;
-        struct dirent *dent;
-        struct stat st;
-        char *format;
-        DIR *dir;
-        int count = 0;
-        int ret;
-
-        dir = opendir(sys);
-        if (!dir)
-                die("can't read directory '%s'", sys);
-
-        while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
-                    strcmp(dent->d_name, "..") == 0)
-                        continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
-                sprintf(format, "%s/%s/format", sys, dent->d_name);
-                ret = stat(format, &st);
-                free(format);
-                if (ret < 0)
-                        continue;
-                count++;
-        }
-
-        write_or_die(&count, 4);
-        
-        rewinddir(dir);
-        while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
-                    strcmp(dent->d_name, "..") == 0)
-                        continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
-                sprintf(format, "%s/%s/format", sys, dent->d_name);
-                ret = stat(format, &st);
-
-                if (ret >= 0) {
-                        /* unfortunately, you can not stat debugfs files for size */
-                        size = get_size(format);
-                        write_or_die(&size, 8);
-                        check_size = copy_file(format);
-                        if (size != check_size)
-                                die("error in size of file '%s'", format);
-                }
-
-                free(format);
-        }
-}
-
-static void read_ftrace_files(void)
-{
-        char *path;
-
-        path = get_tracing_file("events/ftrace");
-
-        copy_event_system(path);
-
-        put_tracing_file(path);
-}
-
-static void read_event_files(void)
-{
-        struct dirent *dent;
-        struct stat st;
-        char *path;
-        char *sys;
-        DIR *dir;
-        int count = 0;
-        int ret;
-
-        path = get_tracing_file("events");
-
-        dir = opendir(path);
-        if (!dir)
-                die("can't read directory '%s'", path);
-
-        while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
-                    strcmp(dent->d_name, "..") == 0 ||
-                    strcmp(dent->d_name, "ftrace") == 0)
-                        continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
-                sprintf(sys, "%s/%s", path, dent->d_name);
-                ret = stat(sys, &st);
-                free(sys);
-                if (ret < 0)
-                        continue;
-                if (S_ISDIR(st.st_mode))
-                        count++;
-        }
-
-        write_or_die(&count, 4);
-
-        rewinddir(dir);
-        while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
-                    strcmp(dent->d_name, "..") == 0 ||
-                    strcmp(dent->d_name, "ftrace") == 0)
-                        continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
-                sprintf(sys, "%s/%s", path, dent->d_name);
-                ret = stat(sys, &st);
-                if (ret >= 0) {
-                        if (S_ISDIR(st.st_mode)) {
-                                write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                                copy_event_system(sys);
-                        }
-                }
-                free(sys);
-        }
-
-        put_tracing_file(path);
-}
-
-static void read_proc_kallsyms(void)
-{
-        unsigned int size, check_size;
-        const char *path = "/proc/kallsyms";
-        struct stat st;
-        int ret;
-
-        ret = stat(path, &st);
-        if (ret < 0) {
-                /* not found */
-                size = 0;
-                write_or_die(&size, 4);
-                return;
-        }
-        size = get_size(path);
-        write_or_die(&size, 4);
-        check_size = copy_file(path);
-        if (size != check_size)
-                die("error in size of file '%s'", path);
-
-}
-
-static void read_ftrace_printk(void)
-{
-        unsigned int size, check_size;
-        const char *path;
-        struct stat st;
-        int ret;
-
-        path = get_tracing_file("printk_formats");
-        ret = stat(path, &st);
-        if (ret < 0) {
-                /* not found */
-                size = 0;
-                write_or_die(&size, 4);
-                return;
-        }
-        size = get_size(path);
-        write_or_die(&size, 4);
-        check_size = copy_file(path);
-        if (size != check_size)
-                die("error in size of file '%s'", path);
-
-}
-
-static void read_tracing_data(void)
-{
-        char buf[BUFSIZ];
-
-        output_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
-        if (output_fd < 0)
-                die("creating file '%s'", output_file);
-
-        buf[0] = 23;
-        buf[1] = 8;
-        buf[2] = 68;
-        memcpy(buf + 3, "tracing", 7);
-
-        write_or_die(buf, 10);
-
-        write_or_die(VERSION, strlen(VERSION) + 1);
-
-        /* save endian */
-        if (bigendian())
-                buf[0] = 1;
-        else
-                buf[0] = 0;
-
-        write_or_die(buf, 1);
-
-        /* save size of long */
-        buf[0] = sizeof(long);
-        write_or_die(buf, 1);
-
-        /* save page_size */
-        page_size = getpagesize();
-        write_or_die(&page_size, 4);
-
-        read_header_files();
-        read_ftrace_files();
-        read_event_files();
-        read_proc_kallsyms();
-        read_ftrace_printk();
-}
-
-static unsigned long long read_thread_file(int cpu)
-{
-        unsigned long long size;
-        char *file;
-
-        file = malloc_or_die(strlen(output_file) + 20);
-        snprintf(file, MAX_PATH, "%s.cpu%d", output_file, cpu);
-
-        size = copy_file(file);
-        free(file);
-        return size;
-}
-
-static void read_trace_data(void)
-{
-        char *path;
-
-        write_or_die("latency  ", 10);
-
-        path = get_tracing_file("trace");
-
-        copy_file(path);
-
-        put_tracing_file(path);
-}
-
-static void read_thread_data(void)
-{
-        unsigned long long offset, check_size;
-        unsigned long long *offsets;
-        unsigned long long *sizes;
-        unsigned long long size;
-        long long ret;
-        struct stat st;
-        char *file;
+        struct tracecmd_output *handle;
+        char **temp_files;
         int i;
-                
-        if (!cpu_count)
-                return;
-
-        /*
-         * Save the command lines;
-         */
-        file = get_tracing_file("saved_cmdlines");
-        ret = stat(file, &st);
-        if (ret >= 0) {
-                size = get_size(file);
-                write_or_die(&size, 8);
-                check_size = copy_file(file);
-                if (size != check_size)
-                        die("error in size of file '%s'", file);
-        } else {
-                size = 0;
-                write_or_die(&size, 8);
-        }
-        put_tracing_file(file);
-
-        write_or_die(&cpu_count, 4);
-
-        if (latency) {
-                read_trace_data();
-                return;
-        }
 
-        write_or_die("flyrecord", 10);
+        if (latency)
+                handle = tracecmd_create_file_latency(output_file, cpu_count);
+        else {
+                if (!cpu_count)
+                        return;
 
-        offsets = malloc_or_die(sizeof(*offsets) * cpu_count);
-        sizes = malloc_or_die(sizeof(*sizes) * cpu_count);
+                temp_files = malloc_or_die(sizeof(*temp_files) * cpu_count);
 
-        offset = lseek(output_fd, 0, SEEK_CUR);
+                for (i = 0; i < cpu_count; i++)
+                        temp_files[i] = get_temp_file(i);
 
-        /* hold any extra data for data */
-        offset += cpu_count * (16);
-        offset = (offset + (page_size - 1)) & ~(PAGE_MASK);
+                handle = tracecmd_create_file(output_file, cpu_count, temp_files);
 
-        for (i = 0; i < cpu_count; i++) {
-                file = malloc_or_die(strlen(output_file) + 20);
-                sprintf(file, "%s.cpu%d", output_file, i);
-                ret = stat(file, &st);
-                if (ret < 0)
-                        die("can not stat '%s'", file);
-                free(file);
-                offsets[i] = offset;
-                sizes[i] = st.st_size;
-                offset += st.st_size;
-                offset = (offset + (page_size - 1)) & ~(PAGE_MASK);
-
-                write_or_die(&offsets[i], 8);
-                write_or_die(&sizes[i], 8);
-        }
-
-        for (i = 0; i < cpu_count; i++) {
-                fprintf(stderr, "offset=%llx\n", offsets[i]);
-                ret = lseek64(output_fd, offsets[i], SEEK_SET);
-                if (ret < 0)
-                        die("could not seek to %lld\n", offsets[i]);
-                check_size = read_thread_file(i);
-                if (check_size != sizes[i])
-                        die("did not match size of %lld to %lld",
-                            check_size, sizes[i]);
+                for (i = 0; i < cpu_count; i++)
+                        put_temp_file(temp_files[i]);
+                free(temp_files);
         }
+        if (!handle)
+                die("could not write to file");
+        tracecmd_output_close(handle);
 }
 
 void usage(char **argv)
@@ -1137,7 +664,7 @@ void usage(char **argv)
                "          -e list available events\n"
                "          -p list available plugins\n"
                "          -o list available options\n"
-               "\n", p, VERSION, p, p, p, p, p, p);
+               "\n", p, TRACECMD_VERSION, p, p, p, p, p, p);
         exit(-1);
 }
 
@@ -1268,15 +795,8 @@ int main (int argc, char **argv)
         if (!events && !plugin)
                 die("no event or plugin was specified... aborting");
 
-        if (record) {
-                if (output)
-                        output_file = output;
-
-                read_tracing_data();
-
-                start_threads();
-                signal(SIGINT, finish);
-        }
+        if (output)
+                output_file = output;
 
         fset = set_ftrace(!disable);
         disable_all();
@@ -1294,9 +814,6 @@ int main (int argc, char **argv)
                     strcmp(plugin, "wakeup") == 0 ||
                     strcmp(plugin, "wakeup_rt") == 0) {
                         latency = 1;
-                        if (record)
-                                stop_threads();
-                        reset_max_latency();
                 }
                 if (fset < 0 && (strcmp(plugin, "function") == 0 ||
                                  strcmp(plugin, "function_graph") == 0))
@@ -1304,7 +821,15 @@ int main (int argc, char **argv)
                 set_plugin(plugin);
         }
 
+        if (record) {
+                if (!latency)
+                        start_threads();
+                signal(SIGINT, finish);
+        }
+
         enable_tracing();
+        if (latency)
+                reset_max_latency();
 
         if (!record)
                 exit(0);
@@ -1316,14 +841,13 @@ int main (int argc, char **argv)
                 printf("Hit Ctrl^C to stop recording\n");
                 while (!finished)
                         sleep(10);
-                
         }
 
         disable_tracing();
 
         stop_threads();
 
-        read_thread_data();
+        record_data();
         delete_thread_data();
 
         exit(0);
diff --git a/trace-cmd.h b/trace-cmd.h
index cc63627..9fbd475 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -10,6 +10,8 @@ extern const char *input_file;
 #define PAGE_MASK (page_size - 1)
 #endif
 
+#define TRACECMD_VERSION "0.5"
+
 void parse_cmdlines(struct pevent *pevent, char *file, int size);
 void parse_proc_kallsyms(struct pevent *pevent, char *file, unsigned int size);
 void parse_ftrace_printk(char *file, unsigned int size);
@@ -35,6 +37,21 @@ struct record {
 };
 
 struct tracecmd_input;
+struct tracecmd_output;
+struct tracecmd_recorder;
+
+static inline int tracecmd_host_bigendian(void)
+{
+        unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
+        unsigned int *ptr;
+
+        ptr = (unsigned int *)str;
+        return *ptr == 0x01020304;
+}
+
+char *tracecmd_find_tracing_dir(void);
+
+/* --- Opening and Reading the trace.dat file --- */
 
 struct tracecmd_input *tracecmd_open(int fd);
 int tracecmd_read_headers(struct tracecmd_input *handle);
@@ -68,4 +85,20 @@ struct pevent *tracecmd_get_pevent(struct tracecmd_input *handle);
 /* hack for function graph work around */
 extern __thread struct tracecmd_input *tracecmd_curr_thread_handle;
 
+
+/* --- Creating and Writing the trace.dat file --- */
+
+struct tracecmd_output *tracecmd_create_file_latency(const char *output_file, int cpus);
+struct tracecmd_output *tracecmd_create_file(const char *output_file,
+                                             int cpus, char * const *cpu_data_files);
+void tracecmd_output_close(struct tracecmd_output *handle);
+
+/* --- Reading the Fly Recorder Trace --- */
+
+void tracecmd_free_recorder(struct tracecmd_recorder *recorder);
+struct tracecmd_recorder *tracecmd_create_recorder(const char *file, int cpu);
+int tracecmd_start_recording(struct tracecmd_recorder *recorder);
+void tracecmd_stop_recording(struct tracecmd_recorder *recorder);
+
+
 #endif /* _TRACE_CMD_H */
diff --git a/trace-input.c b/trace-input.c
index 9e61d20..f37fb6a 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -1197,7 +1197,7 @@ struct tracecmd_input *tracecmd_open(int fd)
                 goto failed_read;
 
         handle->pevent->file_bigendian = buf[0];
-        handle->pevent->host_bigendian = bigendian();
+        handle->pevent->host_bigendian = tracecmd_host_bigendian();
 
         do_read_check(handle, buf, 1);
         handle->long_size = buf[0];
diff --git a/trace-output.c b/trace-output.c
new file mode 100644
index 0000000..8f21fe4
--- /dev/null
+++ b/trace-output.c
@@ -0,0 +1,700 @@
+#define _LARGEFILE64_SOURCE
+#define _GNU_SOURCE
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "trace-cmd.h"
+
+struct tracecmd_output {
+        int             fd;
+        int             page_size;
+        int             cpus;
+        char            *tracing_dir;
+};
+
+static int do_write(struct tracecmd_output *handle, void *data, int size)
+{
+        int tot = 0;
+        int w;
+
+        do {
+                w = write(handle->fd, data, size - tot);
+                tot += w;
+
+                if (!w)
+                        break;
+                if (w < 0)
+                        return w;
+        } while (tot != size);
+
+        return tot;
+}
+
+static int
+do_write_check(struct tracecmd_output *handle, void *data, int size)
+{
+        int ret;
+
+        ret = do_write(handle, data, size);
+        if (ret < 0)
+                return ret;
+        if (ret != size)
+                return -1;
+
+        return 0;
+}
+
+void tracecmd_output_close(struct tracecmd_output *handle)
+{
+        if (!handle)
+                return;
+
+        if (handle->fd >= 0) {
+                close(handle->fd);
+                handle->fd = -1;
+        }
+
+        if (handle->tracing_dir)
+                free(handle->tracing_dir);
+
+        free(handle);
+}
+
+static unsigned long get_size_fd(int fd)
+{
+        unsigned long long size = 0;
+        char buf[BUFSIZ];
+        int r;
+
+        do {
+                r = read(fd, buf, BUFSIZ);
+                if (r > 0)
+                        size += r;
+        } while (r > 0);
+
+        lseek(fd, 0, SEEK_SET);
+
+        return size;
+}
+
+static unsigned long get_size(const char *file)
+{
+        unsigned long long size = 0;
+        int fd;
+
+        fd = open(file, O_RDONLY);
+        if (fd < 0)
+                die("Can't read '%s'", file);
+        size = get_size_fd(fd);
+        close(fd);
+
+        return size;
+}
+
+static unsigned long long copy_file_fd(struct tracecmd_output *handle, int fd)
+{
+        unsigned long long size = 0;
+        char buf[BUFSIZ];
+        int r;
+
+        do {
+                r = read(fd, buf, BUFSIZ);
+                if (r > 0) {
+                        size += r;
+                        if (do_write_check(handle, buf, r))
+                                return 0;
+                }
+        } while (r > 0);
+
+        return size;
+}
+
+static unsigned long long copy_file(struct tracecmd_output *handle,
+                                    const char *file)
+{
+        unsigned long long size = 0;
+        int fd;
+
+        fd = open(file, O_RDONLY);
+        if (fd < 0)
+                die("Can't read '%s'", file);
+        size = copy_file_fd(handle, fd);
+        close(fd);
+
+        return size;
+}
+
+/*
+ * Finds the path to the debugfs/tracing
+ * Allocates the string and stores it.
+ */
+static const char *find_tracing_dir(struct tracecmd_output *handle)
+{
+        if (!handle->tracing_dir)
+                handle->tracing_dir = tracecmd_find_tracing_dir();
+
+        return handle->tracing_dir;
+}
+
+static char *get_tracing_file(struct tracecmd_output *handle, const char *name)
+{
+        const char *tracing;
+        char *file;
+
+        tracing = find_tracing_dir(handle);
+        if (!tracing)
+                return NULL;
+
+        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
+        if (!file)
+                return NULL;
+
+        sprintf(file, "%s/%s", tracing, name);
+        return file;
+}
+
+static void put_tracing_file(char *file)
+{
+        free(file);
+}
+
+int tracecmd_ftrace_enable(int set)
+{
+        struct stat buf;
+        char *path = "/proc/sys/kernel/ftrace_enabled";
+        int fd;
+        char *val = set ? "1" : "0";
+        int ret = 0;
+
+        /* if ftace_enable does not exist, simply ignore it */
+        fd = stat(path, &buf);
+        if (fd < 0)
+                return ENODEV;
+
+        fd = open(path, O_WRONLY);
+        if (fd < 0)
+                die ("Can't %s ftrace", set ? "enable" : "disable");
+
+        if (write(fd, val, 1) < 0)
+                ret = -1;
+        close(fd);
+
+        return ret;
+}
+
+static int read_header_files(struct tracecmd_output *handle)
+{
+        unsigned long long size, check_size;
+        struct stat st;
+        char *path;
+        int fd;
+        int ret;
+
+        path = get_tracing_file(handle, "events/header_page");
+        if (!path)
+                return -1;
+
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* old style did not show this info, just add zero */
+                put_tracing_file(path);
+                if (do_write_check(handle, "header_page", 12))
+                        return -1;
+                size = 0;
+                if (do_write_check(handle, &size, 8))
+                        return -1;
+                if (do_write_check(handle, "header_event", 13))
+                        return -1;
+                if (do_write_check(handle, &size, 8))
+                        return -1;
+                return 0;
+        }
+
+        fd = open(path, O_RDONLY);
+        if (fd < 0) {
+                warning("can't read '%s'", path);
+                return -1;
+        }
+
+        /* unfortunately, you can not stat debugfs files for size */
+        size = get_size_fd(fd);
+
+        if (do_write_check(handle, "header_page", 12))
+                goto out_close;
+        if (do_write_check(handle, &size, 8))
+                goto out_close;
+        check_size = copy_file_fd(handle, fd);
+        close(fd);
+        if (size != check_size) {
+                warning("wrong size for '%s' size=%lld read=%lld",
+                        path, size, check_size);
+                errno = EINVAL;
+                return -1;
+        }
+        put_tracing_file(path);
+
+        path = get_tracing_file(handle, "events/header_event");
+        if (!path)
+                return -1;
+
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                die("can't read '%s'", path);
+
+        size = get_size_fd(fd);
+
+        if (do_write_check(handle, "header_event", 13))
+                goto out_close;
+        if (do_write_check(handle, &size, 8))
+                goto out_close;
+        check_size = copy_file_fd(handle, fd);
+        close(fd);
+        if (size != check_size) {
+                warning("wrong size for '%s'", path);
+                return -1;
+        }
+        put_tracing_file(path);
+        return 0;
+
+ out_close:
+        close(fd);
+        return -1;
+}
+
+static int copy_event_system(struct tracecmd_output *handle, const char *sys)
+{
+        unsigned long long size, check_size;
+        struct dirent *dent;
+        struct stat st;
+        char *format;
+        DIR *dir;
+        int count = 0;
+        int ret;
+
+        dir = opendir(sys);
+        if (!dir) {
+                warning("can't read directory '%s'", sys);
+                return -1;
+        }
+
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0)
+                        continue;
+                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format)
+                        return -1;
+                sprintf(format, "%s/%s/format", sys, dent->d_name);
+                ret = stat(format, &st);
+                free(format);
+                if (ret < 0)
+                        continue;
+                count++;
+        }
+
+        if (do_write_check(handle, &count, 4))
+                return -1;
+        
+        rewinddir(dir);
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0)
+                        continue;
+                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format)
+                        return -1;
+                sprintf(format, "%s/%s/format", sys, dent->d_name);
+                ret = stat(format, &st);
+
+                if (ret >= 0) {
+                        /* unfortunately, you can not stat debugfs files for size */
+                        size = get_size(format);
+                        if (do_write_check(handle, &size, 8))
+                                goto out_free;
+                        check_size = copy_file(handle, format);
+                        if (size != check_size) {
+                                warning("error in size of file '%s'", format);
+                                goto out_free;
+                        }
+                }
+
+                free(format);
+        }
+
+        return 0;
+
+ out_free:
+        free(format);
+        return -1;
+}
+
+static int read_ftrace_files(struct tracecmd_output *handle)
+{
+        char *path;
+        int ret;
+
+        path = get_tracing_file(handle, "events/ftrace");
+        if (!path)
+                return -1;
+
+        ret = copy_event_system(handle, path);
+
+        put_tracing_file(path);
+
+        return ret;
+}
+
+static int read_event_files(struct tracecmd_output *handle)
+{
+        struct dirent *dent;
+        struct stat st;
+        char *path;
+        char *sys;
+        DIR *dir;
+        int count = 0;
+        int ret;
+
+        path = get_tracing_file(handle, "events");
+        if (!path)
+                return -1;
+
+        dir = opendir(path);
+        if (!dir)
+                die("can't read directory '%s'", path);
+
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    strcmp(dent->d_name, "ftrace") == 0)
+                        continue;
+                ret = -1;
+                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                if (!sys)
+                        goto out_close_dir;
+                sprintf(sys, "%s/%s", path, dent->d_name);
+                ret = stat(sys, &st);
+                free(sys);
+                if (ret < 0)
+                        continue;
+                if (S_ISDIR(st.st_mode))
+                        count++;
+        }
+
+        ret = -1;
+        if (do_write_check(handle, &count, 4))
+                goto out_close_dir;
+
+        rewinddir(dir);
+        while ((dent = readdir(dir))) {
+                if (strcmp(dent->d_name, ".") == 0 ||
+                    strcmp(dent->d_name, "..") == 0 ||
+                    strcmp(dent->d_name, "ftrace") == 0)
+                        continue;
+                ret = -1;
+                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                if (!sys)
+                        goto out_close_dir;
+
+                sprintf(sys, "%s/%s", path, dent->d_name);
+                ret = stat(sys, &st);
+                if (ret >= 0) {
+                        if (S_ISDIR(st.st_mode)) {
+                                if (do_write_check(handle, dent->d_name,
+                                                   strlen(dent->d_name) + 1)) {
+                                        free(sys);
+                                        ret = -1;
+                                        goto out_close_dir;
+                                }
+                                copy_event_system(handle, sys);
+                        }
+                }
+                free(sys);
+        }
+
+        put_tracing_file(path);
+
+        ret = 0;
+
+ out_close_dir:
+        closedir(dir);
+        return ret;
+}
+
+static int read_proc_kallsyms(struct tracecmd_output *handle)
+{
+        unsigned int size, check_size;
+        const char *path = "/proc/kallsyms";
+        struct stat st;
+        int ret;
+
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* not found */
+                size = 0;
+                if (do_write_check(handle, &size, 4))
+                        return -1;
+                return 0;
+        }
+        size = get_size(path);
+        if (do_write_check(handle, &size, 4))
+                return -1;
+        check_size = copy_file(handle, path);
+        if (size != check_size) {
+                errno = EINVAL;
+                warning("error in size of file '%s'", path);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int read_ftrace_printk(struct tracecmd_output *handle)
+{
+        unsigned int size, check_size;
+        const char *path;
+        struct stat st;
+        int ret;
+
+        path = get_tracing_file(handle, "printk_formats");
+        if (!path)
+                return -1;
+
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* not found */
+                size = 0;
+                if (do_write_check(handle, &size, 4))
+                        return -1;
+                return 0;
+        }
+        size = get_size(path);
+        if (do_write_check(handle, &size, 4))
+                return -1;
+        check_size = copy_file(handle, path);
+        if (size != check_size) {
+                errno = EINVAL;
+                warning("error in size of file '%s'", path);
+                return -1;
+        }
+
+        return 0;
+}
+
+static struct tracecmd_output *create_file(const char *output_file, int cpus)
+{
+        struct tracecmd_output *handle;
+        char buf[BUFSIZ];
+        char *file = NULL;
+        struct stat st;
+        off64_t check_size;
+        off64_t size;
+        int ret;
+
+        handle = malloc(sizeof(*handle));
+        if (!handle)
+                return NULL;
+        memset(handle, 0, sizeof(*handle));
+
+        handle->fd = open(output_file, O_RDWR | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
+        if (handle->fd < 0)
+                goto out_free;
+
+        buf[0] = 23;
+        buf[1] = 8;
+        buf[2] = 68;
+        memcpy(buf + 3, "tracing", 7);
+
+        if (do_write_check(handle, buf, 10))
+                goto out_free;
+
+        if (do_write_check(handle, TRACECMD_VERSION, strlen(TRACECMD_VERSION) + 1))
+                goto out_free;
+
+        /* save endian */
+        if (tracecmd_host_bigendian())
+                buf[0] = 1;
+        else
+                buf[0] = 0;
+
+        if (do_write_check(handle, buf, 1))
+                goto out_free;
+
+        /* save size of long (this may not be what the kernel is) */
+        buf[0] = sizeof(long);
+        if (do_write_check(handle, buf, 1))
+                goto out_free;
+
+        /* save page_size */
+        handle->page_size = getpagesize();
+        if (do_write_check(handle, &handle->page_size, 4))
+                goto out_free;
+
+        if (read_header_files(handle))
+                goto out_free;
+        if (read_ftrace_files(handle))
+                goto out_free;
+        if (read_event_files(handle))
+                goto out_free;
+        if (read_proc_kallsyms(handle))
+                goto out_free;
+        if (read_ftrace_printk(handle))
+                goto out_free;
+
+        /*
+         * Save the command lines;
+         */
+        file = get_tracing_file(handle, "saved_cmdlines");
+        ret = stat(file, &st);
+        if (ret >= 0) {
+                size = get_size(file);
+                if (do_write_check(handle, &size, 8))
+                        goto out_free;
+                check_size = copy_file(handle, file);
+                if (size != check_size) {
+                        errno = EINVAL;
+                        warning("error in size of file '%s'", file);
+                        goto out_free;
+                }
+        } else {
+                size = 0;
+                if (do_write_check(handle, &size, 8))
+                        goto out_free;
+        }
+        put_tracing_file(file);
+        file = NULL;
+
+        if (do_write_check(handle, &cpus, 4))
+                goto out_free;
+
+        return handle;
+
+ out_free:
+        tracecmd_output_close(handle);
+        return NULL;
+}
+
+struct tracecmd_output *tracecmd_create_file_latency(const char *output_file, int cpus)
+{
+        struct tracecmd_output *handle;
+        char *path;
+
+        handle = create_file(output_file, cpus);
+        if (!handle)
+                return NULL;
+
+        if (do_write_check(handle, "latency  ", 10))
+                goto out_free;
+
+        path = get_tracing_file(handle, "trace");
+        if (!path)
+                goto out_free;
+
+        copy_file(handle, path);
+
+        put_tracing_file(path);
+
+        return handle;
+
+out_free:
+        tracecmd_output_close(handle);
+        return NULL;
+}
+
+struct tracecmd_output *tracecmd_create_file(const char *output_file,
+                                             int cpus, char * const *cpu_data_files)
+{
+        unsigned long long *offsets = NULL;
+        unsigned long long *sizes = NULL;
+        struct tracecmd_output *handle;
+        unsigned long long offset;
+        off64_t check_size;
+        char *file = NULL;
+        struct stat st;
+        int ret;
+        int i;
+
+        handle = create_file(output_file, cpus);
+        if (!handle)
+                return NULL;
+
+        if (do_write_check(handle, "flyrecord", 10))
+                goto out_free;
+
+        offsets = malloc_or_die(sizeof(*offsets) * cpus);
+        if (!offsets)
+                goto out_free;
+        sizes = malloc_or_die(sizeof(*sizes) * cpus);
+        if (!sizes)
+                goto out_free;
+
+        offset = lseek(handle->fd, 0, SEEK_CUR);
+
+        /* hold any extra data for data */
+        offset += cpus * (16);
+        offset = (offset + (handle->page_size - 1)) & ~(handle->page_size - 1);
+
+        for (i = 0; i < cpus; i++) {
+                file = malloc_or_die(strlen(output_file) + 20);
+                if (!file)
+                        goto out_free;
+                sprintf(file, "%s.cpu%d", output_file, i);
+                ret = stat(file, &st);
+                if (ret < 0) {
+                        warning("can not stat '%s'", file);
+                        goto out_free;
+                }
+                free(file);
+                file = NULL;
+                offsets[i] = offset;
+                sizes[i] = st.st_size;
+                offset += st.st_size;
+                offset = (offset + (handle->page_size - 1)) & ~(handle->page_size - 1);
+
+                if (do_write_check(handle, &offsets[i], 8))
+                        goto out_free;
+                if (do_write_check(handle, &sizes[i], 8))
+                        goto out_free;
+        }
+
+        for (i = 0; i < cpus; i++) {
+                fprintf(stderr, "offset=%llx\n", offsets[i]);
+                ret = lseek64(handle->fd, offsets[i], SEEK_SET);
+                if (ret < 0) {
+                        warning("could not seek to %lld\n", offsets[i]);
+                        goto out_free;
+                }
+                check_size = copy_file(handle, cpu_data_files[i]);
+                if (check_size != sizes[i]) {
+                        errno = EINVAL;
+                        warning("did not match size of %lld to %lld",
+                            check_size, sizes[i]);
+                        goto out_free;
+                }
+        }
+
+        free(offsets);
+        free(sizes);
+
+        return handle;
+
+ out_free:
+        free(file);
+        free(offsets);
+        free(sizes);
+
+        tracecmd_output_close(handle);
+        return NULL;
+}
diff --git a/trace-record.c b/trace-record.c
new file mode 100644
index 0000000..0cd81ac
--- /dev/null
+++ b/trace-record.c
@@ -0,0 +1,133 @@
+#define _LARGEFILE64_SOURCE
+#define _GNU_SOURCE
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "trace-cmd.h"
+
+struct tracecmd_recorder {
+        int             fd;
+        int             trace_fd;
+        int             brass[2];
+        int             page_size;
+        int             cpu;
+        int             stop;
+};
+
+void tracecmd_free_recorder(struct tracecmd_recorder *recorder)
+{
+        if (!recorder)
+                return;
+
+        if (recorder->fd)
+                close(recorder->fd);
+
+        free(recorder);
+}
+
+struct tracecmd_recorder *tracecmd_create_recorder(const char *file, int cpu)
+{
+        struct tracecmd_recorder *recorder;
+        char *tracing = NULL;
+        char *path = NULL;
+        int ret;
+
+        recorder = malloc_or_die(sizeof(*recorder));
+        if (!recorder)
+                return NULL;
+
+        recorder->cpu = cpu;
+
+        /* Init to know what to free and release */
+        recorder->trace_fd = -1;
+        recorder->brass[0] = -1;
+        recorder->brass[1] = -1;
+
+        recorder->page_size = getpagesize();
+
+        recorder->fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
+        if (recorder->fd < 0)
+                goto out_free;
+
+        tracing = tracecmd_find_tracing_dir();
+        if (!tracing) {
+                errno = ENODEV;
+                goto out_free;
+        }
+
+        path = malloc_or_die(strlen(tracing) + 40);
+        if (!path)
+                goto out_free;
+
+        sprintf(path, "%s/per_cpu/cpu%d/trace_pipe_raw", tracing, cpu);
+        recorder->trace_fd = open(path, O_RDONLY);
+        if (recorder->trace_fd < 0)
+                goto out_free;
+
+        free(tracing);
+        free(path);
+
+        ret = pipe(recorder->brass);
+        if (ret < 0)
+                goto out_free;
+
+        return recorder;
+
+ out_free:
+        free(tracing);
+        free(path);
+
+        tracecmd_free_recorder(recorder);
+        return NULL;
+}
+
+int tracecmd_start_recording(struct tracecmd_recorder *recorder)
+{
+        char *buf[recorder->page_size];
+        int ret;
+
+        recorder->stop = 0;
+
+        do {
+                ret = splice(recorder->trace_fd, NULL, recorder->brass[1], NULL,
+                             recorder->page_size, 1 /* SPLICE_F_MOVE */);
+                if (ret < 0) {
+                        warning("recorder error in splice input");
+                        return -1;
+                }
+                ret = splice(recorder->brass[0], NULL, recorder->fd, NULL,
+                             recorder->page_size, 3 /* and NON_BLOCK */);
+                if (ret < 0 && errno != EAGAIN) {
+                        warning("recorder error in splice output");
+                        return -1;
+                }
+        } while (!recorder->stop);
+
+        /* splice only reads full pages */
+        do {
+                ret = read(recorder->trace_fd, buf, recorder->page_size);
+                if (ret > 0)
+                        write(recorder->fd, buf, ret);
+        } while (ret > 0);
+
+        return 0;
+}
+
+void tracecmd_stop_recording(struct tracecmd_recorder *recorder)
+{
+        if (!recorder)
+                return;
+
+        recorder->stop = 1;
+}
diff --git a/trace-util.c b/trace-util.c
index a3ee05c..c3d89c6 100644
--- a/trace-util.c
+++ b/trace-util.c
@@ -15,6 +15,13 @@
 
 #define __weak __attribute__((weak))
 
+#define _STR(x) #x
+#define STR(x) _STR(x)
+
+#ifndef MAX_PATH
+# define MAX_PATH 1024
+#endif
+
 void __weak die(char *fmt, ...)
 {
         va_list ap;
@@ -173,6 +180,41 @@ static int load_plugin(struct pevent *pevent,
         return ret;
 }
 
+char *tracecmd_find_tracing_dir(void)
+{
+        char debugfs[MAX_PATH+1];
+        char *tracing_dir;
+        char type[100];
+        FILE *fp;
+        
+        if ((fp = fopen("/proc/mounts","r")) == NULL) {
+                warning("Can't open /proc/mounts for read");
+                return NULL;
+        }
+
+        while (fscanf(fp, "%*s %"
+                      STR(MAX_PATH)
+                      "s %99s %*s %*d %*d\n",
+                      debugfs, type) == 2) {
+                if (strcmp(type, "debugfs") == 0)
+                        break;
+        }
+        fclose(fp);
+
+        if (strcmp(type, "debugfs") != 0) {
+                warning("debugfs not mounted, please mount");
+                return NULL;
+        }
+
+        tracing_dir = malloc_or_die(strlen(debugfs) + 9);
+        if (!tracing_dir)
+                return NULL;
+
+        sprintf(tracing_dir, "%s/tracing", debugfs);
+
+        return tracing_dir;
+}
+
 int trace_load_plugins(struct pevent *pevent)
 {
         struct dirent *dent;