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",