trace-cmd: Add trace-cmd restore

The restore feature now allows you to make a trace.dat file from
several trace.dat.cpu.X files. This will let you put together files
leftover from a crashed trace-cmd record run.

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

9 files changed, 260 insertions, 9 deletions

diff --git a/Documentation/trace-cmd-restore.1.txt b/Documentation/trace-cmd-restore.1.txt
new file mode 100644
index 0000000..6fd6ba4
--- /dev/null
+++ b/Documentation/trace-cmd-restore.1.txt
@@ -0,0 +1,90 @@
+TRACE-CMD-RESTORE(1)
+====================
+
+NAME
+----
+trace-cmd-restore - restore a failed trace record
+
+SYNOPSIS
+--------
+*trace-cmd restore* ['OPTIONS'] ['command'] cpu-file [cpu-file ...]
+
+DESCRIPTION
+-----------
+The trace-cmd(1) restore command will restore a crashed trace-cmd-record(1)
+file. If for some reason a trace-cmd record fails, it will leave a the
+per-cpu data files and not create the final trace.dat file. The trace-cmd
+restore will append the files to create a working trace.dat file that can
+be read with trace-cmd-report(1).
+
+When trace-cmd record runs, it spawns off a process per CPU and writes
+to a per cpu file usually called 'trace.dat.cpuX', where X represents the
+CPU number that it is tracing. If the -o option was used in the trace-cmd
+record, then the CPU data files will have that name instead of the
+'trace.dat' name. If a unexpected crash occurs before the tracing
+is finished, then the per CPU files will still exist but there will
+not be any trace.dat file to read from. trace-cmd restore will allow you
+to create a trace.dat file with the existing data files.
+
+OPTIONS
+-------
+*-c*::
+    Create a partial trace.dat file from the machine, to be used with
+    a full trace-cmd restore at another time. This option is useful for
+    embedded devices. If a server contains the cpu files of a crashed
+    trace-cmd record (or trace-cmd listen), trace-cmd restore can be
+    executed on the embedded device with the -c option to get all the
+    stored information of that embedded device. Then the file created
+    could be copied to the server to run the trace-cmd restore there
+    with the cpu files.
+
+    If *-o* is not specified, then the file created will be called
+    'trace-partial.dat'. This is because the file is not a full version
+    of something that trace-cmd-report(1) could use.
+
+*-o* output'::
+    By default, trace-cmd restore will create a 'trace.dat' file
+    (or 'trace-partial.dat' if *-c* is specified). You can
+    specify a different file to write to with the *-o* option.
+
+*-i* input::
+    By default, trace-cmd restore will read the information of the
+    current system to create the initial data stored in the 'trace.dat'
+    file. If the crash was on another machine, then that machine should
+    have the trace-cmd restore run with the *-c* option to create the
+    trace.dat partial file. Then that file can be copied to the current
+    machine where trace-cmd restore will use *-i* to load that file
+    instead of reading from the current system.
+
+EXAMPLES
+--------
+
+If a crash happened on another box, you could run:
+
+   $ trace-cmd restore -c -o box-partial.dat
+
+Then on the server that has the cpu files:
+
+   $ trace-cmd restore -i box-partial.dat trace.dat.cpu0 trace.dat.cpu1
+
+This would create a trace.dat file for the embedded box.
+
+SEE ALSO
+--------
+trace-cmd(1), trace-cmd-record(1), trace-cmd-report(1), trace-cmd-start(1),
+trace-cmd-stop(1), trace-cmd-extract(1), trace-cmd-reset(1), trace-cmd-split(1),
+trace-cmd-list(1), trace-cmd-listen(1)
+
+AUTHOR
+------
+Written by Steven Rostedt, <rostedt@goodmis.org>
+
+RESOURCES
+---------
+git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
+
+COPYING
+-------
+Copyright \(C) 2010 Red Hat, Inc. Free use of this software is granted under
+the terms of the GNU Public License (GPL).
+
diff --git a/Documentation/trace-cmd.1.txt b/Documentation/trace-cmd.1.txt
index fb4cadd..14c543c 100644
--- a/Documentation/trace-cmd.1.txt
+++ b/Documentation/trace-cmd.1.txt
@@ -43,6 +43,8 @@ COMMANDS
 
   listen  - open up a port to listen for remote tracing connections.
 
+  restore  - restore the data files of a crashed run of trace-cmd record
+
 
 OPTIONS
 -------
@@ -56,6 +58,7 @@ SEE ALSO
 --------
 trace-cmd-record(1), trace-cmd-report(1), trace-cmd-start(1),
 trace-cmd-stop(1), trace-cmd-extract(1), trace-cmd-reset(1),
+trace-cmd-restore(1),
 trace-cmd-split(1), trace-cmd-list(1), trace-cmd-listen(1),
 trace-cmd.dat(5)
 
diff --git a/Makefile b/Makefile
index 54a8b29..c72dda6 100644
--- a/Makefile
+++ b/Makefile
@@ -262,7 +262,7 @@ KERNEL_SHARK_OBJS = $(TRACE_VIEW_OBJS) $(TRACE_GRAPH_OBJS) $(TRACE_GUI_OBJS) \
 
 PEVENT_LIB_OBJS = parse-events.o trace-seq.o parse-filter.o parse-utils.o
 TCMD_LIB_OBJS = $(PEVENT_LIB_OBJS) trace-util.o trace-input.o trace-ftrace.o \
-                        trace-output.o trace-record.o
+                        trace-output.o trace-record.o trace-restore.o
 
 PLUGIN_OBJS = plugin_hrtimer.o plugin_kmem.o plugin_sched_switch.o \
         plugin_mac80211.o plugin_jbd2.o plugin_function.o
diff --git a/trace-cmd.c b/trace-cmd.c
index 7afc5ac..6fbac8c 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -1429,6 +1429,9 @@ int main (int argc, char **argv)
         } else if (strcmp(argv[1], "split") == 0) {
                 trace_split(argc, argv);
                 exit(0);
+        } else if (strcmp(argv[1], "restore") == 0) {
+                trace_restore(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 d8ebccd..b2586bf 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -160,6 +160,7 @@ 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);
 struct tracecmd_output *tracecmd_create_init_fd(int fd);
+struct tracecmd_output *tracecmd_create_init_file(const char *output_file);
 void tracecmd_output_close(struct tracecmd_output *handle);
 struct tracecmd_output *tracecmd_copy(struct tracecmd_input *ihandle,
                                       const char *file);
diff --git a/trace-local.h b/trace-local.h
index 60b8b5e..0ae798d 100644
--- a/trace-local.h
+++ b/trace-local.h
@@ -42,4 +42,6 @@ void trace_split(int argc, char **argv);
 
 void trace_listen(int argc, char **argv);
 
+void trace_restore(int argc, char **argv);
+
 #endif /* __TRACE_LOCAL_H */
diff --git a/trace-output.c b/trace-output.c
index c34e8b2..14fe0f1 100644
--- a/trace-output.c
+++ b/trace-output.c
@@ -860,16 +860,14 @@ struct tracecmd_output *tracecmd_create_file(const char *output_file,
         return handle;
 }
 
-struct tracecmd_output *
-tracecmd_create_init_fd(int fd)
+struct tracecmd_output *tracecmd_create_init_fd(int fd)
 {
-        struct tracecmd_output *handle;
-
-        handle = create_file_fd(fd, NULL);
-        if (!handle)
-                return NULL;
+        return create_file_fd(fd, NULL);
+}
 
-        return handle;
+struct tracecmd_output *tracecmd_create_init_file(const char *output_file)
+{
+        return create_file(output_file, NULL);
 }
 
 /**
diff --git a/trace-restore.c b/trace-restore.c
new file mode 100644
index 0000000..cf8c14f
--- /dev/null
+++ b/trace-restore.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, 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 <signal.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "trace-local.h"
+
+void trace_restore (int argc, char **argv)
+{
+        struct tracecmd_output *handle;
+        const char *output_file = "trace.dat";
+        const char *output = NULL;
+        const char *input = NULL;
+        struct stat st1;
+        struct stat st2;
+        int first_arg;
+        int create_only = 0;
+        int args;
+        int c;
+
+        if (argc < 2)
+                usage(argv);
+
+        if (strcmp(argv[1], "restore") != 0)
+                usage(argv);
+
+        while ((c = getopt(argc-1, argv+1, "+hco:i:")) >= 0) {
+                switch (c) {
+                case 'h':
+                        usage(argv);
+                        break;
+                case 'c':
+                        if (input)
+                                die("-c and -i are incompatible");
+                        create_only = 1;
+                        /* make output default to partial */
+                        output_file = "trace-partial.dat";
+                        break;
+
+                case 'o':
+                        if (output)
+                                die("only one output file allowed");
+                        output = optarg;
+                        break;
+
+                case 'i':
+                        if (input)
+                                die("only one input file allowed");
+                        if (create_only)
+                                die("-c and -i are incompatible");
+                        input = optarg;
+                        break;
+
+                default:
+                        usage(argv);
+                }
+        }
+
+        if (!output)
+                output = output_file;
+
+        if ((argc - optind) <= 1) {
+                if (!create_only) {
+                        warning("No data files found");
+                        usage(argv);
+                }
+
+                handle = tracecmd_create_init_file(output);
+                if (!handle)
+                        die("Unabled to create output file %s", output);
+                tracecmd_output_close(handle);
+                exit(0);
+        }
+        first_arg = optind + 1;
+        args = argc - first_arg;
+        printf("first = %d %s args=%d\n", first_arg, argv[first_arg], args);
+
+        /* Make sure input and output are not the same file */
+        if (input && output) {
+                if (stat(input, &st1) < 0)
+                        die("%s:", input);
+                /* output exists? otherwise we don't care */
+                if (stat(output, &st2) == 0) {
+                        if (st1.st_ino == st2.st_ino &&
+                            st1.st_dev == st2.st_dev)
+                                die("input and output file are the same");
+                }
+        }
+
+        if (input) {
+                struct tracecmd_input *ihandle;
+
+                ihandle = tracecmd_alloc(input);
+                if (!ihandle)
+                        die("error reading file %s", input);
+                /* make sure headers are ok */
+                if (tracecmd_read_headers(ihandle) < 0)
+                        die("error reading file %s headers", input);
+
+                handle = tracecmd_copy(ihandle, output);
+                tracecmd_close(ihandle);
+        } else
+                handle = tracecmd_create_init_file(output);
+
+        if (!handle)
+                die("error writing to %s", output);
+
+        if (tracecmd_append_cpu_data(handle, args, &argv[first_arg]) < 0)
+                die("failed to append data");
+
+        return;
+}
diff --git a/trace-usage.c b/trace-usage.c
index 8f70f29..5dd691c 100644
--- a/trace-usage.c
+++ b/trace-usage.c
@@ -123,6 +123,14 @@ static struct usage_help usage_help[] = {
                 "          -o list available options\n"
         },
         {
+                "restore",
+                "restore a crashed record",
+                " %s restore [-c][-o file][-i file] cpu-file [cpu-file ...]\n"
+                "          -c create a partial trace.dat file only\n"
+                "          -o output file\n"
+                "          -i parital trace.dat file for input\n"
+        },
+        {
                 NULL, NULL, NULL
         }
 };