Merge branch 'trace-cmd' into trace-view

Fixed up the trace-graph and trace-cmd view to handle the new
API

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

12 files changed, 323 insertions, 114 deletions

diff --git a/parse-events.c b/parse-events.c
index 49cde00..24ecb85 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -3113,13 +3113,14 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
  * and lock depth) and places it into the trace_seq.
  */
 void pevent_data_lat_fmt(struct pevent *pevent,
-                         struct trace_seq *s, void *data, int size __unused)
+                         struct trace_seq *s, struct record *record)
 {
         unsigned int lat_flags;
         unsigned int pc;
         int lock_depth;
         int hardirq;
         int softirq;
+        void *data = record->data;
 
         lat_flags = parse_common_flags(pevent, data);
         pc = parse_common_pc(pevent, data);
@@ -3215,30 +3216,32 @@ const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
  * writes the print format into the trace_seq.
  */
 void pevent_event_info(struct trace_seq *s, struct event_format *event,
-                       int cpu, void *data, int size, unsigned long long nsecs)
+                       struct record *record)
 {
         if (event->handler)
-                event->handler(s, data, size, event, cpu, nsecs);
+                event->handler(s, record, event);
         else
-                pretty_print(s, data, size, event);
+                pretty_print(s, record->data, record->size, event);
 
         trace_seq_terminate(s);
 }
 
 void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
-                        int cpu, void *data, int size, unsigned long long nsecs)
+                        struct record *record)
 {
         static char *spaces = "                    "; /* 20 spaces */
         struct event_format *event;
         unsigned long secs;
         unsigned long usecs;
         const char *comm;
+        void *data = record->data;
+        int size = record->size;
         int type;
         int pid;
         int len;
 
-        secs = nsecs / NSECS_PER_SEC;
-        usecs = nsecs - secs * NSECS_PER_SEC;
+        secs = record->ts / NSECS_PER_SEC;
+        usecs = record->ts - secs * NSECS_PER_SEC;
         usecs = usecs / NSECS_PER_USEC;
 
         type = trace_parse_common_type(pevent, data);
@@ -3254,10 +3257,10 @@ void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
 
         if (pevent->latency_format) {
                 trace_seq_printf(s, "%8.8s-%-5d %3d",
-                       comm, pid, cpu);
-                pevent_data_lat_fmt(pevent, s, data, size);
+                       comm, pid, record->cpu);
+                pevent_data_lat_fmt(pevent, s, record);
         } else
-                trace_seq_printf(s, "%16s-%-5d [%03d]", comm, pid,  cpu);
+                trace_seq_printf(s, "%16s-%-5d [%03d]", comm, pid, record->cpu);
 
         trace_seq_printf(s, " %5lu.%06lu: %s: ", secs, usecs, event->name);
 
@@ -3267,7 +3270,7 @@ void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
                 trace_seq_printf(s, "%.*s", 20 - len, spaces);
         
         if (event->handler)
-                event->handler(s, data, size, event, cpu, nsecs);
+                event->handler(s, record, event);
         else
                 pretty_print(s, data, size, event);
 
diff --git a/parse-events.h b/parse-events.h
index 9b64b9d..00bdc44 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -20,6 +20,7 @@ struct record {
         int record_size;                /* size of binary record */
         int size;                       /* size of data */
         void *data;
+        int cpu;
 };
 
 /*
@@ -61,9 +62,8 @@ struct pevent;
 struct event_format;
 
 typedef int (*pevent_event_handler_func)(struct trace_seq *s,
-                                         void *data, int size,
-                                         struct event_format *event, int cpu,
-                                         unsigned long long nsecs);
+                                         struct record *record,
+                                         struct event_format *event);
 
 typedef int (*pevent_plugin_load_func)(struct pevent *pevent);
 
@@ -350,7 +350,7 @@ int pevent_register_print_string(struct pevent *pevent, char *fmt,
 int pevent_pid_is_registered(struct pevent *pevent, int pid);
 
 void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
-                        int cpu, void *data, int size, unsigned long long nsecs);
+                        struct record *record);
 
 int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size);
 
@@ -374,13 +374,13 @@ struct event_format *
 pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name);
 
 void pevent_data_lat_fmt(struct pevent *pevent,
-                         struct trace_seq *s, void *data, int size __unused);
+                         struct trace_seq *s, struct record *record);
 int pevent_data_type(struct pevent *pevent, struct record *rec);
 struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type);
 int pevent_data_pid(struct pevent *pevent, struct record *rec);
 const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid);
 void pevent_event_info(struct trace_seq *s, struct event_format *event,
-                       int cpu, void *data, int size, unsigned long long nsecs);
+                       struct record *record);
 
 struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type);
 
diff --git a/plugin_hrtimer.c b/plugin_hrtimer.c
index 01f8ff3..afc5afe 100644
--- a/plugin_hrtimer.c
+++ b/plugin_hrtimer.c
@@ -30,10 +30,11 @@ static void print_field(struct trace_seq *s, const char *fmt,
                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
 }
 
-static int timer_expire_handler(struct trace_seq *s, void *data, int size,
-                                struct event_format *event, int cpu,
-                                unsigned long long nsecs)
+static int timer_expire_handler(struct trace_seq *s, struct record *record,
+                                struct event_format *event)
 {
+        void *data = record->data;
+
         trace_seq_printf(s, "hrtimer=");
 
         if (_print_field(s, "0x%llx", event, "timer", data) == -1)
@@ -46,12 +47,12 @@ static int timer_expire_handler(struct trace_seq *s, void *data, int size,
         return 0;
 }
 
-static int timer_start_handler(struct trace_seq *s, void *data, int size,
-                               struct event_format *event, int cpu,
-                               unsigned long long nsecs)
+static int timer_start_handler(struct trace_seq *s, struct record *record,
+                               struct event_format *event)
 {
         struct pevent *pevent = event->pevent;
         struct format_field *fn = pevent_find_field(event, "function");
+        void *data = record->data;
 
         trace_seq_printf(s, "hrtimer=");
 
diff --git a/plugin_mac80211.c b/plugin_mac80211.c
index 766d9ce..497d564 100644
--- a/plugin_mac80211.c
+++ b/plugin_mac80211.c
@@ -145,10 +145,11 @@ static void _print_flag(struct trace_seq *s, struct event_format *event,
 #define SFX(fn) _print_field(s, fn ":%#x", event, fn, data)
 #define SP()    trace_seq_putc(s, ' ')
 
-static int drv_bss_info_changed(struct trace_seq *s, void *data, int size,
-                                struct event_format *event, int cpu,
-                                unsigned long long nsecs)
+static int drv_bss_info_changed(struct trace_seq *s, struct record *record,
+                                struct event_format *event)
 {
+        void *data = record->data;
+
         print_string(s, event, "wiphy_name", data);
         trace_seq_printf(s, " vif:");
         print_string(s, event, "vif_name", data);
@@ -172,10 +173,11 @@ static int drv_bss_info_changed(struct trace_seq *s, void *data, int size,
         return 0;
 }
 
-static int drv_config(struct trace_seq *s, void *data,
-                      int size, struct event_format *event, int cpu,
-                      unsigned long long nsecs)
+static int drv_config(struct trace_seq *s, struct record *record,
+                      struct event_format *event)
 {
+        void *data = record->data;
+
         print_string(s, event, "wiphy_name", data);
         trace_seq_putc(s, ' ');
         print_flag(s, event, "flags", data,
diff --git a/plugin_sched_switch.c b/plugin_sched_switch.c
index 4690f2f..0f3b857 100644
--- a/plugin_sched_switch.c
+++ b/plugin_sched_switch.c
@@ -47,12 +47,12 @@ static void write_state(struct trace_seq *s, int val)
                 trace_seq_putc(s, 'R');
 }
 
-static int sched_wakeup_handler(struct trace_seq *s, void *data, int size,
-                                struct event_format *event, int cpu,
-                                unsigned long long nsecs)
+static int sched_wakeup_handler(struct trace_seq *s, struct record *record,
+                                struct event_format *event)
 {
         struct format_field *field;
         unsigned long long val;
+        void *data = record->data;
 
         if (get_field_val(s, data, event, "common_pid", &val, 1))
                 return trace_seq_putc(s, '!');
@@ -102,12 +102,12 @@ static int sched_wakeup_handler(struct trace_seq *s, void *data, int size,
         return 0;
 }
 
-static int sched_switch_handler(struct trace_seq *s, void *data, int size,
-                                struct event_format *event, int cpu,
-                                unsigned long long nsecs)
+static int sched_switch_handler(struct trace_seq *s, struct record *record,
+                                struct event_format *event)
 {
         struct format_field *field;
         unsigned long long val;
+        void *data = record->data;
 
         if (get_field_val(s, data, event, "prev_pid", &val, 1))
                 return trace_seq_putc(s, '!');
diff --git a/trace-cmd.c b/trace-cmd.c
index cfd8ba5..cd45a6e 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -145,6 +145,19 @@ static void stop_threads(void)
         }
 }
 
+static void flush_threads(void)
+{
+        int i;
+
+        if (!cpu_count)
+                return;
+
+        for (i = 0; i < cpu_count; i++) {
+                if (pids[i] > 0)
+                        kill(pids[i], SIGUSR1);
+        }
+}
+
 void die(char *fmt, ...)
 {
         va_list ap;
@@ -569,6 +582,12 @@ static void finish(int sig)
         finished = 1;
 }
 
+static void flush(int sig)
+{
+        if (recorder)
+                tracecmd_stop_recording(recorder);
+}
+
 static int create_recorder(int cpu)
 {
         char *file;
@@ -582,6 +601,7 @@ static int create_recorder(int cpu)
                 return pid;
 
         signal(SIGINT, finish);
+        signal(SIGUSR1, flush);
 
         /* do not kill tasks on error */
         cpu_count = 0;
@@ -593,7 +613,8 @@ static int create_recorder(int cpu)
 
         if (!recorder)
                 die ("can't create recorder");
-        tracecmd_start_recording(recorder, sleep_time);
+        while (!finished)
+                tracecmd_start_recording(recorder, sleep_time);
         tracecmd_free_recorder(recorder);
 
         exit(0);
@@ -644,6 +665,46 @@ static void record_data(void)
         tracecmd_output_close(handle);
 }
 
+static int trace_empty(void)
+{
+        char *path;
+        FILE *fp;
+        char *line = NULL;
+        size_t size;
+        ssize_t n;
+        int ret;
+        
+        /*
+         * 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 = get_tracing_file("trace");
+        fp = fopen(path, "r");
+        if (!fp)
+                die("reading '%s'", path);
+
+        do {
+                n = getline(&line, &size, fp);
+                if (!line)
+                        ret = 1;
+                else if (line[0] != '#')
+                        ret = 0;
+                if (n < 0)
+                        ret = 1;
+        } while (line && n > 0);
+
+        put_tracing_file(path);
+
+        fclose(fp);
+
+        return ret;
+}
+
 void usage(char **argv)
 {
         char *arg = argv[0];
@@ -669,6 +730,9 @@ void usage(char **argv)
                "          Uses same options as record, but does not run a command.\n"
                "          It only enables the tracing and exits\n"
                "\n"
+               " %s extract [-p plugin][-O option][-o file]\n"
+               "          Uses same options as record, but only reads an existing trace.\n"
+               "\n"
                " %s stop\n"
                "          Stops the tracer from recording more data.\n"
                "          Used in conjunction with start\n"
@@ -689,7 +753,7 @@ void usage(char **argv)
                "          -e list available events\n"
                "          -p list available plugins\n"
                "          -o list available options\n"
-               "\n", p, TRACECMD_VERSION, p, p, p, p, p, p);
+               "\n", p, TRACECMD_VERSION, p, p, p, p, p, p, p);
         exit(-1);
 }
 
@@ -705,6 +769,7 @@ int main (int argc, char **argv)
         int events = 0;
         int options = 0;
         int record = 0;
+        int extract = 0;
         int run_command = 0;
         int neg_event = 0;
         int fset;
@@ -724,7 +789,8 @@ int main (int argc, char **argv)
                 trace_view(argc, argv);
                 exit(0);
         } else if ((record = (strcmp(argv[1], "record") == 0)) ||
-                   (strcmp(argv[1], "start") == 0)) {
+                   (strcmp(argv[1], "start") == 0) ||
+                   ((extract = strcmp(argv[1], "extract") == 0))) {
 
                 while ((c = getopt(argc-1, argv+1, "+he:p:do:O:s:v")) >= 0) {
                         switch (c) {
@@ -732,6 +798,8 @@ int main (int argc, char **argv)
                                 usage(argv);
                                 break;
                         case 'e':
+                                if (extract)
+                                        usage(argv);
                                 events = 1;
                                 event = malloc_or_die(sizeof(*event));
                                 event->event = optarg;
@@ -740,6 +808,8 @@ int main (int argc, char **argv)
                                 event_selection = event;
                                 break;
                         case 'v':
+                                if (extract)
+                                        usage(argv);
                                 neg_event = 1;
                                 break;
                         case 'p':
@@ -749,10 +819,12 @@ int main (int argc, char **argv)
                                 fprintf(stderr, "  plugin %s\n", plugin);
                                 break;
                         case 'd':
+                                if (extract)
+                                        usage(argv);
                                 disable = 1;
                                 break;
                         case 'o':
-                                if (!record)
+                                if (!record && !extract)
                                         die("start does not take output\n"
                                             "Did you mean 'record'?");
                                 if (output)
@@ -764,6 +836,8 @@ int main (int argc, char **argv)
                                 set_option(option);
                                 break;
                         case 's':
+                                if (extract)
+                                        usage(argv);
                                 sleep_time = atoi(optarg);
                                 break;
                         }
@@ -827,20 +901,26 @@ int main (int argc, char **argv)
                 if (!record)
                         die("Command start does not take any commands\n"
                             "Did you mean 'record'?");
+                if (extract)
+                        die("Command extract does not take any commands\n"
+                            "Did you mean 'record'?");
                 run_command = 1;
         }
 
-        if (!events && !plugin)
+        if (!events && !plugin && !extract)
                 die("no event or plugin was specified... aborting");
 
         if (output)
                 output_file = output;
 
-        fset = set_ftrace(!disable);
-        disable_all();
+        if (!extract) {
+                fset = set_ftrace(!disable);
+                disable_all();
+
+                if (events)
+                        enable_events();
+        }
 
-        if (events)
-                enable_events();
         if (plugin) {
                 /*
                  * Latency tracers just save the trace and kill
@@ -856,33 +936,41 @@ int main (int argc, char **argv)
                 if (fset < 0 && (strcmp(plugin, "function") == 0 ||
                                  strcmp(plugin, "function_graph") == 0))
                         die("function tracing not configured on this kernel");
-                set_plugin(plugin);
+                if (!extract)
+                        set_plugin(plugin);
         }
 
-        if (record) {
+        if (record || extract) {
                 if (!latency)
                         start_threads();
                 signal(SIGINT, finish);
         }
 
-        enable_tracing();
-        if (latency)
-                reset_max_latency();
+        if (extract) {
+                while (!finished && !trace_empty()) {
+                        flush_threads();
+                        sleep(1);
+                }
+        } else {
+                enable_tracing();
+                if (latency)
+                        reset_max_latency();
 
-        if (!record)
-                exit(0);
+                if (!record)
+                        exit(0);
+
+                if (run_command)
+                        run_cmd((argc - optind) - 1, &argv[optind + 1]);
+                else {
+                        /* sleep till we are woken with Ctrl^C */
+                        printf("Hit Ctrl^C to stop recording\n");
+                        while (!finished)
+                                sleep(10);
+                }
 
-        if (run_command)
-                run_cmd((argc - optind) - 1, &argv[optind + 1]);
-        else {
-                /* sleep till we are woken with Ctrl^C */
-                printf("Hit Ctrl^C to stop recording\n");
-                while (!finished)
-                        sleep(10);
+                disable_tracing();
         }
 
-        disable_tracing();
-
         stop_threads();
 
         record_data();
diff --git a/trace-cmd.h b/trace-cmd.h
index a5cc217..f6141f4 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -72,6 +72,8 @@ struct record *
 tracecmd_read_cpu_first(struct tracecmd_input *handle, int cpu);
 struct record *
 tracecmd_read_cpu_last(struct tracecmd_input *handle, int cpu);
+int tracecmd_refresh_record(struct tracecmd_input *handle,
+                            struct record *record);
 
 int tracecmd_set_cpu_to_timestamp(struct tracecmd_input *handle,
                                   int cpu, unsigned long long ts);
diff --git a/trace-ftrace.c b/trace-ftrace.c
index 9dfe04d..459f74b 100644
--- a/trace-ftrace.c
+++ b/trace-ftrace.c
@@ -28,13 +28,13 @@ static int get_field_val(struct trace_seq *s, void *data,
         return 0;
 }
 
-static int function_handler(struct trace_seq *s, void *data, int size,
-                            struct event_format *event, int cpu,
-                            unsigned long long nsecs)
+static int function_handler(struct trace_seq *s, struct record *record,
+                            struct event_format *event)
 {
         struct pevent *pevent = event->pevent;
         unsigned long long function;
         const char *func;
+        void *data = record->data;
 
         if (get_field_val(s, data, event, "ip", &function))
                 return trace_seq_putc(s, '!');
@@ -220,13 +220,15 @@ static int print_graph_nested(struct trace_seq *s,
 }
 
 static int
-fgraph_ent_handler(struct trace_seq *s, void *data, int size,
-                   struct event_format *event, int cpu,
-                   unsigned long long nsecs)
+fgraph_ent_handler(struct trace_seq *s, struct record *record,
+                   struct event_format *event)
 {
         struct record *rec;
         void *copy_data;
         unsigned long long val, pid;
+        void *data = record->data;
+        int size = record->size;
+        int cpu = record->cpu;
         int ret;
 
         if (get_field_val(s, data, event, "common_pid", &pid))
@@ -248,22 +250,47 @@ fgraph_ent_handler(struct trace_seq *s, void *data, int size,
         rec = tracecmd_peek_data(tracecmd_curr_thread_handle, cpu);
         if (rec)
                 rec = get_return_for_leaf(s, cpu, pid, val, rec);
-        if (rec)
+                        
+        if (rec) {
+                /*
+                 * The record returned needs to be freed.
+                 * We also do a new peek on this CPU to update the
+                 * record cache. (peek caches the record, but the
+                 * refresh below will update the CPU iterator.
+                 * If peek has a record in cache, it will update the
+                 * iterator to that)
+                 */
                 ret = print_graph_entry_leaf(s, event, data, rec);
-        else
+                free_record(rec);
+                tracecmd_peek_data(tracecmd_curr_thread_handle, cpu);
+        } else
                 ret = print_graph_nested(s, event, data);
 
         free(data);
+
+        /*
+         * The above peek may unmap the record given to us.
+         * But callers may still have a reference to that record.
+         * We need to make sure it is still mapped.
+         *
+         * Note, this causes a known bug. If the last item in the trace
+         * was a leaf function, we can't remove it. The peek cache
+         * above will be NULL (no records after the leaf) so a new peek
+         * will simply read the return entry of the leaf and print it
+         * again.
+         */
+        tracecmd_refresh_record(tracecmd_curr_thread_handle,
+                                record);
         return ret;
 }
 
 static int
-fgraph_ret_handler(struct trace_seq *s, void *data, int size,
-                   struct event_format *event, int cpu,
-                   unsigned long long nsecs)
+fgraph_ret_handler(struct trace_seq *s, struct record *record,
+                   struct event_format *event)
 {
         unsigned long long rettime, calltime;
         unsigned long long duration, depth;
+        void *data = record->data;
         int i;
 
         if (get_field_val(s, data, event, "rettime", &rettime))
@@ -291,13 +318,13 @@ fgraph_ret_handler(struct trace_seq *s, void *data, int size,
 }
 
 static int
-trace_stack_handler(struct trace_seq *s, void *data, int size,
-                    struct event_format *event, int cpu,
-                    unsigned long long nsecs)
+trace_stack_handler(struct trace_seq *s, struct record *record,
+                    struct event_format *event)
 {
         struct format_field *field;
         unsigned long long addr;
         const char *func;
+        void *data = record->data;
         int ret;
         int i;
 
diff --git a/trace-graph.c b/trace-graph.c
index 4303a0a..b36c636 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -142,8 +142,7 @@ static void print_rec_info(struct record *record, struct pevent *pevent, int cpu
         }
         trace_seq_puts(&s, event->name);
         trace_seq_putc(&s, ':');
-        pevent_event_info(&s, event, cpu, record->data, record->size,
-                          record->ts);
+        pevent_event_info(&s, event, record);
         trace_seq_putc(&s, '\n');
         trace_seq_do_printf(&s);
 }
@@ -285,10 +284,9 @@ static void draw_cpu_info(struct graph_info *ginfo, gint cpu, gint x, gint y)
                         if (event) {
                                 trace_seq_puts(&s, event->name);
                                 trace_seq_putc(&s, '\n');
-                                pevent_data_lat_fmt(pevent, &s, record->data, record->size);
+                                pevent_data_lat_fmt(pevent, &s, record);
                                 trace_seq_putc(&s, '\n');
-                                pevent_event_info(&s, event, cpu, record->data, record->size,
-                                                  record->ts);
+                                pevent_event_info(&s, event, record);
                                 trace_seq_putc(&s, '\n');
                         } else
                                 trace_seq_printf(&s, "UNKNOW EVENT %d\n", type);
diff --git a/trace-input.c b/trace-input.c
index ee9177f..8cc8865 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -495,6 +495,11 @@ static unsigned int ts4host(struct tracecmd_input *handle,
                 return type_len_ts >> 5;
 }
 
+static unsigned int read_type_len_ts(struct tracecmd_input *handle, void *ptr)
+{
+        return data2host4(handle->pevent, ptr);
+}
+
 static int calc_index(struct tracecmd_input *handle,
                       void *ptr, int cpu)
 {
@@ -574,9 +579,21 @@ static int get_read_page(struct tracecmd_input *handle, int cpu,
         return 0;
 }
 
+/*
+ * get_page maps a page for a given cpu.
+ *
+ * Returns 1 if the page was already mapped,
+ *         0 if it mapped successfully
+ *        -1 on error
+ */
 static int get_page(struct tracecmd_input *handle, int cpu,
                     off64_t offset)
 {
+        /* Don't map if the page is already where we want */
+        if (handle->cpu_data[cpu].offset == offset &&
+            handle->cpu_data[cpu].page)
+                return 1;
+
         if (offset & (handle->page_size - 1)) {
                 errno = -EINVAL;
                 die("bad page offset %llx", offset);
@@ -656,7 +673,7 @@ read_old_format(struct tracecmd_input *handle, void **ptr, int cpu)
 
         index = calc_index(handle, *ptr, cpu);
 
-        type_len_ts = data2host4(pevent, *ptr);
+        type_len_ts = read_type_len_ts(handle, *ptr);
         *ptr += 4;
 
         type = type4host(handle, type_len_ts);
@@ -769,7 +786,7 @@ find_and_read_event(struct tracecmd_input *handle, unsigned long long offset,
         /* Move this cpu index to point to this offest */
         page_offset = offset & ~(handle->page_size - 1);
 
-        if (get_page(handle, cpu, page_offset))
+        if (get_page(handle, cpu, page_offset) < 0)
                 return NULL;
 
         if (pcpu)
@@ -815,6 +832,58 @@ tracecmd_read_at(struct tracecmd_input *handle, unsigned long long offset,
 }
 
 /**
+ * tracecmd_refresh_record - remaps the records data
+ * @handle: input handle for the trace.dat file
+ * @record: the record to be refreshed
+ *
+ * A record data points to a mmap section of memory.
+ * by reading new records the mmap section may be unmapped.
+ * This will refresh the record's data mapping.
+ *
+ * Returns 1 if page is still mapped (does not modify CPU iterator)
+ *         0 on successful mapping (was not mapped before,
+ *                      This will update CPU iterator to point to
+ *                      the next record)
+ *        -1 on error.
+ */
+int tracecmd_refresh_record(struct tracecmd_input *handle,
+                            struct record *record)
+{
+        unsigned long long page_offset;
+        int cpu = record->cpu;
+        struct cpu_data *cpu_data = &handle->cpu_data[cpu];
+        unsigned int type_len_ts;
+        unsigned int len;
+        int index;
+        int ret;
+
+        page_offset = record->offset & ~(handle->page_size - 1);
+        index = record->offset & (handle->page_size - 1);
+
+        ret = get_page(handle, record->cpu, page_offset) < 0;
+        if (ret < 0)
+                return -1;
+
+        /* If the page is still mapped, there's nothing to do */
+        if (ret)
+                return 1;
+
+        record->data = cpu_data->page + index;
+
+        type_len_ts = read_type_len_ts(handle, record->data);
+        len = len4host(handle, type_len_ts);
+
+        /* The data starts either 4 or 8 bytes from offset */
+        record->data += len ? 4 : 8;
+
+        /* The get_page resets the index, set the index after this record */
+        cpu_data->index = index + record->record_size;
+        cpu_data->timestamp = record->ts;
+
+        return 0;
+}
+
+/**
  * tracecmd_read_cpu_first - get the first record in a CPU
  * @handle: input handle for the trace.dat file
  * @cpu: the CPU to search
@@ -918,7 +987,7 @@ tracecmd_set_cpu_to_timestamp(struct tracecmd_input *handle, int cpu,
         }
 
         while (start < end) {
-                if (get_page(handle, cpu, next))
+                if (get_page(handle, cpu, next) < 0)
                         return -1;
 
                 if (cpu_data->timestamp == ts)
@@ -962,7 +1031,7 @@ translate_data(struct tracecmd_input *handle,
         unsigned int type_len_ts;
         unsigned int type_len;
 
-        type_len_ts = data2host4(pevent, *ptr);
+        type_len_ts = read_type_len_ts(handle, *ptr);
         *ptr += 4;
 
         type_len = type_len4host(handle, type_len_ts);
@@ -1020,31 +1089,31 @@ struct record *
 tracecmd_translate_data(struct tracecmd_input *handle,
                         void *ptr, int size)
 {
-        struct record *data;
+        struct record *record;
         unsigned int type_len;
 
         /* minimum record read is 8, (warn?) (TODO: make 8 into macro) */
         if (size < 8)
                 return NULL;
 
-        data = malloc(sizeof(*data));
-        if (!data)
+        record = malloc(sizeof(*record));
+        if (!record)
                 return NULL;
-        memset(data, 0, sizeof(*data));
+        memset(record, 0, sizeof(*record));
 
-        data->data = ptr;
-        type_len = translate_data(handle, &data->data, &data->ts, &data->size);
+        record->data = ptr;
+        type_len = translate_data(handle, &record->data, &record->ts, &record->size);
         switch (type_len) {
         case RINGBUF_TYPE_PADDING:
         case RINGBUF_TYPE_TIME_EXTEND:
         case RINGBUF_TYPE_TIME_STAMP:
-                data->data = NULL;
+                record->data = NULL;
                 break;
         default:
                 break;
         }
 
-        return data;
+        return record;
 }
 
 /**
@@ -1061,19 +1130,38 @@ struct record *
 tracecmd_peek_data(struct tracecmd_input *handle, int cpu)
 {
         struct pevent *pevent = handle->pevent;
-        struct record *data;
+        struct record *record;
         void *page = handle->cpu_data[cpu].page;
         int index = handle->cpu_data[cpu].index;
         void *ptr = page + index;
         unsigned long long extend;
         unsigned int type_len;
         int length;
+        int ret;
 
         /* Hack to work around function graph read ahead */
         tracecmd_curr_thread_handle = handle;
 
-        if (handle->cpu_data[cpu].next)
+        if (handle->cpu_data[cpu].next) {
+                /* Make sure it's still mapped */
+                ret = tracecmd_refresh_record(handle, handle->cpu_data[cpu].next);
+                if (ret < 0) {
+                        free_record(handle->cpu_data[cpu].next);
+                        handle->cpu_data[cpu].next = NULL;
+                        return NULL;
+                }
+                /*
+                 * Make sure the index and timestamp are where
+                 * we want them, because the refresh did not update it.
+                 */
+                if (ret && handle->cpu_data[cpu].timestamp != record->ts) {
+                        handle->cpu_data[cpu].index =
+                                (record->offset & (handle->page_size - 1)) +
+                                record->record_size;
+                        handle->cpu_data[cpu].timestamp = record->ts;
+                }
                 return handle->cpu_data[cpu].next;
+        }
 
         if (!page)
                 return NULL;
@@ -1091,14 +1179,14 @@ read_again:
         }
 
         if (pevent->old_format) {
-                data = read_old_format(handle, &ptr, cpu);
-                if (!data) {
+                record = read_old_format(handle, &ptr, cpu);
+                if (!record) {
                         if (!ptr)
                                 return NULL;
                         goto read_again;
                 }
-                        
-                return data;
+                record->cpu = cpu;
+                return record;
         }
 
         type_len = translate_data(handle, &ptr, &extend, &length);
@@ -1121,24 +1209,25 @@ read_again:
 
         handle->cpu_data[cpu].timestamp += extend;
 
-        data = malloc(sizeof(*data));
-        if (!data)
+        record = malloc(sizeof(*record));
+        if (!record)
                 return NULL;
-        memset(data, 0, sizeof(*data));
+        memset(record, 0, sizeof(*record));
 
-        data->ts = handle->cpu_data[cpu].timestamp;
-        data->size = length;
-        data->data = ptr;
-        data->offset = handle->cpu_data[cpu].offset + index;
+        record->ts = handle->cpu_data[cpu].timestamp;
+        record->size = length;
+        record->cpu = cpu;
+        record->data = ptr;
+        record->offset = handle->cpu_data[cpu].offset + index;
 
         ptr += length;
 
         handle->cpu_data[cpu].index = calc_index(handle, ptr, cpu);
-        handle->cpu_data[cpu].next = data;
+        handle->cpu_data[cpu].next = record;
 
-        data->record_size = handle->cpu_data[cpu].index - index;
+        record->record_size = handle->cpu_data[cpu].index - index;
 
-        return data;
+        return record;
 }
 
 /**
@@ -1154,12 +1243,12 @@ read_again:
 struct record *
 tracecmd_read_data(struct tracecmd_input *handle, int cpu)
 {
-        struct record *data;
+        struct record *record;
 
-        data = tracecmd_peek_data(handle, cpu);
+        record = tracecmd_peek_data(handle, cpu);
         handle->cpu_data[cpu].next = NULL;
 
-        return data;
+        return record;
 }
 
 static int init_read(struct tracecmd_input *handle, int cpu)
diff --git a/trace-read.c b/trace-read.c
index 5a5d4df..a7cac1e 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -202,7 +202,7 @@ static void show_data(struct tracecmd_input *handle, int cpu)
         test_save(record, cpu);
 
         trace_seq_init(&s);
-        pevent_print_event(pevent, &s, cpu, record->data, record->size, record->ts);
+        pevent_print_event(pevent, &s, record);
         trace_seq_do_printf(&s);
         printf("\n");
 
diff --git a/trace-view-store.c b/trace-view-store.c
index eb096fa..9e79a28 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -470,7 +470,7 @@ trace_view_store_get_value (GtkTreeModel *tree_model,
 
                 case TRACE_VIEW_STORE_COL_LAT:
                         trace_seq_init(&s);
-                        pevent_data_lat_fmt(pevent, &s, data->data, data->size);
+                        pevent_data_lat_fmt(pevent, &s, data);
                         g_value_set_string(value, s.buffer);
                         break;
 
@@ -485,8 +485,7 @@ trace_view_store_get_value (GtkTreeModel *tree_model,
 
                         
                         trace_seq_init(&s);
-                        pevent_event_info(&s, event, cpu, data->data, data->size,
-                                          record->timestamp);
+                        pevent_event_info(&s, event, data);
                         g_value_set_string(value, s.buffer);
                         break;
                 }