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

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

Version: ~ [ linux-4.17-rc6 ] ~ [ linux-4.16.10 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.42 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.101 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.132 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.51 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.109 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.56 ] ~ [ 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.101 ] ~ [ 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         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)
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)
146                 return -1;
147 
148         reset_tracing_filters();
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)
302                 goto out;
303 
304         if (argc && perf_evlist__prepare_workload(ftrace->evlist,
305                                 &ftrace->target, argv, false,
306                                 ftrace__workload_exec_failed_signal) < 0) {
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 
360         perf_evlist__start_workload(ftrace->evlist);
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", "");
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 = {
444                 .tracer = DEFAULT_TRACER,
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);
517         delete_filter_func(&ftrace.graph_funcs);
518         delete_filter_func(&ftrace.nograph_funcs);
519 
520         return ret;
521 }
522 

~ [ 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