1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * builtin-ftrace.c 4 * 5 * Copyright (c) 2013 LG Electronics, Namhyung Kim <namhyung@kernel.org> 6 * Copyright (c) 2020 Changbin Du <changbin.du@gmail.com>, significant enhancement. 7 */ 8 9 #include "builtin.h" 10 11 #include <errno.h> 12 #include <unistd.h> 13 #include <signal.h> 14 #include <stdlib.h> 15 #include <fcntl.h> 16 #include <math.h> 17 #include <poll.h> 18 #include <ctype.h> 19 #include <linux/capability.h> 20 #include <linux/string.h> 21 22 #include "debug.h" 23 #include <subcmd/pager.h> 24 #include <subcmd/parse-options.h> 25 #include <api/fs/tracing_path.h> 26 #include "evlist.h" 27 #include "target.h" 28 #include "cpumap.h" 29 #include "thread_map.h" 30 #include "strfilter.h" 31 #include "util/cap.h" 32 #include "util/config.h" 33 #include "util/ftrace.h" 34 #include "util/units.h" 35 #include "util/parse-sublevel-options.h" 36 37 #define DEFAULT_TRACER "function_graph" 38 39 static volatile int workload_exec_errno; 40 static bool done; 41 42 static void sig_handler(int sig __maybe_unused) 43 { 44 done = true; 45 } 46 47 /* 48 * evlist__prepare_workload will send a SIGUSR1 if the fork fails, since 49 * we asked by setting its exec_error to the function below, 50 * ftrace__workload_exec_failed_signal. 51 * 52 * XXX We need to handle this more appropriately, emitting an error, etc. 53 */ 54 static void ftrace__workload_exec_failed_signal(int signo __maybe_unused, 55 siginfo_t *info __maybe_unused, 56 void *ucontext __maybe_unused) 57 { 58 workload_exec_errno = info->si_value.sival_int; 59 done = true; 60 } 61 62 static int __write_tracing_file(const char *name, const char *val, bool append) 63 { 64 char *file; 65 int fd, ret = -1; 66 ssize_t size = strlen(val); 67 int flags = O_WRONLY; 68 char errbuf[512]; 69 char *val_copy; 70 71 file = get_tracing_file(name); 72 if (!file) { 73 pr_debug("cannot get tracing file: %s\n", name); 74 return -1; 75 } 76 77 if (append) 78 flags |= O_APPEND; 79 else 80 flags |= O_TRUNC; 81 82 fd = open(file, flags); 83 if (fd < 0) { 84 pr_debug("cannot open tracing file: %s: %s\n", 85 name, str_error_r(errno, errbuf, sizeof(errbuf))); 86 goto out; 87 } 88 89 /* 90 * Copy the original value and append a '\n'. Without this, 91 * the kernel can hide possible errors. 92 */ 93 val_copy = strdup(val); 94 if (!val_copy) 95 goto out_close; 96 val_copy[size] = '\n'; 97 98 if (write(fd, val_copy, size + 1) == size + 1) 99 ret = 0; 100 else 101 pr_debug("write '%s' to tracing/%s failed: %s\n", 102 val, name, str_error_r(errno, errbuf, sizeof(errbuf))); 103 104 free(val_copy); 105 out_close: 106 close(fd); 107 out: 108 put_tracing_file(file); 109 return ret; 110 } 111 112 static int write_tracing_file(const char *name, const char *val) 113 { 114 return __write_tracing_file(name, val, false); 115 } 116 117 static int append_tracing_file(const char *name, const char *val) 118 { 119 return __write_tracing_file(name, val, true); 120 } 121 122 static int read_tracing_file_to_stdout(const char *name) 123 { 124 char buf[4096]; 125 char *file; 126 int fd; 127 int ret = -1; 128 129 file = get_tracing_file(name); 130 if (!file) { 131 pr_debug("cannot get tracing file: %s\n", name); 132 return -1; 133 } 134 135 fd = open(file, O_RDONLY); 136 if (fd < 0) { 137 pr_debug("cannot open tracing file: %s: %s\n", 138 name, str_error_r(errno, buf, sizeof(buf))); 139 goto out; 140 } 141 142 /* read contents to stdout */ 143 while (true) { 144 int n = read(fd, buf, sizeof(buf)); 145 if (n == 0) 146 break; 147 else if (n < 0) 148 goto out_close; 149 150 if (fwrite(buf, n, 1, stdout) != 1) 151 goto out_close; 152 } 153 ret = 0; 154 155 out_close: 156 close(fd); 157 out: 158 put_tracing_file(file); 159 return ret; 160 } 161 162 static int read_tracing_file_by_line(const char *name, 163 void (*cb)(char *str, void *arg), 164 void *cb_arg) 165 { 166 char *line = NULL; 167 size_t len = 0; 168 char *file; 169 FILE *fp; 170 171 file = get_tracing_file(name); 172 if (!file) { 173 pr_debug("cannot get tracing file: %s\n", name); 174 return -1; 175 } 176 177 fp = fopen(file, "r"); 178 if (fp == NULL) { 179 pr_debug("cannot open tracing file: %s\n", name); 180 put_tracing_file(file); 181 return -1; 182 } 183 184 while (getline(&line, &len, fp) != -1) { 185 cb(line, cb_arg); 186 } 187 188 if (line) 189 free(line); 190 191 fclose(fp); 192 put_tracing_file(file); 193 return 0; 194 } 195 196 static int write_tracing_file_int(const char *name, int value) 197 { 198 char buf[16]; 199 200 snprintf(buf, sizeof(buf), "%d", value); 201 if (write_tracing_file(name, buf) < 0) 202 return -1; 203 204 return 0; 205 } 206 207 static int write_tracing_option_file(const char *name, const char *val) 208 { 209 char *file; 210 int ret; 211 212 if (asprintf(&file, "options/%s", name) < 0) 213 return -1; 214 215 ret = __write_tracing_file(file, val, false); 216 free(file); 217 return ret; 218 } 219 220 static int reset_tracing_cpu(void); 221 static void reset_tracing_filters(void); 222 223 static void reset_tracing_options(struct perf_ftrace *ftrace __maybe_unused) 224 { 225 write_tracing_option_file("function-fork", "0"); 226 write_tracing_option_file("func_stack_trace", "0"); 227 write_tracing_option_file("sleep-time", "1"); 228 write_tracing_option_file("funcgraph-irqs", "1"); 229 write_tracing_option_file("funcgraph-proc", "0"); 230 write_tracing_option_file("funcgraph-abstime", "0"); 231 write_tracing_option_file("latency-format", "0"); 232 write_tracing_option_file("irq-info", "0"); 233 } 234 235 static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused) 236 { 237 if (write_tracing_file("tracing_on", "0") < 0) 238 return -1; 239 240 if (write_tracing_file("current_tracer", "nop") < 0) 241 return -1; 242 243 if (write_tracing_file("set_ftrace_pid", " ") < 0) 244 return -1; 245 246 if (reset_tracing_cpu() < 0) 247 return -1; 248 249 if (write_tracing_file("max_graph_depth", "0") < 0) 250 return -1; 251 252 if (write_tracing_file("tracing_thresh", "0") < 0) 253 return -1; 254 255 reset_tracing_filters(); 256 reset_tracing_options(ftrace); 257 return 0; 258 } 259 260 static int set_tracing_pid(struct perf_ftrace *ftrace) 261 { 262 int i; 263 char buf[16]; 264 265 if (target__has_cpu(&ftrace->target)) 266 return 0; 267 268 for (i = 0; i < perf_thread_map__nr(ftrace->evlist->core.threads); i++) { 269 scnprintf(buf, sizeof(buf), "%d", 270 perf_thread_map__pid(ftrace->evlist->core.threads, i)); 271 if (append_tracing_file("set_ftrace_pid", buf) < 0) 272 return -1; 273 } 274 return 0; 275 } 276 277 static int set_tracing_cpumask(struct perf_cpu_map *cpumap) 278 { 279 char *cpumask; 280 size_t mask_size; 281 int ret; 282 int last_cpu; 283 284 last_cpu = perf_cpu_map__cpu(cpumap, perf_cpu_map__nr(cpumap) - 1).cpu; 285 mask_size = last_cpu / 4 + 2; /* one more byte for EOS */ 286 mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */ 287 288 cpumask = malloc(mask_size); 289 if (cpumask == NULL) { 290 pr_debug("failed to allocate cpu mask\n"); 291 return -1; 292 } 293 294 cpu_map__snprint_mask(cpumap, cpumask, mask_size); 295 296 ret = write_tracing_file("tracing_cpumask", cpumask); 297 298 free(cpumask); 299 return ret; 300 } 301 302 static int set_tracing_cpu(struct perf_ftrace *ftrace) 303 { 304 struct perf_cpu_map *cpumap = ftrace->evlist->core.user_requested_cpus; 305 306 if (!target__has_cpu(&ftrace->target)) 307 return 0; 308 309 return set_tracing_cpumask(cpumap); 310 } 311 312 static int set_tracing_func_stack_trace(struct perf_ftrace *ftrace) 313 { 314 if (!ftrace->func_stack_trace) 315 return 0; 316 317 if (write_tracing_option_file("func_stack_trace", "1") < 0) 318 return -1; 319 320 return 0; 321 } 322 323 static int set_tracing_func_irqinfo(struct perf_ftrace *ftrace) 324 { 325 if (!ftrace->func_irq_info) 326 return 0; 327 328 if (write_tracing_option_file("irq-info", "1") < 0) 329 return -1; 330 331 return 0; 332 } 333 334 static int reset_tracing_cpu(void) 335 { 336 struct perf_cpu_map *cpumap = perf_cpu_map__new(NULL); 337 int ret; 338 339 ret = set_tracing_cpumask(cpumap); 340 perf_cpu_map__put(cpumap); 341 return ret; 342 } 343 344 static int __set_tracing_filter(const char *filter_file, struct list_head *funcs) 345 { 346 struct filter_entry *pos; 347 348 list_for_each_entry(pos, funcs, list) { 349 if (append_tracing_file(filter_file, pos->name) < 0) 350 return -1; 351 } 352 353 return 0; 354 } 355 356 static int set_tracing_filters(struct perf_ftrace *ftrace) 357 { 358 int ret; 359 360 ret = __set_tracing_filter("set_ftrace_filter", &ftrace->filters); 361 if (ret < 0) 362 return ret; 363 364 ret = __set_tracing_filter("set_ftrace_notrace", &ftrace->notrace); 365 if (ret < 0) 366 return ret; 367 368 ret = __set_tracing_filter("set_graph_function", &ftrace->graph_funcs); 369 if (ret < 0) 370 return ret; 371 372 /* old kernels do not have this filter */ 373 __set_tracing_filter("set_graph_notrace", &ftrace->nograph_funcs); 374 375 return ret; 376 } 377 378 static void reset_tracing_filters(void) 379 { 380 write_tracing_file("set_ftrace_filter", " "); 381 write_tracing_file("set_ftrace_notrace", " "); 382 write_tracing_file("set_graph_function", " "); 383 write_tracing_file("set_graph_notrace", " "); 384 } 385 386 static int set_tracing_depth(struct perf_ftrace *ftrace) 387 { 388 if (ftrace->graph_depth == 0) 389 return 0; 390 391 if (ftrace->graph_depth < 0) { 392 pr_err("invalid graph depth: %d\n", ftrace->graph_depth); 393 return -1; 394 } 395 396 if (write_tracing_file_int("max_graph_depth", ftrace->graph_depth) < 0) 397 return -1; 398 399 return 0; 400 } 401 402 static int set_tracing_percpu_buffer_size(struct perf_ftrace *ftrace) 403 { 404 int ret; 405 406 if (ftrace->percpu_buffer_size == 0) 407 return 0; 408 409 ret = write_tracing_file_int("buffer_size_kb", 410 ftrace->percpu_buffer_size / 1024); 411 if (ret < 0) 412 return ret; 413 414 return 0; 415 } 416 417 static int set_tracing_trace_inherit(struct perf_ftrace *ftrace) 418 { 419 if (!ftrace->inherit) 420 return 0; 421 422 if (write_tracing_option_file("function-fork", "1") < 0) 423 return -1; 424 425 return 0; 426 } 427 428 static int set_tracing_sleep_time(struct perf_ftrace *ftrace) 429 { 430 if (!ftrace->graph_nosleep_time) 431 return 0; 432 433 if (write_tracing_option_file("sleep-time", "0") < 0) 434 return -1; 435 436 return 0; 437 } 438 439 static int set_tracing_funcgraph_irqs(struct perf_ftrace *ftrace) 440 { 441 if (!ftrace->graph_noirqs) 442 return 0; 443 444 if (write_tracing_option_file("funcgraph-irqs", "0") < 0) 445 return -1; 446 447 return 0; 448 } 449 450 static int set_tracing_funcgraph_verbose(struct perf_ftrace *ftrace) 451 { 452 if (!ftrace->graph_verbose) 453 return 0; 454 455 if (write_tracing_option_file("funcgraph-proc", "1") < 0) 456 return -1; 457 458 if (write_tracing_option_file("funcgraph-abstime", "1") < 0) 459 return -1; 460 461 if (write_tracing_option_file("latency-format", "1") < 0) 462 return -1; 463 464 return 0; 465 } 466 467 static int set_tracing_thresh(struct perf_ftrace *ftrace) 468 { 469 int ret; 470 471 if (ftrace->graph_thresh == 0) 472 return 0; 473 474 ret = write_tracing_file_int("tracing_thresh", ftrace->graph_thresh); 475 if (ret < 0) 476 return ret; 477 478 return 0; 479 } 480 481 static int set_tracing_options(struct perf_ftrace *ftrace) 482 { 483 if (set_tracing_pid(ftrace) < 0) { 484 pr_err("failed to set ftrace pid\n"); 485 return -1; 486 } 487 488 if (set_tracing_cpu(ftrace) < 0) { 489 pr_err("failed to set tracing cpumask\n"); 490 return -1; 491 } 492 493 if (set_tracing_func_stack_trace(ftrace) < 0) { 494 pr_err("failed to set tracing option func_stack_trace\n"); 495 return -1; 496 } 497 498 if (set_tracing_func_irqinfo(ftrace) < 0) { 499 pr_err("failed to set tracing option irq-info\n"); 500 return -1; 501 } 502 503 if (set_tracing_filters(ftrace) < 0) { 504 pr_err("failed to set tracing filters\n"); 505 return -1; 506 } 507 508 if (set_tracing_depth(ftrace) < 0) { 509 pr_err("failed to set graph depth\n"); 510 return -1; 511 } 512 513 if (set_tracing_percpu_buffer_size(ftrace) < 0) { 514 pr_err("failed to set tracing per-cpu buffer size\n"); 515 return -1; 516 } 517 518 if (set_tracing_trace_inherit(ftrace) < 0) { 519 pr_err("failed to set tracing option function-fork\n"); 520 return -1; 521 } 522 523 if (set_tracing_sleep_time(ftrace) < 0) { 524 pr_err("failed to set tracing option sleep-time\n"); 525 return -1; 526 } 527 528 if (set_tracing_funcgraph_irqs(ftrace) < 0) { 529 pr_err("failed to set tracing option funcgraph-irqs\n"); 530 return -1; 531 } 532 533 if (set_tracing_funcgraph_verbose(ftrace) < 0) { 534 pr_err("failed to set tracing option funcgraph-proc/funcgraph-abstime\n"); 535 return -1; 536 } 537 538 if (set_tracing_thresh(ftrace) < 0) { 539 pr_err("failed to set tracing thresh\n"); 540 return -1; 541 } 542 543 return 0; 544 } 545 546 static void select_tracer(struct perf_ftrace *ftrace) 547 { 548 bool graph = !list_empty(&ftrace->graph_funcs) || 549 !list_empty(&ftrace->nograph_funcs); 550 bool func = !list_empty(&ftrace->filters) || 551 !list_empty(&ftrace->notrace); 552 553 /* The function_graph has priority over function tracer. */ 554 if (graph) 555 ftrace->tracer = "function_graph"; 556 else if (func) 557 ftrace->tracer = "function"; 558 /* Otherwise, the default tracer is used. */ 559 560 pr_debug("%s tracer is used\n", ftrace->tracer); 561 } 562 563 static int __cmd_ftrace(struct perf_ftrace *ftrace) 564 { 565 char *trace_file; 566 int trace_fd; 567 char buf[4096]; 568 struct pollfd pollfd = { 569 .events = POLLIN, 570 }; 571 572 if (!(perf_cap__capable(CAP_PERFMON) || 573 perf_cap__capable(CAP_SYS_ADMIN))) { 574 pr_err("ftrace only works for %s!\n", 575 #ifdef HAVE_LIBCAP_SUPPORT 576 "users with the CAP_PERFMON or CAP_SYS_ADMIN capability" 577 #else 578 "root" 579 #endif 580 ); 581 return -1; 582 } 583 584 select_tracer(ftrace); 585 586 if (reset_tracing_files(ftrace) < 0) { 587 pr_err("failed to reset ftrace\n"); 588 goto out; 589 } 590 591 /* reset ftrace buffer */ 592 if (write_tracing_file("trace", "0") < 0) 593 goto out; 594 595 if (set_tracing_options(ftrace) < 0) 596 goto out_reset; 597 598 if (write_tracing_file("current_tracer", ftrace->tracer) < 0) { 599 pr_err("failed to set current_tracer to %s\n", ftrace->tracer); 600 goto out_reset; 601 } 602 603 setup_pager(); 604 605 trace_file = get_tracing_file("trace_pipe"); 606 if (!trace_file) { 607 pr_err("failed to open trace_pipe\n"); 608 goto out_reset; 609 } 610 611 trace_fd = open(trace_file, O_RDONLY); 612 613 put_tracing_file(trace_file); 614 615 if (trace_fd < 0) { 616 pr_err("failed to open trace_pipe\n"); 617 goto out_reset; 618 } 619 620 fcntl(trace_fd, F_SETFL, O_NONBLOCK); 621 pollfd.fd = trace_fd; 622 623 /* display column headers */ 624 read_tracing_file_to_stdout("trace"); 625 626 if (!ftrace->initial_delay) { 627 if (write_tracing_file("tracing_on", "1") < 0) { 628 pr_err("can't enable tracing\n"); 629 goto out_close_fd; 630 } 631 } 632 633 evlist__start_workload(ftrace->evlist); 634 635 if (ftrace->initial_delay) { 636 usleep(ftrace->initial_delay * 1000); 637 if (write_tracing_file("tracing_on", "1") < 0) { 638 pr_err("can't enable tracing\n"); 639 goto out_close_fd; 640 } 641 } 642 643 while (!done) { 644 if (poll(&pollfd, 1, -1) < 0) 645 break; 646 647 if (pollfd.revents & POLLIN) { 648 int n = read(trace_fd, buf, sizeof(buf)); 649 if (n < 0) 650 break; 651 if (fwrite(buf, n, 1, stdout) != 1) 652 break; 653 } 654 } 655 656 write_tracing_file("tracing_on", "0"); 657 658 if (workload_exec_errno) { 659 const char *emsg = str_error_r(workload_exec_errno, buf, sizeof(buf)); 660 /* flush stdout first so below error msg appears at the end. */ 661 fflush(stdout); 662 pr_err("workload failed: %s\n", emsg); 663 goto out_close_fd; 664 } 665 666 /* read remaining buffer contents */ 667 while (true) { 668 int n = read(trace_fd, buf, sizeof(buf)); 669 if (n <= 0) 670 break; 671 if (fwrite(buf, n, 1, stdout) != 1) 672 break; 673 } 674 675 out_close_fd: 676 close(trace_fd); 677 out_reset: 678 reset_tracing_files(ftrace); 679 out: 680 return (done && !workload_exec_errno) ? 0 : -1; 681 } 682 683 static void make_histogram(int buckets[], char *buf, size_t len, char *linebuf, 684 bool use_nsec) 685 { 686 char *p, *q; 687 char *unit; 688 double num; 689 int i; 690 691 /* ensure NUL termination */ 692 buf[len] = '\0'; 693 694 /* handle data line by line */ 695 for (p = buf; (q = strchr(p, '\n')) != NULL; p = q + 1) { 696 *q = '\0'; 697 /* move it to the line buffer */ 698 strcat(linebuf, p); 699 700 /* 701 * parse trace output to get function duration like in 702 * 703 * # tracer: function_graph 704 * # 705 * # CPU DURATION FUNCTION CALLS 706 * # | | | | | | | 707 * 1) + 10.291 us | do_filp_open(); 708 * 1) 4.889 us | do_filp_open(); 709 * 1) 6.086 us | do_filp_open(); 710 * 711 */ 712 if (linebuf[0] == '#') 713 goto next; 714 715 /* ignore CPU */ 716 p = strchr(linebuf, ')'); 717 if (p == NULL) 718 p = linebuf; 719 720 while (*p && !isdigit(*p) && (*p != '|')) 721 p++; 722 723 /* no duration */ 724 if (*p == '\0' || *p == '|') 725 goto next; 726 727 num = strtod(p, &unit); 728 if (!unit || strncmp(unit, " us", 3)) 729 goto next; 730 731 if (use_nsec) 732 num *= 1000; 733 734 i = log2(num); 735 if (i < 0) 736 i = 0; 737 if (i >= NUM_BUCKET) 738 i = NUM_BUCKET - 1; 739 740 buckets[i]++; 741 742 next: 743 /* empty the line buffer for the next output */ 744 linebuf[0] = '\0'; 745 } 746 747 /* preserve any remaining output (before newline) */ 748 strcat(linebuf, p); 749 } 750 751 static void display_histogram(int buckets[], bool use_nsec) 752 { 753 int i; 754 int total = 0; 755 int bar_total = 46; /* to fit in 80 column */ 756 char bar[] = "###############################################"; 757 int bar_len; 758 759 for (i = 0; i < NUM_BUCKET; i++) 760 total += buckets[i]; 761 762 if (total == 0) { 763 printf("No data found\n"); 764 return; 765 } 766 767 printf("# %14s | %10s | %-*s |\n", 768 " DURATION ", "COUNT", bar_total, "GRAPH"); 769 770 bar_len = buckets[0] * bar_total / total; 771 printf(" %4d - %-4d %s | %10d | %.*s%*s |\n", 772 0, 1, "us", buckets[0], bar_len, bar, bar_total - bar_len, ""); 773 774 for (i = 1; i < NUM_BUCKET - 1; i++) { 775 int start = (1 << (i - 1)); 776 int stop = 1 << i; 777 const char *unit = use_nsec ? "ns" : "us"; 778 779 if (start >= 1024) { 780 start >>= 10; 781 stop >>= 10; 782 unit = use_nsec ? "us" : "ms"; 783 } 784 bar_len = buckets[i] * bar_total / total; 785 printf(" %4d - %-4d %s | %10d | %.*s%*s |\n", 786 start, stop, unit, buckets[i], bar_len, bar, 787 bar_total - bar_len, ""); 788 } 789 790 bar_len = buckets[NUM_BUCKET - 1] * bar_total / total; 791 printf(" %4d - %-4s %s | %10d | %.*s%*s |\n", 792 1, "...", use_nsec ? "ms" : " s", buckets[NUM_BUCKET - 1], 793 bar_len, bar, bar_total - bar_len, ""); 794 795 } 796 797 static int prepare_func_latency(struct perf_ftrace *ftrace) 798 { 799 char *trace_file; 800 int fd; 801 802 if (ftrace->target.use_bpf) 803 return perf_ftrace__latency_prepare_bpf(ftrace); 804 805 if (reset_tracing_files(ftrace) < 0) { 806 pr_err("failed to reset ftrace\n"); 807 return -1; 808 } 809 810 /* reset ftrace buffer */ 811 if (write_tracing_file("trace", "0") < 0) 812 return -1; 813 814 if (set_tracing_options(ftrace) < 0) 815 return -1; 816 817 /* force to use the function_graph tracer to track duration */ 818 if (write_tracing_file("current_tracer", "function_graph") < 0) { 819 pr_err("failed to set current_tracer to function_graph\n"); 820 return -1; 821 } 822 823 trace_file = get_tracing_file("trace_pipe"); 824 if (!trace_file) { 825 pr_err("failed to open trace_pipe\n"); 826 return -1; 827 } 828 829 fd = open(trace_file, O_RDONLY); 830 if (fd < 0) 831 pr_err("failed to open trace_pipe\n"); 832 833 put_tracing_file(trace_file); 834 return fd; 835 } 836 837 static int start_func_latency(struct perf_ftrace *ftrace) 838 { 839 if (ftrace->target.use_bpf) 840 return perf_ftrace__latency_start_bpf(ftrace); 841 842 if (write_tracing_file("tracing_on", "1") < 0) { 843 pr_err("can't enable tracing\n"); 844 return -1; 845 } 846 847 return 0; 848 } 849 850 static int stop_func_latency(struct perf_ftrace *ftrace) 851 { 852 if (ftrace->target.use_bpf) 853 return perf_ftrace__latency_stop_bpf(ftrace); 854 855 write_tracing_file("tracing_on", "0"); 856 return 0; 857 } 858 859 static int read_func_latency(struct perf_ftrace *ftrace, int buckets[]) 860 { 861 if (ftrace->target.use_bpf) 862 return perf_ftrace__latency_read_bpf(ftrace, buckets); 863 864 return 0; 865 } 866 867 static int cleanup_func_latency(struct perf_ftrace *ftrace) 868 { 869 if (ftrace->target.use_bpf) 870 return perf_ftrace__latency_cleanup_bpf(ftrace); 871 872 reset_tracing_files(ftrace); 873 return 0; 874 } 875 876 static int __cmd_latency(struct perf_ftrace *ftrace) 877 { 878 int trace_fd; 879 char buf[4096]; 880 char line[256]; 881 struct pollfd pollfd = { 882 .events = POLLIN, 883 }; 884 int buckets[NUM_BUCKET] = { }; 885 886 if (!(perf_cap__capable(CAP_PERFMON) || 887 perf_cap__capable(CAP_SYS_ADMIN))) { 888 pr_err("ftrace only works for %s!\n", 889 #ifdef HAVE_LIBCAP_SUPPORT 890 "users with the CAP_PERFMON or CAP_SYS_ADMIN capability" 891 #else 892 "root" 893 #endif 894 ); 895 return -1; 896 } 897 898 trace_fd = prepare_func_latency(ftrace); 899 if (trace_fd < 0) 900 goto out; 901 902 fcntl(trace_fd, F_SETFL, O_NONBLOCK); 903 pollfd.fd = trace_fd; 904 905 if (start_func_latency(ftrace) < 0) 906 goto out; 907 908 evlist__start_workload(ftrace->evlist); 909 910 line[0] = '\0'; 911 while (!done) { 912 if (poll(&pollfd, 1, -1) < 0) 913 break; 914 915 if (pollfd.revents & POLLIN) { 916 int n = read(trace_fd, buf, sizeof(buf) - 1); 917 if (n < 0) 918 break; 919 920 make_histogram(buckets, buf, n, line, ftrace->use_nsec); 921 } 922 } 923 924 stop_func_latency(ftrace); 925 926 if (workload_exec_errno) { 927 const char *emsg = str_error_r(workload_exec_errno, buf, sizeof(buf)); 928 pr_err("workload failed: %s\n", emsg); 929 goto out; 930 } 931 932 /* read remaining buffer contents */ 933 while (!ftrace->target.use_bpf) { 934 int n = read(trace_fd, buf, sizeof(buf) - 1); 935 if (n <= 0) 936 break; 937 make_histogram(buckets, buf, n, line, ftrace->use_nsec); 938 } 939 940 read_func_latency(ftrace, buckets); 941 942 display_histogram(buckets, ftrace->use_nsec); 943 944 out: 945 close(trace_fd); 946 cleanup_func_latency(ftrace); 947 948 return (done && !workload_exec_errno) ? 0 : -1; 949 } 950 951 static int perf_ftrace_config(const char *var, const char *value, void *cb) 952 { 953 struct perf_ftrace *ftrace = cb; 954 955 if (!strstarts(var, "ftrace.")) 956 return 0; 957 958 if (strcmp(var, "ftrace.tracer")) 959 return -1; 960 961 if (!strcmp(value, "function_graph") || 962 !strcmp(value, "function")) { 963 ftrace->tracer = value; 964 return 0; 965 } 966 967 pr_err("Please select \"function_graph\" (default) or \"function\"\n"); 968 return -1; 969 } 970 971 static void list_function_cb(char *str, void *arg) 972 { 973 struct strfilter *filter = (struct strfilter *)arg; 974 975 if (strfilter__compare(filter, str)) 976 printf("%s", str); 977 } 978 979 static int opt_list_avail_functions(const struct option *opt __maybe_unused, 980 const char *str, int unset) 981 { 982 struct strfilter *filter; 983 const char *err = NULL; 984 int ret; 985 986 if (unset || !str) 987 return -1; 988 989 filter = strfilter__new(str, &err); 990 if (!filter) 991 return err ? -EINVAL : -ENOMEM; 992 993 ret = strfilter__or(filter, str, &err); 994 if (ret == -EINVAL) { 995 pr_err("Filter parse error at %td.\n", err - str + 1); 996 pr_err("Source: \"%s\"\n", str); 997 pr_err(" %*c\n", (int)(err - str + 1), '^'); 998 strfilter__delete(filter); 999 return ret; 1000 } 1001 1002 ret = read_tracing_file_by_line("available_filter_functions", 1003 list_function_cb, filter); 1004 strfilter__delete(filter); 1005 if (ret < 0) 1006 return ret; 1007 1008 exit(0); 1009 } 1010 1011 static int parse_filter_func(const struct option *opt, const char *str, 1012 int unset __maybe_unused) 1013 { 1014 struct list_head *head = opt->value; 1015 struct filter_entry *entry; 1016 1017 entry = malloc(sizeof(*entry) + strlen(str) + 1); 1018 if (entry == NULL) 1019 return -ENOMEM; 1020 1021 strcpy(entry->name, str); 1022 list_add_tail(&entry->list, head); 1023 1024 return 0; 1025 } 1026 1027 static void delete_filter_func(struct list_head *head) 1028 { 1029 struct filter_entry *pos, *tmp; 1030 1031 list_for_each_entry_safe(pos, tmp, head, list) { 1032 list_del_init(&pos->list); 1033 free(pos); 1034 } 1035 } 1036 1037 static int parse_buffer_size(const struct option *opt, 1038 const char *str, int unset) 1039 { 1040 unsigned long *s = (unsigned long *)opt->value; 1041 static struct parse_tag tags_size[] = { 1042 { .tag = 'B', .mult = 1 }, 1043 { .tag = 'K', .mult = 1 << 10 }, 1044 { .tag = 'M', .mult = 1 << 20 }, 1045 { .tag = 'G', .mult = 1 << 30 }, 1046 { .tag = 0 }, 1047 }; 1048 unsigned long val; 1049 1050 if (unset) { 1051 *s = 0; 1052 return 0; 1053 } 1054 1055 val = parse_tag_value(str, tags_size); 1056 if (val != (unsigned long) -1) { 1057 if (val < 1024) { 1058 pr_err("buffer size too small, must larger than 1KB."); 1059 return -1; 1060 } 1061 *s = val; 1062 return 0; 1063 } 1064 1065 return -1; 1066 } 1067 1068 static int parse_func_tracer_opts(const struct option *opt, 1069 const char *str, int unset) 1070 { 1071 int ret; 1072 struct perf_ftrace *ftrace = (struct perf_ftrace *) opt->value; 1073 struct sublevel_option func_tracer_opts[] = { 1074 { .name = "call-graph", .value_ptr = &ftrace->func_stack_trace }, 1075 { .name = "irq-info", .value_ptr = &ftrace->func_irq_info }, 1076 { .name = NULL, } 1077 }; 1078 1079 if (unset) 1080 return 0; 1081 1082 ret = perf_parse_sublevel_options(str, func_tracer_opts); 1083 if (ret) 1084 return ret; 1085 1086 return 0; 1087 } 1088 1089 static int parse_graph_tracer_opts(const struct option *opt, 1090 const char *str, int unset) 1091 { 1092 int ret; 1093 struct perf_ftrace *ftrace = (struct perf_ftrace *) opt->value; 1094 struct sublevel_option graph_tracer_opts[] = { 1095 { .name = "nosleep-time", .value_ptr = &ftrace->graph_nosleep_time }, 1096 { .name = "noirqs", .value_ptr = &ftrace->graph_noirqs }, 1097 { .name = "verbose", .value_ptr = &ftrace->graph_verbose }, 1098 { .name = "thresh", .value_ptr = &ftrace->graph_thresh }, 1099 { .name = "depth", .value_ptr = &ftrace->graph_depth }, 1100 { .name = NULL, } 1101 }; 1102 1103 if (unset) 1104 return 0; 1105 1106 ret = perf_parse_sublevel_options(str, graph_tracer_opts); 1107 if (ret) 1108 return ret; 1109 1110 return 0; 1111 } 1112 1113 enum perf_ftrace_subcommand { 1114 PERF_FTRACE_NONE, 1115 PERF_FTRACE_TRACE, 1116 PERF_FTRACE_LATENCY, 1117 }; 1118 1119 int cmd_ftrace(int argc, const char **argv) 1120 { 1121 int ret; 1122 int (*cmd_func)(struct perf_ftrace *) = NULL; 1123 struct perf_ftrace ftrace = { 1124 .tracer = DEFAULT_TRACER, 1125 .target = { .uid = UINT_MAX, }, 1126 }; 1127 const struct option common_options[] = { 1128 OPT_STRING('p', "pid", &ftrace.target.pid, "pid", 1129 "Trace on existing process id"), 1130 /* TODO: Add short option -t after -t/--tracer can be removed. */ 1131 OPT_STRING(0, "tid", &ftrace.target.tid, "tid", 1132 "Trace on existing thread id (exclusive to --pid)"), 1133 OPT_INCR('v', "verbose", &verbose, 1134 "Be more verbose"), 1135 OPT_BOOLEAN('a', "all-cpus", &ftrace.target.system_wide, 1136 "System-wide collection from all CPUs"), 1137 OPT_STRING('C', "cpu", &ftrace.target.cpu_list, "cpu", 1138 "List of cpus to monitor"), 1139 OPT_END() 1140 }; 1141 const struct option ftrace_options[] = { 1142 OPT_STRING('t', "tracer", &ftrace.tracer, "tracer", 1143 "Tracer to use: function_graph(default) or function"), 1144 OPT_CALLBACK_DEFAULT('F', "funcs", NULL, "[FILTER]", 1145 "Show available functions to filter", 1146 opt_list_avail_functions, "*"), 1147 OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func", 1148 "Trace given functions using function tracer", 1149 parse_filter_func), 1150 OPT_CALLBACK('N', "notrace-funcs", &ftrace.notrace, "func", 1151 "Do not trace given functions", parse_filter_func), 1152 OPT_CALLBACK(0, "func-opts", &ftrace, "options", 1153 "Function tracer options, available options: call-graph,irq-info", 1154 parse_func_tracer_opts), 1155 OPT_CALLBACK('G', "graph-funcs", &ftrace.graph_funcs, "func", 1156 "Trace given functions using function_graph tracer", 1157 parse_filter_func), 1158 OPT_CALLBACK('g', "nograph-funcs", &ftrace.nograph_funcs, "func", 1159 "Set nograph filter on given functions", parse_filter_func), 1160 OPT_CALLBACK(0, "graph-opts", &ftrace, "options", 1161 "Graph tracer options, available options: nosleep-time,noirqs,verbose,thresh=<n>,depth=<n>", 1162 parse_graph_tracer_opts), 1163 OPT_CALLBACK('m', "buffer-size", &ftrace.percpu_buffer_size, "size", 1164 "Size of per cpu buffer, needs to use a B, K, M or G suffix.", parse_buffer_size), 1165 OPT_BOOLEAN(0, "inherit", &ftrace.inherit, 1166 "Trace children processes"), 1167 OPT_UINTEGER('D', "delay", &ftrace.initial_delay, 1168 "Number of milliseconds to wait before starting tracing after program start"), 1169 OPT_PARENT(common_options), 1170 }; 1171 const struct option latency_options[] = { 1172 OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func", 1173 "Show latency of given function", parse_filter_func), 1174 #ifdef HAVE_BPF_SKEL 1175 OPT_BOOLEAN('b', "use-bpf", &ftrace.target.use_bpf, 1176 "Use BPF to measure function latency"), 1177 #endif 1178 OPT_BOOLEAN('n', "--use-nsec", &ftrace.use_nsec, 1179 "Use nano-second histogram"), 1180 OPT_PARENT(common_options), 1181 }; 1182 const struct option *options = ftrace_options; 1183 1184 const char * const ftrace_usage[] = { 1185 "perf ftrace [<options>] [<command>]", 1186 "perf ftrace [<options>] -- [<command>] [<options>]", 1187 "perf ftrace {trace|latency} [<options>] [<command>]", 1188 "perf ftrace {trace|latency} [<options>] -- [<command>] [<options>]", 1189 NULL 1190 }; 1191 enum perf_ftrace_subcommand subcmd = PERF_FTRACE_NONE; 1192 1193 INIT_LIST_HEAD(&ftrace.filters); 1194 INIT_LIST_HEAD(&ftrace.notrace); 1195 INIT_LIST_HEAD(&ftrace.graph_funcs); 1196 INIT_LIST_HEAD(&ftrace.nograph_funcs); 1197 1198 signal(SIGINT, sig_handler); 1199 signal(SIGUSR1, sig_handler); 1200 signal(SIGCHLD, sig_handler); 1201 signal(SIGPIPE, sig_handler); 1202 1203 ret = perf_config(perf_ftrace_config, &ftrace); 1204 if (ret < 0) 1205 return -1; 1206 1207 if (argc > 1) { 1208 if (!strcmp(argv[1], "trace")) { 1209 subcmd = PERF_FTRACE_TRACE; 1210 } else if (!strcmp(argv[1], "latency")) { 1211 subcmd = PERF_FTRACE_LATENCY; 1212 options = latency_options; 1213 } 1214 1215 if (subcmd != PERF_FTRACE_NONE) { 1216 argc--; 1217 argv++; 1218 } 1219 } 1220 /* for backward compatibility */ 1221 if (subcmd == PERF_FTRACE_NONE) 1222 subcmd = PERF_FTRACE_TRACE; 1223 1224 argc = parse_options(argc, argv, options, ftrace_usage, 1225 PARSE_OPT_STOP_AT_NON_OPTION); 1226 if (argc < 0) { 1227 ret = -EINVAL; 1228 goto out_delete_filters; 1229 } 1230 1231 switch (subcmd) { 1232 case PERF_FTRACE_TRACE: 1233 if (!argc && target__none(&ftrace.target)) 1234 ftrace.target.system_wide = true; 1235 cmd_func = __cmd_ftrace; 1236 break; 1237 case PERF_FTRACE_LATENCY: 1238 if (list_empty(&ftrace.filters)) { 1239 pr_err("Should provide a function to measure\n"); 1240 parse_options_usage(ftrace_usage, options, "T", 1); 1241 ret = -EINVAL; 1242 goto out_delete_filters; 1243 } 1244 cmd_func = __cmd_latency; 1245 break; 1246 case PERF_FTRACE_NONE: 1247 default: 1248 pr_err("Invalid subcommand\n"); 1249 ret = -EINVAL; 1250 goto out_delete_filters; 1251 } 1252 1253 ret = target__validate(&ftrace.target); 1254 if (ret) { 1255 char errbuf[512]; 1256 1257 target__strerror(&ftrace.target, ret, errbuf, 512); 1258 pr_err("%s\n", errbuf); 1259 goto out_delete_filters; 1260 } 1261 1262 ftrace.evlist = evlist__new(); 1263 if (ftrace.evlist == NULL) { 1264 ret = -ENOMEM; 1265 goto out_delete_filters; 1266 } 1267 1268 ret = evlist__create_maps(ftrace.evlist, &ftrace.target); 1269 if (ret < 0) 1270 goto out_delete_evlist; 1271 1272 if (argc) { 1273 ret = evlist__prepare_workload(ftrace.evlist, &ftrace.target, 1274 argv, false, 1275 ftrace__workload_exec_failed_signal); 1276 if (ret < 0) 1277 goto out_delete_evlist; 1278 } 1279 1280 ret = cmd_func(&ftrace); 1281 1282 out_delete_evlist: 1283 evlist__delete(ftrace.evlist); 1284 1285 out_delete_filters: 1286 delete_filter_func(&ftrace.filters); 1287 delete_filter_func(&ftrace.notrace); 1288 delete_filter_func(&ftrace.graph_funcs); 1289 delete_filter_func(&ftrace.nograph_funcs); 1290 1291 return ret; 1292 } 1293