Linux Perf
builtin-ftrace.c
Go to the documentation of this file.
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 <errno.h>
13 #include <unistd.h>
14 #include <signal.h>
15 #include <fcntl.h>
16 #include <poll.h>
17 
18 #include "debug.h"
19 #include <subcmd/parse-options.h>
20 #include <api/fs/tracing_path.h>
21 #include "evlist.h"
22 #include "target.h"
23 #include "cpumap.h"
24 #include "thread_map.h"
25 #include "util/config.h"
26 
27 
28 #define DEFAULT_TRACER "function_graph"
29 
30 struct perf_ftrace {
32  struct target target;
33  const char *tracer;
34  struct list_head filters;
35  struct list_head notrace;
36  struct list_head graph_funcs;
37  struct list_head nograph_funcs;
39 };
40 
41 struct filter_entry {
42  struct list_head list;
43  char name[];
44 };
45 
46 static bool done;
47 
48 static void sig_handler(int sig __maybe_unused)
49 {
50  done = true;
51 }
52 
53 /*
54  * perf_evlist__prepare_workload will send a SIGUSR1 if the fork fails, since
55  * we asked by setting its exec_error to the function below,
56  * ftrace__workload_exec_failed_signal.
57  *
58  * XXX We need to handle this more appropriately, emitting an error, etc.
59  */
60 static void ftrace__workload_exec_failed_signal(int signo __maybe_unused,
61  siginfo_t *info __maybe_unused,
62  void *ucontext __maybe_unused)
63 {
64  /* workload_exec_errno = info->si_value.sival_int; */
65  done = true;
66 }
67 
68 static int __write_tracing_file(const char *name, const char *val, bool append)
69 {
70  char *file;
71  int fd, ret = -1;
72  ssize_t size = strlen(val);
73  int flags = O_WRONLY;
74  char errbuf[512];
75  char *val_copy;
76 
77  file = get_tracing_file(name);
78  if (!file) {
79  pr_debug("cannot get tracing file: %s\n", name);
80  return -1;
81  }
82 
83  if (append)
84  flags |= O_APPEND;
85  else
86  flags |= O_TRUNC;
87 
88  fd = open(file, flags);
89  if (fd < 0) {
90  pr_debug("cannot open tracing file: %s: %s\n",
91  name, str_error_r(errno, errbuf, sizeof(errbuf)));
92  goto out;
93  }
94 
95  /*
96  * Copy the original value and append a '\n'. Without this,
97  * the kernel can hide possible errors.
98  */
99  val_copy = strdup(val);
100  if (!val_copy)
101  goto out_close;
102  val_copy[size] = '\n';
103 
104  if (write(fd, val_copy, size + 1) == size + 1)
105  ret = 0;
106  else
107  pr_debug("write '%s' to tracing/%s failed: %s\n",
108  val, name, str_error_r(errno, errbuf, sizeof(errbuf)));
109 
110  free(val_copy);
111 out_close:
112  close(fd);
113 out:
114  put_tracing_file(file);
115  return ret;
116 }
117 
118 static int write_tracing_file(const char *name, const char *val)
119 {
120  return __write_tracing_file(name, val, false);
121 }
122 
123 static int append_tracing_file(const char *name, const char *val)
124 {
125  return __write_tracing_file(name, val, true);
126 }
127 
128 static int reset_tracing_cpu(void);
129 static void reset_tracing_filters(void);
130 
131 static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
132 {
133  if (write_tracing_file("tracing_on", "0") < 0)
134  return -1;
135 
136  if (write_tracing_file("current_tracer", "nop") < 0)
137  return -1;
138 
139  if (write_tracing_file("set_ftrace_pid", " ") < 0)
140  return -1;
141 
142  if (reset_tracing_cpu() < 0)
143  return -1;
144 
145  if (write_tracing_file("max_graph_depth", "0") < 0)
146  return -1;
147 
149  return 0;
150 }
151 
152 static int set_tracing_pid(struct perf_ftrace *ftrace)
153 {
154  int i;
155  char buf[16];
156 
157  if (target__has_cpu(&ftrace->target))
158  return 0;
159 
160  for (i = 0; i < thread_map__nr(ftrace->evlist->threads); i++) {
161  scnprintf(buf, sizeof(buf), "%d",
162  ftrace->evlist->threads->map[i]);
163  if (append_tracing_file("set_ftrace_pid", buf) < 0)
164  return -1;
165  }
166  return 0;
167 }
168 
169 static int set_tracing_cpumask(struct cpu_map *cpumap)
170 {
171  char *cpumask;
172  size_t mask_size;
173  int ret;
174  int last_cpu;
175 
176  last_cpu = cpu_map__cpu(cpumap, cpumap->nr - 1);
177  mask_size = (last_cpu + 3) / 4 + 1;
178  mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */
179 
180  cpumask = malloc(mask_size);
181  if (cpumask == NULL) {
182  pr_debug("failed to allocate cpu mask\n");
183  return -1;
184  }
185 
186  cpu_map__snprint_mask(cpumap, cpumask, mask_size);
187 
188  ret = write_tracing_file("tracing_cpumask", cpumask);
189 
190  free(cpumask);
191  return ret;
192 }
193 
194 static int set_tracing_cpu(struct perf_ftrace *ftrace)
195 {
196  struct cpu_map *cpumap = ftrace->evlist->cpus;
197 
198  if (!target__has_cpu(&ftrace->target))
199  return 0;
200 
201  return set_tracing_cpumask(cpumap);
202 }
203 
204 static int reset_tracing_cpu(void)
205 {
206  struct cpu_map *cpumap = cpu_map__new(NULL);
207  int ret;
208 
209  ret = set_tracing_cpumask(cpumap);
210  cpu_map__put(cpumap);
211  return ret;
212 }
213 
214 static int __set_tracing_filter(const char *filter_file, struct list_head *funcs)
215 {
216  struct filter_entry *pos;
217 
218  list_for_each_entry(pos, funcs, list) {
219  if (append_tracing_file(filter_file, pos->name) < 0)
220  return -1;
221  }
222 
223  return 0;
224 }
225 
226 static int set_tracing_filters(struct perf_ftrace *ftrace)
227 {
228  int ret;
229 
230  ret = __set_tracing_filter("set_ftrace_filter", &ftrace->filters);
231  if (ret < 0)
232  return ret;
233 
234  ret = __set_tracing_filter("set_ftrace_notrace", &ftrace->notrace);
235  if (ret < 0)
236  return ret;
237 
238  ret = __set_tracing_filter("set_graph_function", &ftrace->graph_funcs);
239  if (ret < 0)
240  return ret;
241 
242  /* old kernels do not have this filter */
243  __set_tracing_filter("set_graph_notrace", &ftrace->nograph_funcs);
244 
245  return ret;
246 }
247 
248 static void reset_tracing_filters(void)
249 {
250  write_tracing_file("set_ftrace_filter", " ");
251  write_tracing_file("set_ftrace_notrace", " ");
252  write_tracing_file("set_graph_function", " ");
253  write_tracing_file("set_graph_notrace", " ");
254 }
255 
256 static int set_tracing_depth(struct perf_ftrace *ftrace)
257 {
258  char buf[16];
259 
260  if (ftrace->graph_depth == 0)
261  return 0;
262 
263  if (ftrace->graph_depth < 0) {
264  pr_err("invalid graph depth: %d\n", ftrace->graph_depth);
265  return -1;
266  }
267 
268  snprintf(buf, sizeof(buf), "%d", ftrace->graph_depth);
269 
270  if (write_tracing_file("max_graph_depth", buf) < 0)
271  return -1;
272 
273  return 0;
274 }
275 
276 static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
277 {
278  char *trace_file;
279  int trace_fd;
280  char buf[4096];
281  struct pollfd pollfd = {
282  .events = POLLIN,
283  };
284 
285  if (geteuid() != 0) {
286  pr_err("ftrace only works for root!\n");
287  return -1;
288  }
289 
290  signal(SIGINT, sig_handler);
291  signal(SIGUSR1, sig_handler);
292  signal(SIGCHLD, sig_handler);
293  signal(SIGPIPE, sig_handler);
294 
295  if (reset_tracing_files(ftrace) < 0) {
296  pr_err("failed to reset ftrace\n");
297  goto out;
298  }
299 
300  /* reset ftrace buffer */
301  if (write_tracing_file("trace", "0") < 0)
302  goto out;
303 
304  if (argc && perf_evlist__prepare_workload(ftrace->evlist,
305  &ftrace->target, argv, false,
307  goto out;
308  }
309 
310  if (set_tracing_pid(ftrace) < 0) {
311  pr_err("failed to set ftrace pid\n");
312  goto out_reset;
313  }
314 
315  if (set_tracing_cpu(ftrace) < 0) {
316  pr_err("failed to set tracing cpumask\n");
317  goto out_reset;
318  }
319 
320  if (set_tracing_filters(ftrace) < 0) {
321  pr_err("failed to set tracing filters\n");
322  goto out_reset;
323  }
324 
325  if (set_tracing_depth(ftrace) < 0) {
326  pr_err("failed to set graph depth\n");
327  goto out_reset;
328  }
329 
330  if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
331  pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
332  goto out_reset;
333  }
334 
335  setup_pager();
336 
337  trace_file = get_tracing_file("trace_pipe");
338  if (!trace_file) {
339  pr_err("failed to open trace_pipe\n");
340  goto out_reset;
341  }
342 
343  trace_fd = open(trace_file, O_RDONLY);
344 
345  put_tracing_file(trace_file);
346 
347  if (trace_fd < 0) {
348  pr_err("failed to open trace_pipe\n");
349  goto out_reset;
350  }
351 
352  fcntl(trace_fd, F_SETFL, O_NONBLOCK);
353  pollfd.fd = trace_fd;
354 
355  if (write_tracing_file("tracing_on", "1") < 0) {
356  pr_err("can't enable tracing\n");
357  goto out_close_fd;
358  }
359 
361 
362  while (!done) {
363  if (poll(&pollfd, 1, -1) < 0)
364  break;
365 
366  if (pollfd.revents & POLLIN) {
367  int n = read(trace_fd, buf, sizeof(buf));
368  if (n < 0)
369  break;
370  if (fwrite(buf, n, 1, stdout) != 1)
371  break;
372  }
373  }
374 
375  write_tracing_file("tracing_on", "0");
376 
377  /* read remaining buffer contents */
378  while (true) {
379  int n = read(trace_fd, buf, sizeof(buf));
380  if (n <= 0)
381  break;
382  if (fwrite(buf, n, 1, stdout) != 1)
383  break;
384  }
385 
386 out_close_fd:
387  close(trace_fd);
388 out_reset:
389  reset_tracing_files(ftrace);
390 out:
391  return done ? 0 : -1;
392 }
393 
394 static int perf_ftrace_config(const char *var, const char *value, void *cb)
395 {
396  struct perf_ftrace *ftrace = cb;
397 
398  if (!strstarts(var, "ftrace."))
399  return 0;
400 
401  if (strcmp(var, "ftrace.tracer"))
402  return -1;
403 
404  if (!strcmp(value, "function_graph") ||
405  !strcmp(value, "function")) {
406  ftrace->tracer = value;
407  return 0;
408  }
409 
410  pr_err("Please select \"function_graph\" (default) or \"function\"\n");
411  return -1;
412 }
413 
414 static int parse_filter_func(const struct option *opt, const char *str,
415  int unset __maybe_unused)
416 {
417  struct list_head *head = opt->value;
418  struct filter_entry *entry;
419 
420  entry = malloc(sizeof(*entry) + strlen(str) + 1);
421  if (entry == NULL)
422  return -ENOMEM;
423 
424  strcpy(entry->name, str);
425  list_add_tail(&entry->list, head);
426 
427  return 0;
428 }
429 
430 static void delete_filter_func(struct list_head *head)
431 {
432  struct filter_entry *pos, *tmp;
433 
434  list_for_each_entry_safe(pos, tmp, head, list) {
435  list_del(&pos->list);
436  free(pos);
437  }
438 }
439 
440 int cmd_ftrace(int argc, const char **argv)
441 {
442  int ret;
443  struct perf_ftrace ftrace = {
445  .target = { .uid = UINT_MAX, },
446  };
447  const char * const ftrace_usage[] = {
448  "perf ftrace [<options>] [<command>]",
449  "perf ftrace [<options>] -- <command> [<options>]",
450  NULL
451  };
452  const struct option ftrace_options[] = {
453  OPT_STRING('t', "tracer", &ftrace.tracer, "tracer",
454  "tracer to use: function_graph(default) or function"),
455  OPT_STRING('p', "pid", &ftrace.target.pid, "pid",
456  "trace on existing process id"),
457  OPT_INCR('v', "verbose", &verbose,
458  "be more verbose"),
459  OPT_BOOLEAN('a', "all-cpus", &ftrace.target.system_wide,
460  "system-wide collection from all CPUs"),
461  OPT_STRING('C', "cpu", &ftrace.target.cpu_list, "cpu",
462  "list of cpus to monitor"),
463  OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func",
464  "trace given functions only", parse_filter_func),
465  OPT_CALLBACK('N', "notrace-funcs", &ftrace.notrace, "func",
466  "do not trace given functions", parse_filter_func),
467  OPT_CALLBACK('G', "graph-funcs", &ftrace.graph_funcs, "func",
468  "Set graph filter on given functions", parse_filter_func),
469  OPT_CALLBACK('g', "nograph-funcs", &ftrace.nograph_funcs, "func",
470  "Set nograph filter on given functions", parse_filter_func),
471  OPT_INTEGER('D', "graph-depth", &ftrace.graph_depth,
472  "Max depth for function graph tracer"),
473  OPT_END()
474  };
475 
476  INIT_LIST_HEAD(&ftrace.filters);
477  INIT_LIST_HEAD(&ftrace.notrace);
478  INIT_LIST_HEAD(&ftrace.graph_funcs);
479  INIT_LIST_HEAD(&ftrace.nograph_funcs);
480 
481  ret = perf_config(perf_ftrace_config, &ftrace);
482  if (ret < 0)
483  return -1;
484 
485  argc = parse_options(argc, argv, ftrace_options, ftrace_usage,
486  PARSE_OPT_STOP_AT_NON_OPTION);
487  if (!argc && target__none(&ftrace.target))
488  usage_with_options(ftrace_usage, ftrace_options);
489 
490  ret = target__validate(&ftrace.target);
491  if (ret) {
492  char errbuf[512];
493 
494  target__strerror(&ftrace.target, ret, errbuf, 512);
495  pr_err("%s\n", errbuf);
496  goto out_delete_filters;
497  }
498 
499  ftrace.evlist = perf_evlist__new();
500  if (ftrace.evlist == NULL) {
501  ret = -ENOMEM;
502  goto out_delete_filters;
503  }
504 
505  ret = perf_evlist__create_maps(ftrace.evlist, &ftrace.target);
506  if (ret < 0)
507  goto out_delete_evlist;
508 
509  ret = __cmd_ftrace(&ftrace, argc, argv);
510 
511 out_delete_evlist:
512  perf_evlist__delete(ftrace.evlist);
513 
514 out_delete_filters:
515  delete_filter_func(&ftrace.filters);
516  delete_filter_func(&ftrace.notrace);
519 
520  return ret;
521 }
static int parse_filter_func(const struct option *opt, const char *str, int unset __maybe_unused)
int nr
Definition: cpumap.h:14
struct target target
#define DEFAULT_TRACER
int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target, const char *argv[], bool pipe_output, void(*exec_error)(int signo, siginfo_t *info, void *ucontext))
Definition: evlist.c:1428
int value
Definition: python.c:1143
int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
Definition: evlist.c:1066
size_t size
Definition: evsel.c:60
enum target_errno target__validate(struct target *target)
Definition: target.c:17
static int set_tracing_cpu(struct perf_ftrace *ftrace)
static void ftrace__workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info __maybe_unused, void *ucontext __maybe_unused)
int cmd_ftrace(int argc, const char **argv)
void perf_evlist__delete(struct perf_evlist *evlist)
Definition: evlist.c:133
struct list_head graph_funcs
size_t cpu_map__snprint_mask(struct cpu_map *map, char *buf, size_t size)
Definition: cpumap.c:690
static int set_tracing_depth(struct perf_ftrace *ftrace)
Definition: cpumap.h:12
int perf_evlist__start_workload(struct perf_evlist *evlist)
Definition: evlist.c:1542
struct thread_map * threads
Definition: evlist.h:47
static bool target__none(struct target *target)
Definition: target.h:62
static bool done
#define pr_err(fmt,...)
Definition: json.h:21
static int perf_ftrace_config(const char *var, const char *value, void *cb)
void * malloc(YYSIZE_T)
int target__strerror(struct target *target, int errnum, char *buf, size_t buflen)
Definition: target.c:116
void cpu_map__put(struct cpu_map *map)
Definition: cpumap.c:298
static size_t mask_size(struct cpu_map *map, int *max)
Definition: event.c:1030
const char * name
bool system_wide
Definition: target.h:14
#define pr_debug(fmt,...)
Definition: json.h:27
static int write_tracing_file(const char *name, const char *val)
static int __write_tracing_file(const char *name, const char *val, bool append)
static bool target__has_cpu(struct target *target)
Definition: target.h:57
static int entry(u64 ip, struct unwind_info *ui)
Definition: unwind-libdw.c:71
int cpu_map__cpu(struct cpu_map *cpus, int idx)
Definition: cpumap.c:633
static int str(yyscan_t scanner, int token)
struct list_head nograph_funcs
static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
char name[]
struct thread_map_data map[]
Definition: thread_map.h:18
static int set_tracing_pid(struct perf_ftrace *ftrace)
static void reset_tracing_filters(void)
struct list_head filters
static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
static int set_tracing_filters(struct perf_ftrace *ftrace)
static int set_tracing_cpumask(struct cpu_map *cpumap)
static int thread_map__nr(struct thread_map *threads)
Definition: thread_map.h:41
static int reset_tracing_cpu(void)
struct perf_evlist * evlist
static int append_tracing_file(const char *name, const char *val)
int perf_config(config_fn_t fn, void *data)
Definition: config.c:718
static void delete_filter_func(struct list_head *head)
u32 flags
static int __set_tracing_filter(const char *filter_file, struct list_head *funcs)
const char * cpu_list
Definition: target.h:11
void free(void *)
const char * tracer
struct list_head list
static void sig_handler(int sig __maybe_unused)
const char * pid
Definition: target.h:9
struct list_head notrace
struct cpu_map * cpus
Definition: evlist.h:48
int verbose
Definition: jevents.c:53
struct cpu_map * cpu_map__new(const char *cpu_list)
Definition: cpumap.c:125
struct perf_evlist * perf_evlist__new(void)
Definition: evlist.c:54
Definition: target.h:8