trace-cmd: Have function graph keep record around

The function graph tracer looks forward in the trace to determine
if a function is a leaf or not. In doing so, it causes the mapping
of records to change. This produces a nasty side effect where the
caller can have the record stored, and it will suddenly invalidate
the record's mapping.

This refreshes the record passed in and does a trick by calling
the tracecmd_peek_data function that will cache the location
after the leaf function's return entry.

This unfortunately causes a side effect too where if the last
entry in the trace is a leaf function, we can't hide the exit entry
and it will print regardless. But this side effect wont crash the
application, but the previous side effect will.

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

2 files changed, 44 insertions, 3 deletions

diff --git a/trace-ftrace.c b/trace-ftrace.c
index 0920430..459f74b 100644
--- a/trace-ftrace.c
+++ b/trace-ftrace.c
@@ -250,12 +250,37 @@ fgraph_ent_handler(struct trace_seq *s, struct record *record,
         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;
 }
 
diff --git a/trace-input.c b/trace-input.c
index 5c8dfae..8cc8865 100644
--- a/trace-input.c
+++ b/trace-input.c
@@ -1137,13 +1137,29 @@ tracecmd_peek_data(struct tracecmd_input *handle, int cpu)
         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) {
                 /* Make sure it's still mapped */
-                tracecmd_refresh_record(handle, handle->cpu_data[cpu].next);
+                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;
         }