trace-cmd: Added trace stack command

Added the command "trace-cmd stack" to run the stack tracer.
It simply enables the stack tracer and depending on the options
it will ouput the current stack, or disable it.

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

7 files changed, 300 insertions, 4 deletions

diff --git a/Documentation/trace-cmd-stack.1.txt b/Documentation/trace-cmd-stack.1.txt
new file mode 100644
index 0000000..6b5f0c0
--- /dev/null
+++ b/Documentation/trace-cmd-stack.1.txt
@@ -0,0 +1,45 @@
+TRACE-CMD-STACK(1)
+==================
+
+NAME
+----
+trace-cmd-stack - read, enable or disable Ftrace Linux kernel stack tracing.
+
+SYNOPSIS
+--------
+*trace-cmd stack*
+
+DESCRIPTION
+-----------
+The trace-cmd(1) stack enables the Ftrace stack tracer within the kernel.
+The stack tracer enables the function tracer and at each function call
+within the kernel, the stack is checked. When a new maximum usage stack
+is discovered, it is recorded.
+
+When no option is used, the current stack is displayed.
+
+To enable the stack tracer, use the option *--start*, and to disable
+the stack tracer, use the option *--stop*. The output will be the maximum
+stack found since the start was enabled.
+
+Use *--reset* to reset the stack counter to zero.
+
+SEE ALSO
+--------
+trace-cmd(1), trace-cmd-record(1), trace-cmd-report(1), trace-cmd-start(1),
+trace-cmd-extract(1), trace-cmd-reset(1), trace-cmd-split(1),
+trace-cmd-list(1), trace-cmd-listen(1)
+
+AUTHOR
+------
+Written by Steven Rostedt, <rostedt@goodmis.org>
+
+RESOURCES
+---------
+git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
+
+COPYING
+-------
+Copyright \(C) 2010 Red Hat, Inc. Free use of this software is granted under
+the terms of the GNU Public License (GPL).
+
diff --git a/Makefile b/Makefile
index fe34d1c..41f0d43 100644
--- a/Makefile
+++ b/Makefile
@@ -261,7 +261,8 @@ $(obj)/%.o: $(src)/%.c
 
 TRACE_GUI_OBJS = trace-filter.o trace-compat.o trace-hash.o trace-dialog.o \
                 trace-xml.o
-TRACE_CMD_OBJS = trace-cmd.o trace-usage.o trace-read.o trace-split.o trace-listen.o
+TRACE_CMD_OBJS = trace-cmd.o trace-usage.o trace-read.o trace-split.o trace-listen.o \
+        trace-stack.o
 TRACE_VIEW_OBJS = trace-view.o trace-view-store.o
 TRACE_GRAPH_OBJS = trace-graph.o trace-plot.o trace-plot-cpu.o trace-plot-task.o
 TRACE_VIEW_MAIN_OBJS = trace-view-main.o $(TRACE_VIEW_OBJS) $(TRACE_GUI_OBJS)
diff --git a/trace-cmd.c b/trace-cmd.c
index cce499a..9cbe362 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -55,6 +55,19 @@
 int silence_warnings;
 int show_status;
 
+static char *get_tracing_file(const char *name);
+static void put_tracing_file(char *file);
+
+char *tracecmd_get_tracing_file(const char *name)
+{
+        return get_tracing_file(name);
+}
+
+void tracecmd_put_tracing_file(char *name)
+{
+        put_tracing_file(name);
+}
+
 static int tracing_on_init_val;
 
 static int rt_prio;
@@ -286,9 +299,6 @@ static int set_ftrace(int set)
         return 0;
 }
 
-static char *get_tracing_file(const char *name);
-static void put_tracing_file(char *file);
-
 static void clear_trace(void)
 {
         FILE *fp;
@@ -1439,6 +1449,9 @@ int main (int argc, char **argv)
         } else if (strcmp(argv[1], "restore") == 0) {
                 trace_restore(argc, argv);
                 exit(0);
+        } else if (strcmp(argv[1], "stack") == 0) {
+                trace_stack(argc, argv);
+                exit(0);
         } else if ((record = (strcmp(argv[1], "record") == 0)) ||
                    (strcmp(argv[1], "start") == 0) ||
                    ((extract = strcmp(argv[1], "extract") == 0))) {
diff --git a/trace-cmd.h b/trace-cmd.h
index b77b8e6..59d9d54 100644
--- a/trace-cmd.h
+++ b/trace-cmd.h
@@ -149,6 +149,9 @@ tracecmd_get_cursor(struct tracecmd_input *handle, int cpu);
 int tracecmd_ftrace_overrides(struct tracecmd_input *handle, struct tracecmd_ftrace *finfo);
 struct pevent *tracecmd_get_pevent(struct tracecmd_input *handle);
 
+char *tracecmd_get_tracing_file(const char *name);
+void tracecmd_put_tracing_file(char *name);
+
 #ifndef SWIG
 /* hack for function graph work around */
 extern __thread struct tracecmd_input *tracecmd_curr_thread_handle;
diff --git a/trace-local.h b/trace-local.h
index 0ae798d..73c38d2 100644
--- a/trace-local.h
+++ b/trace-local.h
@@ -44,4 +44,6 @@ void trace_listen(int argc, char **argv);
 
 void trace_restore(int argc, char **argv);
 
+void trace_stack(int argc, char **argv);
+
 #endif /* __TRACE_LOCAL_H */
diff --git a/trace-stack.c b/trace-stack.c
new file mode 100644
index 0000000..3d9f392
--- /dev/null
+++ b/trace-stack.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "trace-local.h"
+
+#define PROC_FILE "/proc/sys/kernel/stack_tracer_enabled"
+
+enum stack_type {
+        STACK_START,
+        STACK_STOP,
+        STACK_RESET,
+        STACK_REPORT
+};
+
+static void test_available(void)
+{
+        struct stat buf;
+        int fd;
+
+        fd = stat(PROC_FILE, &buf);
+        if (fd < 0)
+                die("stack tracer not configured on running kernel");
+}
+
+static char read_proc(void)
+{
+        char buf[1];
+        int fd;
+        int n;
+
+        fd = open(PROC_FILE, O_RDONLY);
+        if (fd < 0)
+                die("reading %s", PROC_FILE);
+        n = read(fd, buf, 1);
+        close(fd);
+        if (n != 1)
+                die("error reading %s", PROC_FILE);
+
+        return buf[0];
+}
+
+static void start_stop_trace(char val)
+{
+        char buf[1];
+        int fd;
+        int n;
+
+        buf[0] = read_proc();
+        if (buf[0] == val)
+                return;
+
+        fd = open(PROC_FILE, O_WRONLY);
+        if (fd < 0)
+                die("writing %s", PROC_FILE);
+        buf[0] = val;
+        n = write(fd, buf, 1);
+        if (n < 0)
+                die("writing into %s", PROC_FILE);
+        close(fd);
+}
+
+static void start_trace(void)
+{
+        start_stop_trace('1');
+}
+
+static void stop_trace(void)
+{
+        start_stop_trace('0');
+}
+
+static void reset_trace(void)
+{
+        char *path;
+        char buf[1];
+        int fd;
+        int n;
+
+        path = tracecmd_get_tracing_file("stack_max_size");
+        fd = open(path, O_WRONLY);
+        if (fd < 0)
+                die("writing %s", path);
+
+        buf[0] = '0';
+        n = write(fd, buf, 1);
+        if (n < 0)
+                die("writing into %s", path);
+        tracecmd_put_tracing_file(path);
+        close(fd);
+}
+
+static void read_trace(void)
+{
+        FILE *fp;
+        char *path;
+        char *buf = NULL;
+        size_t n;
+        int r;
+
+        if (read_proc() == '1')
+                printf("(stack tracer running)\n");
+        else
+                printf("(stack tracer not running)\n");
+
+        path = tracecmd_get_tracing_file("stack_trace");
+        fp = fopen(path, "r");
+        if (!fp)
+                die("reading to '%s'", path);
+        tracecmd_put_tracing_file(path);
+
+        while ((r = getline(&buf, &n, fp)) >= 0) {
+                /*
+                 * Skip any line that starts with a '#'.
+                 * Those talk about how to enable stack tracing
+                 * within the debugfs system. We don't care about that.
+                 */
+                if (buf[0] != '#')
+                        printf("%s", buf);
+
+                free(buf);
+                buf = NULL;
+        }
+
+        fclose(fp);
+}
+
+void trace_stack (int argc, char **argv)
+{
+        enum stack_type trace_type = STACK_REPORT;
+        int c;
+
+        if (argc < 2)
+                usage(argv);
+
+        if (strcmp(argv[1], "stack") != 0)
+                usage(argv);
+
+        for (;;) {
+                int option_index = 0;
+                static struct option long_options[] = {
+                        {"start", no_argument, NULL, 0},
+                        {"stop", no_argument, NULL, 0},
+                        {"reset", no_argument, NULL, 0},
+                        {"help", no_argument, NULL, '?'},
+                        {NULL, 0, NULL, 0}
+                };
+
+                c = getopt_long (argc-1, argv+1, "+h?",
+                        long_options, &option_index);
+                if (c == -1)
+                        break;
+
+                switch (c) {
+                case 'h':
+                        usage(argv);
+                        break;
+                case 0:
+                        switch(option_index) {
+                        case 0:
+                                trace_type = STACK_START;
+                                break;
+                        case 1:
+                                trace_type = STACK_STOP;
+                                break;
+                        case 2:
+                                trace_type = STACK_RESET;
+                                break;
+                        default:
+                                usage(argv);
+                        }
+                        break;
+                default:
+                        usage(argv);
+                }
+        }
+
+        test_available();
+
+        switch (trace_type) {
+        case STACK_START:
+                start_trace();
+                break;
+        case STACK_STOP:
+                stop_trace();
+                break;
+        case STACK_RESET:
+                reset_trace();
+                break;
+        default:
+                read_trace();
+                break;
+        }
+
+        return;
+}
diff --git a/trace-usage.c b/trace-usage.c
index 5dd691c..a6280e8 100644
--- a/trace-usage.c
+++ b/trace-usage.c
@@ -131,6 +131,14 @@ static struct usage_help usage_help[] = {
                 "          -i parital trace.dat file for input\n"
         },
         {
+                "stack",
+                "output, enable or disable kernel stack tracing",
+                " %s stack [--start][--stop][--reset]\n"
+                "          --start  enable the stack tracer\n"
+                "          --stop   disable the stack tracer\n"
+                "          --reset  reset the maximum stack found\n"
+        },
+        {
                 NULL, NULL, NULL
         }
 };