trace-cmd: Add split feature

 trace-cmd split [options] -o file [start [end]]
          -o output file to write to (file.1, file.2, etc)
          -s n  split file up by n seconds
          -m n  split file up by n milliseconds
          -u n  split file up by n microseconds
          -e n  split file up by n events
          -p n  split file up by n pages
          -r    repeat from start to end
          -c    per cpu, that is -p 2 will be 2 pages for each CPU
          if option is specified, it will split the file
           up starting at start, and ending at end
          start - decimal start time in seconds (ex: 75678.923853)
                  if left out, will start at beginning of file
          end   - decimal end time in seconds

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

8 files changed, 894 insertions, 58 deletions

diff --git a/Makefile b/Makefile
index d64d1c8..d2dd7ed 100644
--- a/Makefile
+++ b/Makefile
@@ -140,7 +140,7 @@ endef
         $(Q)$(call check_gui)
 
 
-TRACE_CMD_OBJS = trace-cmd.o trace-read.o
+TRACE_CMD_OBJS = trace-cmd.o trace-read.o trace-split.o
 TRACE_VIEW_OBJS = trace-view.o trace-view-store.o trace-filter.o trace-compat.o \
         trace-hash.o
 TRACE_GRAPH_OBJS = trace-graph.o trace-compat.o trace-hash.o trace-filter.o
diff --git a/trace-cmd-local.h b/trace-cmd-local.h
new file mode 100644
index 0000000..fa0959c
--- /dev/null
+++ b/trace-cmd-local.h
@@ -0,0 +1,40 @@
+#ifndef _TRACE_CMD_LOCAL_H
+#define _TRACE_CMD_LOCAL_H
+
+/* Local for trace-input.c and trace-output.c */
+
+#include "trace-cmd.h"
+
+static int __do_write(int fd, void *data, int size)
+{
+        int tot = 0;
+        int w;
+
+        do {
+                w = write(fd, data, size - tot);
+                tot += w;
+
+                if (!w)
+                        break;
+                if (w < 0)
+                        return w;
+        } while (tot != size);
+
+        return tot;
+}
+
+static int
+__do_write_check(int fd, void *data, int size)
+{
+        int ret;
+
+        ret = __do_write(fd, data, size);
+        if (ret < 0)
+                return ret;
+        if (ret != size)
+                return -1;
+
+        return 0;
+}
+
+#endif /* _TRACE_CMD_LOCAL_H */
diff --git a/trace-cmd.c b/trace-cmd.c
index 45d8568..8839e74 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -750,11 +750,26 @@ void usage(char **argv)
                "          -E show event files stored\n"
                "          -l show latency format (default with latency tracers)\n"
                "\n"
+               " %s split [options] -o file [start [end]]\n"
+               "          -o output file to write to (file.1, file.2, etc)\n"
+               "          -s n  split file up by n seconds\n"
+               "          -m n  split file up by n milliseconds\n"
+               "          -u n  split file up by n microseconds\n"
+               "          -e n  split file up by n events\n"
+               "          -p n  split file up by n pages\n"
+               "          -r    repeat from start to end\n"
+               "          -c    per cpu, that is -p 2 will be 2 pages for each CPU\n"
+               "          if option is specified, it will split the file\n"
+               "           up starting at start, and ending at end\n"
+               "          start - decimal start time in seconds (ex: 75678.923853)\n"
+               "                  if left out, will start at beginning of file\n"
+               "          end   - decimal end time in seconds\n"
+               "\n"
                " %s list [-e][-p]\n"
                "          -e list available events\n"
                "          -p list available plugins\n"
                "          -o list available options\n"
-               "\n", p, VERSION_STRING, p, p, p, p, p, p, p);
+               "\n", p, VERSION_STRING, p, p, p, p, p, p, p, p);
         exit(-1);
 }
 
@@ -786,6 +801,9 @@ int main (int argc, char **argv)
         if (strcmp(argv[1], "report") == 0) {
                 trace_report(argc, argv);
                 exit(0);
+        } else if (strcmp(argv[1], "split") == 0) {
+                trace_split(argc, argv);
+                exit(0);
         } else if ((record = (strcmp(argv[1], "record") == 0)) ||
                    (strcmp(argv[1], "start") == 0) ||
                    ((extract = strcmp(argv[1], "extract") == 0))) {
diff --git a/trace-cmd.h b/trace-cmd.h
index 13d913a..98b4dec 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -49,6 +49,7 @@ int tracecmd_read_headers(struct tracecmd_input *handle);
 int tracecmd_long_size(struct tracecmd_input *handle);
 int tracecmd_page_size(struct tracecmd_input *handle);
 int tracecmd_cpus(struct tracecmd_input *handle);
+int tracecmd_copy_headers(struct tracecmd_input *handle, int fd);
 
 void tracecmd_print_events(struct tracecmd_input *handle);
 
@@ -94,6 +95,10 @@ struct tracecmd_output *tracecmd_create_file_latency(const char *output_file, in
 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);
+struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle,
+                                      const char *file);
+int tracecmd_append_cpu_data(struct tracecmd_output *handle,
+                             int cpus, char * const *cpu_data_files);
 
 /* --- Reading the Fly Recorder Trace --- */
 
diff --git a/trace-input.c b/trace-input.c
index ece0aab..0f2f7d8 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -16,7 +16,7 @@
 #include <ctype.h>
 #include <errno.h>
 
-#include "trace-cmd.h"
+#include "trace-cmd-local.h"
 #include "list.h"
 
 /* for debugging read instead of mmap */
@@ -1714,6 +1714,238 @@ void tracecmd_close(struct tracecmd_input *handle)
         free(handle);
 }
 
+static long long read_copy_size8(struct tracecmd_input *handle, int fd)
+{
+        long long size;
+
+        /* read size */
+        if (do_read_check(handle, &size, 8))
+                return -1;
+
+        if (__do_write_check(fd, &size, 8))
+                return -1;
+
+        size = __data2host8(handle->pevent, size);
+
+        return size;
+}
+
+static int read_copy_size4(struct tracecmd_input *handle, int fd)
+{
+        int size;
+
+        /* read size */
+        if (do_read_check(handle, &size, 4))
+                return -1;
+
+        if (__do_write_check(fd, &size, 4))
+                return -1;
+
+        size = __data2host4(handle->pevent, size);
+
+        return size;
+}
+
+static int read_copy_data(struct tracecmd_input *handle,
+                          unsigned long long size, int fd)
+{
+        char *buf;
+
+        buf = malloc(size);
+        if (!buf)
+                return -1;
+        if (do_read_check(handle, buf, size))
+                goto failed_read;
+
+        if (__do_write_check(fd, buf, size))
+                goto failed_read;
+        
+        free(buf);
+
+        return 0;
+
+ failed_read:
+        free(buf);
+        return -1;
+}
+
+static int copy_header_files(struct tracecmd_input *handle, int fd)
+{
+        long long size;
+
+        lseek64(handle->fd, handle->header_files_start, SEEK_SET);
+
+        /* "header_page"  */
+        if (read_copy_data(handle, 12, fd) < 0)
+                return -1;
+
+        size = read_copy_size8(handle, fd);
+        if (size < 0)
+                return -1;
+
+        if (read_copy_data(handle, size, fd) < 0)
+                return -1;
+
+        /* "header_event"  */
+        if (read_copy_data(handle, 13, fd) < 0)
+                return -1;
+
+        size = read_copy_size8(handle, fd);
+        if (size < 0)
+                return -1;
+
+        if (read_copy_data(handle, size, fd) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int copy_ftrace_files(struct tracecmd_input *handle, int fd)
+{
+        unsigned long long size;
+        int count;
+        int i;
+
+        count = read_copy_size4(handle, fd);
+        if (count < 0)
+                return -1;
+
+        for (i = 0; i < count; i++) {
+
+                size = read_copy_size8(handle, fd);
+                if (size < 0)
+                        return -1;
+
+                if (read_copy_data(handle, size, fd) < 0)
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int copy_event_files(struct tracecmd_input *handle, int fd)
+{
+        unsigned long long size;
+        char *system;
+        int systems;
+        int count;
+        int ret;
+        int i,x;
+
+        systems = read_copy_size4(handle, fd);
+        if (systems < 0)
+                return -1;
+
+        for (i = 0; i < systems; i++) {
+                system = read_string(handle);
+                if (!system)
+                        return -1;
+                if (__do_write_check(fd, system, strlen(system) + 1)) {
+                        free(system);
+                        return -1;
+                }
+                free(system);
+
+                count = read_copy_size4(handle, fd);
+                if (count < 0)
+                        return -1;
+
+                for (x=0; x < count; x++) {
+                        size = read_copy_size8(handle, fd);
+                        if (size < 0)
+                                return -1;
+
+                        ret = read_copy_data(handle, size, fd);
+                        if (ret < 0)
+                                return -1;
+                }
+        }
+
+        return 0;
+}
+
+static int copy_proc_kallsyms(struct tracecmd_input *handle, int fd)
+{
+        int size;
+
+        size = read_copy_size4(handle, fd);
+        if (!size)
+                return 0; /* OK? */
+
+        if (size < 0)
+                return -1;
+
+        if (read_copy_data(handle, size, fd) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int copy_ftrace_printk(struct tracecmd_input *handle, int fd)
+{
+        int size;
+
+        size = read_copy_size4(handle, fd);
+        if (!size)
+                return 0; /* OK? */
+
+        if (size < 0)
+                return -1;
+
+        if (read_copy_data(handle, size, fd) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int copy_command_lines(struct tracecmd_input *handle, int fd)
+{
+        unsigned long size;
+
+        size = read_copy_size8(handle, fd);
+        if (!size)
+                return 0; /* OK? */
+
+        if (size < 0)
+                return -1;
+
+        if (read_copy_data(handle, size, fd) < 0)
+                return -1;
+
+        return 0;
+}
+
+int tracecmd_copy_headers(struct tracecmd_input *handle, int fd)
+{
+        int ret;
+
+        ret = copy_header_files(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        ret = copy_ftrace_files(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        ret = copy_event_files(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        ret = copy_proc_kallsyms(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        ret = copy_ftrace_printk(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        ret = copy_command_lines(handle, fd);
+        if (ret < 0)
+                return -1;
+
+        return 0;
+}
+
 /**
  * tracecmd_long_size - return the size of "long" for the arch
  * @handle: input handle for the trace.dat file
diff --git a/trace-local.h b/trace-local.h
index 0be298f..9f49c24 100644
--- a/trace-local.h
+++ b/trace-local.h
@@ -12,4 +12,6 @@ int read_trace_files(void);
 
 void trace_report(int argc, char **argv);
 
+void trace_split(int argc, char **argv);
+
 #endif /* __TRACE_LOCAL_H */
diff --git a/trace-output.c b/trace-output.c
index 66f95fb..41477f5 100644
--- a/trace-output.c
+++ b/trace-output.c
@@ -16,7 +16,7 @@
 #include <ctype.h>
 #include <errno.h>
 
-#include "trace-cmd.h"
+#include "trace-cmd-local.h"
 #include "version.h"
 
 struct tracecmd_output {
@@ -26,36 +26,10 @@ struct tracecmd_output {
         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;
+        return __do_write_check(handle->fd, data, size);
 }
 
 void tracecmd_output_close(struct tracecmd_output *handle)
@@ -494,9 +468,11 @@ static int read_ftrace_printk(struct tracecmd_output *handle)
         return 0;
 }
 
-static struct tracecmd_output *create_file(const char *output_file, int cpus)
+static struct tracecmd_output *create_file(const char *output_file, int cpus,
+                                           struct tracecmd_input *ihandle)
 {
         struct tracecmd_output *handle;
+        struct pevent *pevent;
         char buf[BUFSIZ];
         char *file = NULL;
         struct stat st;
@@ -524,11 +500,21 @@ static struct tracecmd_output *create_file(const char *output_file, int cpus)
         if (do_write_check(handle, FILE_VERSION_STRING, strlen(FILE_VERSION_STRING) + 1))
                 goto out_free;
 
-        /* save endian */
-        if (tracecmd_host_bigendian())
-                buf[0] = 1;
-        else
-                buf[0] = 0;
+        /* get endian and page size */
+        if (ihandle) {
+                pevent = tracecmd_get_pevent(ihandle);
+                if (pevent->file_bigendian)
+                        buf[0] = 1;
+                else
+                        buf[0] = 0;
+                handle->page_size = tracecmd_page_size(ihandle);
+        } else {
+                if (tracecmd_host_bigendian())
+                        buf[0] = 1;
+                else
+                        buf[0] = 0;
+                handle->page_size = getpagesize();
+        }
 
         if (do_write_check(handle, buf, 1))
                 goto out_free;
@@ -538,11 +524,12 @@ static struct tracecmd_output *create_file(const char *output_file, int cpus)
         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 (ihandle)
+                return handle;
+
         if (read_header_files(handle))
                 goto out_free;
         if (read_ftrace_files(handle))
@@ -577,9 +564,6 @@ static struct tracecmd_output *create_file(const char *output_file, int cpus)
         put_tracing_file(file);
         file = NULL;
 
-        if (do_write_check(handle, &cpus, 4))
-                goto out_free;
-
         return handle;
 
  out_free:
@@ -592,10 +576,13 @@ struct tracecmd_output *tracecmd_create_file_latency(const char *output_file, in
         struct tracecmd_output *handle;
         char *path;
 
-        handle = create_file(output_file, cpus);
+        handle = create_file(output_file, cpus, NULL);
         if (!handle)
                 return NULL;
 
+        if (do_write_check(handle, &cpus, 4))
+                goto out_free;
+
         if (do_write_check(handle, "latency  ", 10))
                 goto out_free;
 
@@ -614,22 +601,20 @@ out_free:
         return NULL;
 }
 
-struct tracecmd_output *tracecmd_create_file(const char *output_file,
-                                             int cpus, char * const *cpu_data_files)
+int tracecmd_append_cpu_data(struct tracecmd_output *handle,
+                             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;
+        char *file;
         struct stat st;
         int ret;
         int i;
 
-        handle = create_file(output_file, cpus);
-        if (!handle)
-                return NULL;
+        if (do_write_check(handle, &cpus, 4))
+                goto out_free;
 
         if (do_write_check(handle, "flyrecord", 10))
                 goto out_free;
@@ -648,17 +633,12 @@ struct tracecmd_output *tracecmd_create_file(const char *output_file,
         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);
+                file = cpu_data_files[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;
@@ -689,13 +669,58 @@ struct tracecmd_output *tracecmd_create_file(const char *output_file,
         free(offsets);
         free(sizes);
 
-        return handle;
+        return 0;
 
  out_free:
-        free(file);
         free(offsets);
         free(sizes);
 
         tracecmd_output_close(handle);
+        return -1;
+}
+
+struct tracecmd_output *tracecmd_create_file(const char *output_file,
+                                             int cpus, char * const *cpu_data_files)
+{
+        struct tracecmd_output *handle;
+
+        handle = create_file(output_file, cpus, NULL);
+        if (!handle)
+                return NULL;
+
+        if (tracecmd_append_cpu_data(handle, cpus, cpu_data_files) < 0) {
+                free(handle);
+                return NULL;
+        }
+
+        return handle;
+}
+
+/**
+ * tracecmd_copy - copy the headers of one trace.dat file for another
+ * @ihandle: input handle of the trace.dat file to copy
+ * @file: the trace.dat file to create
+ *
+ * Reads the header information and creates a new trace data file
+ * with the same characteristics (events and all) and returns
+ * tracecmd_output handle to this new file.
+ */
+struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle,
+                                      const char *file)
+{
+        struct tracecmd_output *handle;
+
+        handle = create_file(file, tracecmd_cpus(ihandle), ihandle);
+        if (!handle)
+                return NULL;
+
+        if (tracecmd_copy_headers(ihandle, handle->fd) < 0)
+                goto out_free;
+
+        /* The file is all ready to have cpu data attached */
+        return handle;
+
+out_free:
+        tracecmd_output_close(handle);
         return NULL;
 }
diff --git a/trace-split.c b/trace-split.c
new file mode 100644
index 0000000..96cda2d
--- /dev/null
+++ b/trace-split.c
@@ -0,0 +1,514 @@
+/*
+ * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#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-local.h"
+
+static unsigned int page_size;
+static const char *default_input_file = "trace.dat";
+static const char *input_file;
+
+enum split_types {
+        SPLIT_NONE,
+        /* The order of these must be reverse of the case statement in the options */
+        SPLIT_SECONDS,
+        SPLIT_MSECS,
+        SPLIT_USECS,
+        SPLIT_EVENTS,
+        SPLIT_PAGES,
+        SPLIT_NR_TYPES,
+};
+
+struct cpu_data {
+        unsigned long long              ts;
+        unsigned long long              offset;
+        struct record                   *record;
+        int                             cpu;
+        int                             fd;
+        int                             index;
+        void                            *commit;
+        void                            *page;
+        char                            *file;
+};
+
+static int create_type_len(struct pevent *pevent, int time, int len)
+{
+        static int bigendian = -1;
+        char *ptr;
+        int test;
+
+        if (bigendian < 0) {
+                test = 0x4321;
+                ptr = (char *)&test;
+                if (*ptr == 0x12)
+                        bigendian = 0;
+                else
+                        bigendian = 1;
+        }
+
+        if (pevent->file_bigendian)
+                time |= (len << 27);
+        else
+                time = (time << 5) | len;
+
+        return __data2host4(pevent, time);
+}
+
+static int write_record(struct tracecmd_input *handle,
+                        struct record *record,
+                        struct cpu_data *cpu_data,
+                        enum split_types type)
+{
+        unsigned long long diff;
+        struct pevent *pevent;
+        void *page;
+        int len;
+        char *ptr;
+        int index = 0;
+        int time;
+
+        page = cpu_data->page;
+
+        pevent = tracecmd_get_pevent(handle);
+
+        ptr = page + cpu_data->index;
+
+        diff = record->ts - cpu_data->ts;
+        if (diff > (1 << 27)) {
+                /* Add a time stamp */
+                len = RINGBUF_TYPE_TIME_EXTEND;
+                time = (unsigned int)(diff & ((1ULL << 27) - 1));
+                time = create_type_len(pevent, time, len);
+                *(unsigned *)ptr = time;
+                ptr += 4;
+                time = (unsigned int)(diff >> 27);
+                *(unsigned *)ptr = __data2host4(pevent, time);
+                cpu_data->ts = record->ts;
+                cpu_data->index += 8;
+                return 0;
+        }
+
+        if (record->size) {
+                if (record->size < 28 * 4)
+                        len = record->size / 4;
+                else
+                        len = 0;
+        }
+
+        time = (unsigned)diff;
+        time = create_type_len(pevent, time, len);
+
+        memcpy(ptr, &time, 4);
+        ptr += 4;
+        index = 4;
+
+        if (!len) {
+                len = record->size / 4;
+                len += 4;
+                memcpy(ptr, &len, 4);
+                ptr += 4;
+                index += 4;
+        }
+
+        len = (record->size + 3) & ~3;
+        index += len;
+
+        memcpy(ptr, record->data, len);
+
+        cpu_data->index += index;
+        cpu_data->ts = record->ts;
+
+        return 1;
+}
+
+static void write_page(struct cpu_data *cpu_data, int long_size)
+{
+        if (long_size == 8)
+                *(unsigned long long *)cpu_data->commit =
+                        (unsigned long long)cpu_data->index;
+        else
+                *(unsigned int *)cpu_data->commit =
+                        cpu_data->index;
+        write(cpu_data->fd, cpu_data->page, page_size);
+}
+
+static struct record *read_record(struct tracecmd_input *handle,
+                                  int percpu, int *cpu)
+{
+        if (percpu)
+                return tracecmd_read_data(handle, *cpu);
+
+        return tracecmd_read_next_data(handle, cpu);
+}
+
+static int parse_cpu(struct tracecmd_input *handle,
+                     struct cpu_data *cpu_data,
+                     unsigned long long start,
+                     unsigned long long end,
+                     int count_limit, int percpu, int cpu,
+                     enum split_types type)
+{
+        struct record *record;
+        struct pevent *pevent;
+        void *ptr;
+        int page_size;
+        int long_size = 0;
+        int cpus;
+        int count = 0;
+        int pages = 0;
+
+        cpus = tracecmd_cpus(handle);
+
+        long_size = tracecmd_long_size(handle);
+        page_size = tracecmd_page_size(handle);
+        pevent = tracecmd_get_pevent(handle);
+
+        /* Force new creation of first page */
+        if (percpu) {
+                cpu_data[cpu].index = page_size + 1;
+                cpu_data[cpu].page = NULL;
+        } else {
+                for (cpu = 0; cpu < cpus; cpu++) {
+                        cpu_data[cpu].index = page_size + 1;
+                        cpu_data[cpu].page = NULL;
+                }
+        }
+
+        /*
+         * Get the cpu pointers up to the start of the
+         * start time stamp.
+         */
+
+        record = read_record(handle, percpu, &cpu);
+
+        if (start) {
+                while (record && record->ts < start) {
+                        free_record(record);
+                        record = read_record(handle, percpu, &cpu);
+                }
+        } else if (record)
+                start = record->ts;
+
+        while (record && (!end || record->ts <= end)) {
+                if (cpu_data[cpu].index + record->record_size > page_size) {
+                        if (cpu_data[cpu].page)
+                                write_page(&cpu_data[cpu], long_size);
+                        else
+                                cpu_data[cpu].page = malloc_or_die(page_size);
+
+                        if (type == SPLIT_PAGES && pages++ > count_limit)
+                                break;
+
+                        memset(cpu_data[cpu].page, 0, page_size);
+                        ptr = cpu_data[cpu].page;
+
+                        *(unsigned long long*)ptr =
+                                __data2host8(pevent, record->ts);
+                        cpu_data[cpu].ts = record->ts;
+                        ptr += 8;
+                        cpu_data[cpu].commit = ptr;
+                        ptr += long_size;
+                        cpu_data[cpu].index = 8 + long_size;
+                }
+
+                cpu_data[cpu].offset = record->offset;
+
+                if (write_record(handle, record, &cpu_data[cpu], type)) {
+                        free_record(record);
+                        record = read_record(handle, percpu, &cpu);
+
+                        /* if we hit the end of the cpu, clear the offset */
+                        if (!record) {
+                                if (percpu)
+                                        cpu_data[cpu].offset = 0;
+                                else
+                                        for (cpu = 0; cpu < cpus; cpu++)
+                                                cpu_data[cpu].offset = 0;
+                        }
+
+                        switch (type) {
+                        case SPLIT_NONE:
+                                break;
+                        case SPLIT_SECONDS:
+                                if (record &&
+                                    record->ts >
+                                    (start + (unsigned long long)count_limit * 1000000000ULL)) {
+                                        free_record(record);
+                                        record = NULL;
+                                }
+                                break;
+                        case SPLIT_MSECS:
+                                if (record &&
+                                    record->ts >
+                                    (start + (unsigned long long)count_limit * 1000000ULL)) {
+                                        free_record(record);
+                                        record = NULL;
+                                }
+                                break;
+                        case SPLIT_USECS:
+                                if (record &&
+                                    record->ts >
+                                    (start + (unsigned long long)count_limit * 1000ULL)) {
+                                        free_record(record);
+                                        record = NULL;
+                                }
+                                break;
+                        case SPLIT_EVENTS:
+                                if (++count >= count_limit) {
+                                        free_record(record);
+                                        record = NULL;
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        }
+
+        if (record)
+                free_record(record);
+
+        if (percpu) {
+                if (cpu_data[cpu].page) {
+                        write_page(&cpu_data[cpu], long_size);
+                        free(cpu_data[cpu].page);
+                        cpu_data[cpu].page = NULL;
+                }
+        } else {
+                for (cpu = 0; cpu < cpus; cpu++) {
+                        if (cpu_data[cpu].page) {
+                                write_page(&cpu_data[cpu], long_size);
+                                free(cpu_data[cpu].page);
+                                cpu_data[cpu].page = NULL;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+static double parse_file(struct tracecmd_input *handle,
+                         const char *output_file,
+                         unsigned long long start,
+                         unsigned long long end, int percpu,
+                         int count, enum split_types type)
+{
+        unsigned long long current;
+        struct tracecmd_output *ohandle;
+        struct cpu_data *cpu_data;
+        struct record *record;
+        char **cpu_list;
+        char *file;
+        int cpus;
+        int cpu;
+        int fd;
+
+        ohandle = tracecmd_copy(handle, output_file);
+
+        cpus = tracecmd_cpus(handle);
+        cpu_data = malloc_or_die(sizeof(*cpu_data) * cpus);
+
+        for (cpu = 0; cpu < cpus; cpu++) {
+                file = malloc_or_die(strlen(output_file) + 50);
+                sprintf(file, ".tmp.%s.%d", output_file, cpu);
+                fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
+                cpu_data[cpu].cpu = cpu;
+                cpu_data[cpu].fd = fd;
+                cpu_data[cpu].file = file;
+                cpu_data[cpu].offset = 0;
+                if (start)
+                        tracecmd_set_cpu_to_timestamp(handle, cpu, start);
+        }
+
+        if (percpu) {
+                for (cpu = 0; cpu < cpus; cpu++)
+                        parse_cpu(handle, cpu_data, start,
+                                  end, count, percpu, cpu, type);
+        } else
+                parse_cpu(handle, cpu_data, start,
+                          end, count, percpu, -1, type);
+
+        cpu_list = malloc_or_die(sizeof(*cpu_list) * cpus);
+        for (cpu = 0; cpu < cpus; cpu ++)
+                cpu_list[cpu] = cpu_data[cpu].file;
+
+        tracecmd_append_cpu_data(ohandle, cpus, cpu_list);
+
+        current = end;
+        for (cpu = 0; cpu < cpus; cpu++) {
+                /* Set the tracecmd cursor to the next set of records */
+                if (cpu_data[cpu].offset) {
+                        record = tracecmd_read_at(handle, cpu_data[cpu].offset, NULL);
+                        if (record && (!current || record->ts > current))
+                                current = record->ts + 1;
+                        free_record(record);
+                }
+                unlink(cpu_data[cpu].file);
+                free(cpu_data[cpu].file);
+        }
+        free(cpu_data);
+        free(cpu_list);
+        tracecmd_output_close(ohandle);
+
+        return current;
+}
+
+void trace_split (int argc, char **argv)
+{
+        struct tracecmd_input *handle;
+        struct pevent *pevent;
+        unsigned long long start_ns = 0, end_ns = 0;
+        unsigned long long current;
+        double start, end;
+        char *output = NULL;
+        char *output_file;
+        enum split_types split_type = SPLIT_NONE;
+        enum split_types type = SPLIT_NONE;
+        int count;
+        int repeat = 0;
+        int percpu = 0;
+        int cpu = -1;
+        int ac;
+        int c;
+
+        if (strcmp(argv[1], "split") != 0)
+                usage(argv);
+
+        while ((c = getopt(argc-1, argv+1, "+ho:i:s:m:u:e:p:rcC:")) >= 0) {
+                switch (c) {
+                case 'h':
+                        usage(argv);
+                        break;
+                case 'p':
+                        type++;
+                case 'e':
+                        type++;
+                case 'u':
+                        type++;
+                case 'm':
+                        type++;
+                case 's':
+                        type++;
+                        if (split_type != SPLIT_NONE)
+                                die("Only one type of split is allowed");
+                        count = atoi(optarg);
+                        split_type = type;
+                        break;
+                case 'r':
+                        repeat = 1;
+                        break;
+                case 'c':
+                        percpu = 1;
+                        break;
+                case 'C':
+                        cpu = atoi(optarg);
+                        break;
+                case 'o':
+                        if (output)
+                                die("only one output file allowed");
+                        output = strdup(optarg);
+                        break;
+                case 'i':
+                        input_file = optarg;
+                        break;
+                default:
+                        usage(argv);
+                }
+        }
+
+        ac = (argc - optind);
+
+        if (ac >= 2) {
+                optind++;
+                start = strtod(argv[optind], NULL);
+                if (ac > 3)
+                        usage(argv);
+
+                start_ns = (unsigned long long)(start * 1000000000.0);
+                optind++;
+                if (ac == 3) {
+                        end = strtod(argv[optind], NULL);
+                        end_ns = (unsigned long long)(end * 1000000000.0);
+                        if (end_ns < start_ns)
+                                die("Error: end is less than start");
+                }
+        }
+
+        if (!input_file)
+                input_file = default_input_file;
+
+        handle = tracecmd_open(input_file);
+        if (!handle)
+                die("error reading %s", input_file);
+
+        page_size = tracecmd_page_size(handle);
+
+        pevent = tracecmd_get_pevent(handle);
+
+        if (!output) {
+                if (repeat)
+                        output = strdup(input_file);
+                else {
+                        output = malloc_or_die(strlen(input_file) + 3);
+                        sprintf(output, "%s.1", input_file);
+                }
+        }
+
+        current = start_ns;
+        output_file = malloc_or_die(strlen(output) + 50);
+        c = 1;
+
+        do {
+                if (repeat)
+                        sprintf(output_file, "%s.%04d", output, c++);
+                else
+                        strcpy(output_file, output);
+                        
+                current = parse_file(handle, output_file, start_ns, end_ns,
+                                     percpu, count, type);
+                if (!repeat)
+                        break;
+                start_ns = 0;
+        } while (current && (!end_ns || current < end_ns));
+
+        free(output);
+        free(output_file);
+
+        tracecmd_close(handle);
+
+        return;
+}