tools/perf/builtin-ftrace.c

   1 /*
   2  * builtin-ftrace.c
   3  *
   4  * Copyright (c) 2013  LG Electronics,  Namhyung Kim <namhyung@kernel.org>
   5  *
   6  * Released under the GPL v2.
   7  */
   8
   9 #include "builtin.h"
  10 #include "perf.h"
  11
  12 #include <unistd.h>
  13 #include <signal.h>
  14 #include <fcntl.h>
  15
  16 #include "debug.h"
  17 #include <subcmd/parse-options.h>
  18 #include "evlist.h"
  19 #include "target.h"
  20 #include "cpumap.h"
  21 #include "thread_map.h"
  22 #include "util/config.h"
  23
  24
  25 #define DEFAULT_TRACER  "function_graph"
  26
  27 struct perf_ftrace {
  28         struct perf_evlist *evlist;
  29         struct target target;
  30         const char *tracer;
  31 };
  32
  33 static bool done;
  34
  35 static void sig_handler(int sig __maybe_unused)
  36 {
  37         done = true;
  38 }
  39
  40 /*
  41  * perf_evlist__prepare_workload will send a SIGUSR1 if the fork fails, since
  42  * we asked by setting its exec_error to the function below,
  43  * ftrace__workload_exec_failed_signal.
  44  *
  45  * XXX We need to handle this more appropriately, emitting an error, etc.
  46  */
  47 static void ftrace__workload_exec_failed_signal(int signo __maybe_unused,
  48                                                 siginfo_t *info __maybe_unused,
  49                                                 void *ucontext __maybe_unused)
  50 {
  51         /* workload_exec_errno = info->si_value.sival_int; */
  52         done = true;
  53 }
  54
  55 static int __write_tracing_file(const char *name, const char *val, bool append)
  56 {
  57         char *file;
  58         int fd, ret = -1;
  59         ssize_t size = strlen(val);
  60         int flags = O_WRONLY;
  61
  62         file = get_tracing_file(name);
  63         if (!file) {
  64                 pr_debug("cannot get tracing file: %s\n", name);
  65                 return -1;
  66         }
  67
  68         if (append)
  69                 flags |= O_APPEND;
  70         else
  71                 flags |= O_TRUNC;
  72
  73         fd = open(file, flags);
  74         if (fd < 0) {
  75                 pr_debug("cannot open tracing file: %s\n", name);
  76                 goto out;
  77         }
  78
  79         if (write(fd, val, size) == size)
  80                 ret = 0;
  81         else
  82                 pr_debug("write '%s' to tracing/%s failed\n", val, name);
  83
  84         close(fd);
  85 out:
  86         put_tracing_file(file);
  87         return ret;
  88 }
  89
  90 static int write_tracing_file(const char *name, const char *val)
  91 {
  92         return __write_tracing_file(name, val, false);
  93 }
  94
  95 static int append_tracing_file(const char *name, const char *val)
  96 {
  97         return __write_tracing_file(name, val, true);
  98 }
  99
 100 static int reset_tracing_cpu(void);
 101
 102 static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
 103 {
 104         if (write_tracing_file("tracing_on", "0") < 0)
 105                 return -1;
 106
 107         if (write_tracing_file("current_tracer", "nop") < 0)
 108                 return -1;
 109
 110         if (write_tracing_file("set_ftrace_pid", " ") < 0)
 111                 return -1;
 112
 113         if (reset_tracing_cpu() < 0)
 114                 return -1;
 115
 116         return 0;
 117 }
 118
 119 static int set_tracing_pid(struct perf_ftrace *ftrace)
 120 {
 121         int i;
 122         char buf[16];
 123
 124         if (target__has_cpu(&ftrace->target))
 125                 return 0;
 126
 127         for (i = 0; i < thread_map__nr(ftrace->evlist->threads); i++) {
 128                 scnprintf(buf, sizeof(buf), "%d",
 129                           ftrace->evlist->threads->map[i]);
 130                 if (append_tracing_file("set_ftrace_pid", buf) < 0)
 131                         return -1;
 132         }
 133         return 0;
 134 }
 135
 136 static int set_tracing_cpumask(struct cpu_map *cpumap)
 137 {
 138         char *cpumask;
 139         size_t mask_size;
 140         int ret;
 141         int last_cpu;
 142
 143         last_cpu = cpu_map__cpu(cpumap, cpumap->nr - 1);
 144         mask_size = (last_cpu + 3) / 4 + 1;
 145         mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */
 146
 147         cpumask = malloc(mask_size);
 148         if (cpumask == NULL) {
 149                 pr_debug("failed to allocate cpu mask\n");
 150                 return -1;
 151         }
 152
 153         cpu_map__snprint_mask(cpumap, cpumask, mask_size);
 154
 155         ret = write_tracing_file("tracing_cpumask", cpumask);
 156
 157         free(cpumask);
 158         return ret;
 159 }
 160
 161 static int set_tracing_cpu(struct perf_ftrace *ftrace)
 162 {
 163         struct cpu_map *cpumap = ftrace->evlist->cpus;
 164
 165         if (!target__has_cpu(&ftrace->target))
 166                 return 0;
 167
 168         return set_tracing_cpumask(cpumap);
 169 }
 170
 171 static int reset_tracing_cpu(void)
 172 {
 173         struct cpu_map *cpumap = cpu_map__new(NULL);
 174         int ret;
 175
 176         ret = set_tracing_cpumask(cpumap);
 177         cpu_map__put(cpumap);
 178         return ret;
 179 }
 180
 181 static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 182 {
 183         char *trace_file;
 184         int trace_fd;
 185         char buf[4096];
 186         struct pollfd pollfd = {
 187                 .events = POLLIN,
 188         };
 189
 190         if (geteuid() != 0) {
 191                 pr_err("ftrace only works for root!\n");
 192                 return -1;
 193         }
 194
 195         signal(SIGINT, sig_handler);
 196         signal(SIGUSR1, sig_handler);
 197         signal(SIGCHLD, sig_handler);
 198         signal(SIGPIPE, sig_handler);
 199
 200         if (reset_tracing_files(ftrace) < 0)
 201                 goto out;
 202
 203         /* reset ftrace buffer */
 204         if (write_tracing_file("trace", "0") < 0)
 205                 goto out;
 206
 207         if (argc && perf_evlist__prepare_workload(ftrace->evlist,
 208                                 &ftrace->target, argv, false,
 209                                 ftrace__workload_exec_failed_signal) < 0) {
 210                 goto out;
 211         }
 212
 213         if (set_tracing_pid(ftrace) < 0) {
 214                 pr_err("failed to set ftrace pid\n");
 215                 goto out_reset;
 216         }
 217
 218         if (set_tracing_cpu(ftrace) < 0) {
 219                 pr_err("failed to set tracing cpumask\n");
 220                 goto out_reset;
 221         }
 222
 223         if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
 224                 pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
 225                 goto out_reset;
 226         }
 227
 228         trace_file = get_tracing_file("trace_pipe");
 229         if (!trace_file) {
 230                 pr_err("failed to open trace_pipe\n");
 231                 goto out_reset;
 232         }
 233
 234         trace_fd = open(trace_file, O_RDONLY);
 235
 236         put_tracing_file(trace_file);
 237
 238         if (trace_fd < 0) {
 239                 pr_err("failed to open trace_pipe\n");
 240                 goto out_reset;
 241         }
 242
 243         fcntl(trace_fd, F_SETFL, O_NONBLOCK);
 244         pollfd.fd = trace_fd;
 245
 246         if (write_tracing_file("tracing_on", "1") < 0) {
 247                 pr_err("can't enable tracing\n");
 248                 goto out_close_fd;
 249         }
 250
 251         setup_pager();
 252
 253         perf_evlist__start_workload(ftrace->evlist);
 254
 255         while (!done) {
 256                 if (poll(&pollfd, 1, -1) < 0)
 257                         break;
 258
 259                 if (pollfd.revents & POLLIN) {
 260                         int n = read(trace_fd, buf, sizeof(buf));
 261                         if (n < 0)
 262                                 break;
 263                         if (fwrite(buf, n, 1, stdout) != 1)
 264                                 break;
 265                 }
 266         }
 267
 268         write_tracing_file("tracing_on", "0");
 269
 270         /* read remaining buffer contents */
 271         while (true) {
 272                 int n = read(trace_fd, buf, sizeof(buf));
 273                 if (n <= 0)
 274                         break;
 275                 if (fwrite(buf, n, 1, stdout) != 1)
 276                         break;
 277         }
 278
 279 out_close_fd:
 280         close(trace_fd);
 281 out_reset:
 282         reset_tracing_files(ftrace);
 283 out:
 284         return done ? 0 : -1;
 285 }
 286
 287 static int perf_ftrace_config(const char *var, const char *value, void *cb)
 288 {
 289         struct perf_ftrace *ftrace = cb;
 290
 291         if (prefixcmp(var, "ftrace."))
 292                 return 0;
 293
 294         if (strcmp(var, "ftrace.tracer"))
 295                 return -1;
 296
 297         if (!strcmp(value, "function_graph") ||
 298             !strcmp(value, "function")) {
 299                 ftrace->tracer = value;
 300                 return 0;
 301         }
 302
 303         pr_err("Please select \"function_graph\" (default) or \"function\"\n");
 304         return -1;
 305 }
 306
 307 int cmd_ftrace(int argc, const char **argv, const char *prefix __maybe_unused)
 308 {
 309         int ret;
 310         struct perf_ftrace ftrace = {
 311                 .tracer = DEFAULT_TRACER,
 312                 .target = { .uid = UINT_MAX, },
 313         };
 314         const char * const ftrace_usage[] = {
 315                 "perf ftrace [<options>] [<command>]",
 316                 "perf ftrace [<options>] -- <command> [<options>]",
 317                 NULL
 318         };
 319         const struct option ftrace_options[] = {
 320         OPT_STRING('t', "tracer", &ftrace.tracer, "tracer",
 321                    "tracer to use: function_graph(default) or function"),
 322         OPT_STRING('p', "pid", &ftrace.target.pid, "pid",
 323                    "trace on existing process id"),
 324         OPT_INCR('v', "verbose", &verbose,
 325                  "be more verbose"),
 326         OPT_BOOLEAN('a', "all-cpus", &ftrace.target.system_wide,
 327                     "system-wide collection from all CPUs"),
 328         OPT_STRING('C', "cpu", &ftrace.target.cpu_list, "cpu",
 329                     "list of cpus to monitor"),
 330         OPT_END()
 331         };
 332
 333         ret = perf_config(perf_ftrace_config, &ftrace);
 334         if (ret < 0)
 335                 return -1;
 336
 337         argc = parse_options(argc, argv, ftrace_options, ftrace_usage,
 338                             PARSE_OPT_STOP_AT_NON_OPTION);
 339         if (!argc && target__none(&ftrace.target))
 340                 usage_with_options(ftrace_usage, ftrace_options);
 341
 342         ret = target__validate(&ftrace.target);
 343         if (ret) {
 344                 char errbuf[512];
 345
 346                 target__strerror(&ftrace.target, ret, errbuf, 512);
 347                 pr_err("%s\n", errbuf);
 348                 return -EINVAL;
 349         }
 350
 351         ftrace.evlist = perf_evlist__new();
 352         if (ftrace.evlist == NULL)
 353                 return -ENOMEM;
 354
 355         ret = perf_evlist__create_maps(ftrace.evlist, &ftrace.target);
 356         if (ret < 0)
 357                 goto out_delete_evlist;
 358
 359         ret = __cmd_ftrace(&ftrace, argc, argv);
 360
 361 out_delete_evlist:
 362         perf_evlist__delete(ftrace.evlist);
 363
 364         return ret;
 365 }