trace-cmd: Add --func-stack option to enable function stack trace

Added --func-stack option to trace-cmd record, that will enable the
function stack tracing, but only if the -l option (limit functions)
is used, and succeeds in filtering functions. It is known that running
the function stack trace on all functions can livelock the machine.

The output now looks like this:

          <idle>-0     [002] 64003.696572: function:             schedule
          <idle>-0     [002] 64003.696577: kernel_stack:         <stack trace>
=> cpu_idle (ffffffff8100a38c)
=> start_secondary (ffffffff814ab828)
       trace-cmd-4132  [003] 64003.696632: function:             schedule
       trace-cmd-4132  [003] 64003.696637: kernel_stack:         <stack trace>

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

3 files changed, 67 insertions, 1 deletions

diff --git a/Documentation/trace-cmd-record.1.txt b/Documentation/trace-cmd-record.1.txt
index 87e4f97..b78182a 100644
--- a/Documentation/trace-cmd-record.1.txt
+++ b/Documentation/trace-cmd-record.1.txt
@@ -64,6 +64,13 @@ OPTIONS
 => cpu_idle (ffffffff8100a38c)
 => start_secondary (ffffffff814ab828)
 
+*--func-stack*::
+    Enable a stack trace on all functions. Note this is only applicable
+    for the "function" plugin tracer, and will only take effect if the
+    -l option is used and succeeds in limiting functions. If the function
+    tracer is not filtered, and the stack trace is enabled, you can live
+    lock the machine.
+
 *-f* 'filter'::
     Specify a filter for the previous event. This must come after a *-e*. This
     will filter what events get recorded based on the content of the event.
diff --git a/trace-record.c b/trace-record.c
index 2a6872c..031e084 100644
--- a/trace-record.c
+++ b/trace-record.c
@@ -54,6 +54,7 @@
 #define ITER_CTRL       "trace_options"
 #define MAX_LATENCY     "tracing_max_latency"
 #define STAMP           "stamp"
+#define FUNC_STACK_TRACE "func_stack_trace"
 
 #define UDP_MAX_PACKET (65536 - 20)
 
@@ -97,6 +98,8 @@ static struct func_list *filter_funcs;
 static struct func_list *notrace_funcs;
 static struct func_list *graph_funcs;
 
+static int func_stack;
+
 struct filter_pids {
         struct filter_pids *next;
         int pid;
@@ -560,6 +563,7 @@ static void set_plugin(const char *name)
 {
         FILE *fp;
         char *path;
+        char zero = '0';
 
         path = tracecmd_get_tracing_file("current_tracer");
         fp = fopen(path, "w");
@@ -569,6 +573,16 @@ static void set_plugin(const char *name)
 
         fwrite(name, 1, strlen(name), fp);
         fclose(fp);
+
+        if (strncmp(name, "function", 8) != 0)
+                return;
+
+        /* Make sure func_stack_trace option is disabled */
+        path = tracecmd_get_tracing_file("options/func_stack_trace");
+        fp = fopen(path, "w");
+        tracecmd_put_tracing_file(path);
+        fwrite(&zero, 1, 1, fp);
+        fclose(fp);
 }
 
 static void save_option(const char *option)
@@ -1525,11 +1539,44 @@ static void write_func_file(const char *file, struct func_list **list)
         tracecmd_put_tracing_file(path);
 }
 
+static int functions_filtered(void)
+{
+        char buf[1] = { '#' };
+        char *path;
+        int fd;
+
+        path = tracecmd_get_tracing_file("set_ftrace_filter");
+        fd = open(path, O_RDONLY);
+        tracecmd_put_tracing_file(path);
+        if (fd < 0)
+                return 0;
+
+        /*
+         * If functions are not filtered, than the first character
+         * will be '#'. Make sure it is not an '#' and also not space.
+         */
+        read(fd, buf, 1);
+        close(fd);
+
+        if (buf[0] == '#' || isspace(buf[0]))
+                return 0;
+        return 1;
+}
+
 static void set_funcs(void)
 {
         write_func_file("set_ftrace_filter", &filter_funcs);
         write_func_file("set_ftrace_notrace", &notrace_funcs);
         write_func_file("set_graph_function", &graph_funcs);
+
+        /* make sure we are filtering functions */
+        if (func_stack) {
+                if (!functions_filtered()) {
+                        disable_all();
+                        die("Function stack trace set, but functions not filtered");
+                }
+                save_option(FUNC_STACK_TRACE);
+        }
 }
 
 static void add_func(struct func_list **list, const char *func)
@@ -1810,6 +1857,7 @@ static void record_all_events(void)
 }
 
 enum {
+        OPT_funcstack   = 254,
         OPT_date        = 255,
 };
 
@@ -1867,6 +1915,7 @@ void trace_record (int argc, char **argv)
                 int option_index = 0;
                 static struct option long_options[] = {
                         {"date", no_argument, NULL, OPT_date},
+                        {"func-stack", no_argument, NULL, OPT_funcstack},
                         {"help", no_argument, NULL, '?'},
                         {NULL, 0, NULL, 0}
                 };
@@ -1957,7 +2006,8 @@ void trace_record (int argc, char **argv)
                 case 'p':
                         if (plugin)
                                 die("only one plugin allowed");
-                        plugin = optarg;
+                        for (plugin = optarg; isspace(*plugin); plugin++)
+                                ;
                         fprintf(stderr, "  plugin %s\n", plugin);
                         break;
                 case 'd':
@@ -2012,11 +2062,18 @@ void trace_record (int argc, char **argv)
                 case OPT_date:
                         date = 1;
                         break;
+                case OPT_funcstack:
+                        func_stack = 1;
+                        break;
                 default:
                         usage(argv);
                 }
         }
 
+        if (strncmp(plugin, "function", 8) == 0 &&
+            func_stack && !filter_funcs)
+                die("Must supply function filtering with --func-stack\n");
+
         if (do_ptrace && !filter_task && (filter_pid < 0))
                 die(" -c can only be used with -F or -P");
 
diff --git a/trace-usage.c b/trace-usage.c
index 1ecc8fa..4b171fe 100644
--- a/trace-usage.c
+++ b/trace-usage.c
@@ -40,6 +40,8 @@ static struct usage_help usage_help[] = {
                 "          -b change kernel buffersize (in kilobytes per CPU)\n"
                 "          -k do not reset the buffers after tracing.\n"
                 "          -i do not fail if an event is not found\n"
+                "          --func-stack perform a stack trace for function tracer\n"
+                "             (use with caution)\n"
         },
         {
                 "start",