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") < 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") < 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") < 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", "0"); 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 (prefixcmp(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