~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/builtin-ftrace.c

Version: ~ [ linux-4.15-rc8 ] ~ [ linux-4.14.13 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.76 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.111 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.48 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.91 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.53 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.98 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp