perf ftrace: Add option '-m/--buffer-size' to set per-cpu buffer size

[linux-2.6-microblaze.git] / tools / perf / builtin-ftrace.c

diff --git a/tools/perf/builtin-ftrace.c b/tools/perf/builtin-ftrace.c
index 048a111..a3a4f4b 100644 (file)
--- a/tools/perf/builtin-ftrace.c
+++ b/tools/perf/builtin-ftrace.c
@@ -26,6 +26,7 @@
 #include "thread_map.h"
 #include "util/cap.h"
 #include "util/config.h"
+#include "util/units.h"
 
 #define DEFAULT_TRACER  "function_graph"
 
@@ -33,11 +34,13 @@ struct perf_ftrace {
        struct evlist           *evlist;
        struct target           target;
        const char              *tracer;
+       bool                    list_avail_functions;
        struct list_head        filters;
        struct list_head        notrace;
        struct list_head        graph_funcs;
        struct list_head        nograph_funcs;
        int                     graph_depth;
+       unsigned long           percpu_buffer_size;
 };
 
 struct filter_entry {
@@ -128,6 +131,57 @@ static int append_tracing_file(const char *name, const char *val)
        return __write_tracing_file(name, val, true);
 }
 
+static int read_tracing_file_to_stdout(const char *name)
+{
+       char buf[4096];
+       char *file;
+       int fd;
+       int ret = -1;
+
+       file = get_tracing_file(name);
+       if (!file) {
+               pr_debug("cannot get tracing file: %s\n", name);
+               return -1;
+       }
+
+       fd = open(file, O_RDONLY);
+       if (fd < 0) {
+               pr_debug("cannot open tracing file: %s: %s\n",
+                        name, str_error_r(errno, buf, sizeof(buf)));
+               goto out;
+       }
+
+       /* read contents to stdout */
+       while (true) {
+               int n = read(fd, buf, sizeof(buf));
+               if (n == 0)
+                       break;
+               else if (n < 0)
+                       goto out_close;
+
+               if (fwrite(buf, n, 1, stdout) != 1)
+                       goto out_close;
+       }
+       ret = 0;
+
+out_close:
+       close(fd);
+out:
+       put_tracing_file(file);
+       return ret;
+}
+
+static int write_tracing_file_int(const char *name, int value)
+{
+       char buf[16];
+
+       snprintf(buf, sizeof(buf), "%d", value);
+       if (write_tracing_file(name, buf) < 0)
+               return -1;
+
+       return 0;
+}
+
 static int reset_tracing_cpu(void);
 static void reset_tracing_filters(void);
 
@@ -258,8 +312,6 @@ static void reset_tracing_filters(void)
 
 static int set_tracing_depth(struct perf_ftrace *ftrace)
 {
-       char buf[16];
-
        if (ftrace->graph_depth == 0)
                return 0;
 
@@ -268,14 +320,27 @@ static int set_tracing_depth(struct perf_ftrace *ftrace)
                return -1;
        }
 
-       snprintf(buf, sizeof(buf), "%d", ftrace->graph_depth);
-
-       if (write_tracing_file("max_graph_depth", buf) < 0)
+       if (write_tracing_file_int("max_graph_depth", ftrace->graph_depth) < 0)
                return -1;
 
        return 0;
 }
 
+static int set_tracing_percpu_buffer_size(struct perf_ftrace *ftrace)
+{
+       int ret;
+
+       if (ftrace->percpu_buffer_size == 0)
+               return 0;
+
+       ret = write_tracing_file_int("buffer_size_kb",
+                                    ftrace->percpu_buffer_size / 1024);
+       if (ret < 0)
+               return ret;
+
+       return 0;
+}
+
 static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 {
        char *trace_file;
@@ -302,6 +367,9 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
        signal(SIGCHLD, sig_handler);
        signal(SIGPIPE, sig_handler);
 
+       if (ftrace->list_avail_functions)
+               return read_tracing_file_to_stdout("available_filter_functions");
+
        if (reset_tracing_files(ftrace) < 0) {
                pr_err("failed to reset ftrace\n");
                goto out;
@@ -337,6 +405,11 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
                goto out_reset;
        }
 
+       if (set_tracing_percpu_buffer_size(ftrace) < 0) {
+               pr_err("failed to set tracing per-cpu buffer size\n");
+               goto out_reset;
+       }
+
        if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
                pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
                goto out_reset;
@@ -455,6 +528,37 @@ static void delete_filter_func(struct list_head *head)
        }
 }
 
+static int parse_buffer_size(const struct option *opt,
+                            const char *str, int unset)
+{
+       unsigned long *s = (unsigned long *)opt->value;
+       static struct parse_tag tags_size[] = {
+               { .tag  = 'B', .mult = 1       },
+               { .tag  = 'K', .mult = 1 << 10 },
+               { .tag  = 'M', .mult = 1 << 20 },
+               { .tag  = 'G', .mult = 1 << 30 },
+               { .tag  = 0 },
+       };
+       unsigned long val;
+
+       if (unset) {
+               *s = 0;
+               return 0;
+       }
+
+       val = parse_tag_value(str, tags_size);
+       if (val != (unsigned long) -1) {
+               if (val < 1024) {
+                       pr_err("buffer size too small, must larger than 1KB.");
+                       return -1;
+               }
+               *s = val;
+               return 0;
+       }
+
+       return -1;
+}
+
 static void select_tracer(struct perf_ftrace *ftrace)
 {
        bool graph = !list_empty(&ftrace->graph_funcs) ||
@@ -487,6 +591,8 @@ int cmd_ftrace(int argc, const char **argv)
        const struct option ftrace_options[] = {
        OPT_STRING('t', "tracer", &ftrace.tracer, "tracer",
                   "tracer to use: function_graph(default) or function"),
+       OPT_BOOLEAN('F', "funcs", &ftrace.list_avail_functions,
+                   "Show available functions to filter"),
        OPT_STRING('p', "pid", &ftrace.target.pid, "pid",
                   "trace on existing process id"),
        OPT_INCR('v', "verbose", &verbose,
@@ -507,6 +613,8 @@ int cmd_ftrace(int argc, const char **argv)
                     "Set nograph filter on given functions", parse_filter_func),
        OPT_INTEGER('D', "graph-depth", &ftrace.graph_depth,
                    "Max depth for function graph tracer"),
+       OPT_CALLBACK('m', "buffer-size", &ftrace.percpu_buffer_size, "size",
+                    "size of per cpu buffer", parse_buffer_size),
        OPT_END()
        };