trace-cmd: Do not use threads for extract

Currently the trace-cmd extract function uses the forked threads to
read the data from the ring buffers. As this is not a live trace and
the program does not end till all the buffers are flushed to disk,
there is no need to use the threads. Just serially read each buffer
into a file and then pull them together normally.

This also fixes a bug that was triggered in the kernel where reading
the trace_pipe_raw file after EOF will yield the last page again,
causing the trace-cmd extract to produce duplicate pages.

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

3 files changed, 70 insertions, 76 deletions

diff --git a/trace-cmd.h b/trace-cmd.h
index 5a7c6c0..3f522ee 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -213,6 +213,7 @@ struct tracecmd_recorder *tracecmd_create_recorder_fd(int fd, int cpu);
 int tracecmd_start_recording(struct tracecmd_recorder *recorder, unsigned long sleep);
 void tracecmd_stop_recording(struct tracecmd_recorder *recorder);
 void tracecmd_stat_cpu(struct trace_seq *s, int cpu);
+long tracecmd_flush_recording(struct tracecmd_recorder *recorder);
 
 /* --- Plugin handling --- */
 extern struct plugin_option trace_ftrace_options[];
diff --git a/trace-record.c b/trace-record.c
index 90589cf..bf48e03 100644
--- a/trace-record.c
+++ b/trace-record.c
@@ -219,11 +219,15 @@ static void delete_thread_data(void)
                 return;
 
         for (i = 0; i < cpu_count; i++) {
-                if (pids[i]) {
+                if (pids) {
+                        if (pids[i]) {
+                                delete_temp_file(i);
+                                if (pids[i] < 0)
+                                        pids[i] = 0;
+                        }
+                } else
+                        /* Extract does not allocate pids */
                         delete_temp_file(i);
-                        if (pids[i] < 0)
-                                pids[i] = 0;
-                }
         }
 }
 
@@ -243,16 +247,20 @@ static void stop_threads(void)
         }
 }
 
+static int create_recorder(int cpu, int extract);
+
 static void flush_threads(void)
 {
+        long ret;
         int i;
 
         if (!cpu_count)
                 return;
 
         for (i = 0; i < cpu_count; i++) {
-                if (pids[i] > 0)
-                        kill(pids[i], SIGUSR1);
+                ret = create_recorder(i, 1);
+                if (ret < 0)
+                        die("error reading ring buffer");
         }
 }
 
@@ -1270,25 +1278,32 @@ static void set_prio(int prio)
                 warning("failed to set priority");
 }
 
-static int create_recorder(int cpu)
+/*
+ * If extract is set, then this is going to set up the recorder,
+ * connections and exit as the tracing is serialized by a single thread.
+ */
+static int create_recorder(int cpu, int extract)
 {
+        long ret;
         char *file;
         int pid;
 
-        signal(SIGUSR1, flush);
+        if (!extract) {
+                signal(SIGUSR1, flush);
 
-        pid = fork();
-        if (pid < 0)
-                die("fork");
+                pid = fork();
+                if (pid < 0)
+                        die("fork");
 
-        if (pid)
-                return pid;
+                if (pid)
+                        return pid;
 
-        if (rt_prio)
-                set_prio(rt_prio);
+                if (rt_prio)
+                        set_prio(rt_prio);
 
-        /* do not kill tasks on error */
-        cpu_count = 0;
+                /* do not kill tasks on error */
+                cpu_count = 0;
+        }
 
         if (client_ports) {
                 connect_port(cpu);
@@ -1301,6 +1316,13 @@ static int create_recorder(int cpu)
 
         if (!recorder)
                 die ("can't create recorder");
+
+        if (extract) {
+                ret = tracecmd_flush_recording(recorder);
+                tracecmd_free_recorder(recorder);
+                return ret;
+        }
+
         while (!finished) {
                 if (tracecmd_start_recording(recorder, sleep_time) < 0)
                         break;
@@ -1448,7 +1470,7 @@ static void start_threads(void)
         memset(pids, 0, sizeof(*pids) * cpu_count);
 
         for (i = 0; i < cpu_count; i++) {
-                pids[i] = create_recorder(i);
+                pids[i] = create_recorder(i, 0);
         }
 }
 
@@ -1493,44 +1515,6 @@ static void record_data(char *date2ts)
         tracecmd_output_close(handle);
 }
 
-static int trace_empty(void)
-{
-        char *path;
-        FILE *fp;
-        char *line = NULL;
-        size_t size;
-        ssize_t n;
-        int ret = 1;
-        
-        /*
-         * Test if the trace file is empty.
-         *
-         * Yes, this is a heck of a hack. What is done here
-         * is to read the trace file and ignore the
-         * lines starting with '#', and if we get a line
-         * that is without a '#' the trace is not empty.
-         * Otherwise it is.
-         */
-        path = tracecmd_get_tracing_file("trace");
-        fp = fopen(path, "r");
-        if (!fp)
-                die("reading '%s'", path);
-
-        do {
-                n = getline(&line, &size, fp);
-                if (n > 0 && line && line[0] != '#') {
-                        ret = 0;
-                        break;
-                }
-        } while (line && n > 0);
-
-        tracecmd_put_tracing_file(path);
-
-        fclose(fp);
-
-        return ret;
-}
-
 static void write_func_file(const char *file, struct func_list **list)
 {
         struct func_list *item;
@@ -2202,17 +2186,15 @@ void trace_record (int argc, char **argv)
 
         s = malloc_or_die(sizeof(*s) * cpu_count);
 
-        if (record || extract) {
+        if (record) {
                 signal(SIGINT, finish);
                 if (!latency)
                         start_threads();
         }
 
         if (extract) {
-                while (!finished && !trace_empty()) {
-                        flush_threads();
-                        sleep(1);
-                }
+                flush_threads();
+
         } else {
                 if (!record) {
                         update_task_filter();
@@ -2233,10 +2215,9 @@ void trace_record (int argc, char **argv)
                 }
 
                 disable_tracing();
+                stop_threads();
         }
 
-        stop_threads();
-
         for (cpu = 0; cpu < cpu_count; cpu++) {
                 trace_seq_init(&s[cpu]);
                 trace_seq_printf(&s[cpu], "CPU: %d\n", cpu);
@@ -2263,7 +2244,6 @@ void trace_record (int argc, char **argv)
         record_data(date2ts);
         delete_thread_data();
 
-
         if (keep)
                 exit(0);
 
diff --git a/trace-recorder.c b/trace-recorder.c
index e57ef9b..4a01fb9 100644
--- a/trace-recorder.c
+++ b/trace-recorder.c
@@ -156,10 +156,32 @@ static long splice_data(struct tracecmd_recorder *recorder)
         return ret;
 }
 
+long tracecmd_flush_recording(struct tracecmd_recorder *recorder)
+{
+        char *buf[recorder->page_size];
+        long total = 0;
+        long ret;
+
+        do {
+                ret = splice_data(recorder);
+                if (ret < 0)
+                        return ret;
+                total += ret;
+        } while (ret);
+
+        /* 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 total;
+}
+
 int tracecmd_start_recording(struct tracecmd_recorder *recorder, unsigned long sleep)
 {
         struct timespec req;
-        char *buf[recorder->page_size];
         long ret;
 
         recorder->stop = 0;
@@ -175,21 +197,12 @@ int tracecmd_start_recording(struct tracecmd_recorder *recorder, unsigned long s
                         return ret;
         } while (!recorder->stop);
 
-        /* Flush via splice first */
-        do {
-                ret = splice_data(recorder);
-        } while (ret > 0);
+        /* Flush out the rest */
+        ret = tracecmd_flush_recording(recorder);
 
         if (ret < 0)
                 return ret;
 
-        /* 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;
 }