1 /* 2 * builtin-top.c 3 * 4 * Builtin top command: Display a continuously updated profile of 5 * any workload, CPU or specific PID. 6 * 7 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 8 * 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> 9 * 10 * Improvements and fixes by: 11 * 12 * Arjan van de Ven <arjan@linux.intel.com> 13 * Yanmin Zhang <yanmin.zhang@intel.com> 14 * Wu Fengguang <fengguang.wu@intel.com> 15 * Mike Galbraith <efault@gmx.de> 16 * Paul Mackerras <paulus@samba.org> 17 * 18 * Released under the GPL v2. (and only v2, not any later version) 19 */ 20 #include "builtin.h" 21 22 #include "perf.h" 23 24 #include "util/annotate.h" 25 #include "util/config.h" 26 #include "util/color.h" 27 #include "util/drv_configs.h" 28 #include "util/evlist.h" 29 #include "util/evsel.h" 30 #include "util/event.h" 31 #include "util/machine.h" 32 #include "util/session.h" 33 #include "util/symbol.h" 34 #include "util/thread.h" 35 #include "util/thread_map.h" 36 #include "util/top.h" 37 #include <linux/rbtree.h> 38 #include <subcmd/parse-options.h> 39 #include "util/parse-events.h" 40 #include "util/cpumap.h" 41 #include "util/xyarray.h" 42 #include "util/sort.h" 43 #include "util/term.h" 44 #include "util/intlist.h" 45 #include "util/parse-branch-options.h" 46 #include "arch/common.h" 47 48 #include "util/debug.h" 49 50 #include <assert.h> 51 #include <elf.h> 52 #include <fcntl.h> 53 54 #include <stdio.h> 55 #include <termios.h> 56 #include <unistd.h> 57 #include <inttypes.h> 58 59 #include <errno.h> 60 #include <time.h> 61 #include <sched.h> 62 #include <signal.h> 63 64 #include <sys/syscall.h> 65 #include <sys/ioctl.h> 66 #include <poll.h> 67 #include <sys/prctl.h> 68 #include <sys/wait.h> 69 #include <sys/uio.h> 70 #include <sys/utsname.h> 71 #include <sys/mman.h> 72 73 #include <linux/stringify.h> 74 #include <linux/time64.h> 75 #include <linux/types.h> 76 77 #include "sane_ctype.h" 78 79 static volatile int done; 80 81 #define HEADER_LINE_NR 5 82 83 static void perf_top__update_print_entries(struct perf_top *top) 84 { 85 top->print_entries = top->winsize.ws_row - HEADER_LINE_NR; 86 } 87 88 static void perf_top__sig_winch(int sig __maybe_unused, 89 siginfo_t *info __maybe_unused, void *arg) 90 { 91 struct perf_top *top = arg; 92 93 get_term_dimensions(&top->winsize); 94 perf_top__update_print_entries(top); 95 } 96 97 static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he) 98 { 99 struct symbol *sym; 100 struct annotation *notes; 101 struct map *map; 102 int err = -1; 103 104 if (!he || !he->ms.sym) 105 return -1; 106 107 sym = he->ms.sym; 108 map = he->ms.map; 109 110 /* 111 * We can't annotate with just /proc/kallsyms 112 */ 113 if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS && 114 !dso__is_kcore(map->dso)) { 115 pr_err("Can't annotate %s: No vmlinux file was found in the " 116 "path\n", sym->name); 117 sleep(1); 118 return -1; 119 } 120 121 notes = symbol__annotation(sym); 122 if (notes->src != NULL) { 123 pthread_mutex_lock(¬es->lock); 124 goto out_assign; 125 } 126 127 pthread_mutex_lock(¬es->lock); 128 129 if (symbol__alloc_hist(sym) < 0) { 130 pthread_mutex_unlock(¬es->lock); 131 pr_err("Not enough memory for annotating '%s' symbol!\n", 132 sym->name); 133 sleep(1); 134 return err; 135 } 136 137 err = symbol__disassemble(sym, map, NULL, 0, NULL); 138 if (err == 0) { 139 out_assign: 140 top->sym_filter_entry = he; 141 } else { 142 char msg[BUFSIZ]; 143 symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg)); 144 pr_err("Couldn't annotate %s: %s\n", sym->name, msg); 145 } 146 147 pthread_mutex_unlock(¬es->lock); 148 return err; 149 } 150 151 static void __zero_source_counters(struct hist_entry *he) 152 { 153 struct symbol *sym = he->ms.sym; 154 symbol__annotate_zero_histograms(sym); 155 } 156 157 static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip) 158 { 159 struct utsname uts; 160 int err = uname(&uts); 161 162 ui__warning("Out of bounds address found:\n\n" 163 "Addr: %" PRIx64 "\n" 164 "DSO: %s %c\n" 165 "Map: %" PRIx64 "-%" PRIx64 "\n" 166 "Symbol: %" PRIx64 "-%" PRIx64 " %c %s\n" 167 "Arch: %s\n" 168 "Kernel: %s\n" 169 "Tools: %s\n\n" 170 "Not all samples will be on the annotation output.\n\n" 171 "Please report to linux-kernel@vger.kernel.org\n", 172 ip, map->dso->long_name, dso__symtab_origin(map->dso), 173 map->start, map->end, sym->start, sym->end, 174 sym->binding == STB_GLOBAL ? 'g' : 175 sym->binding == STB_LOCAL ? 'l' : 'w', sym->name, 176 err ? "[unknown]" : uts.machine, 177 err ? "[unknown]" : uts.release, perf_version_string); 178 if (use_browser <= 0) 179 sleep(5); 180 181 map->erange_warned = true; 182 } 183 184 static void perf_top__record_precise_ip(struct perf_top *top, 185 struct hist_entry *he, 186 int counter, u64 ip) 187 { 188 struct annotation *notes; 189 struct symbol *sym = he->ms.sym; 190 int err = 0; 191 192 if (sym == NULL || (use_browser == 0 && 193 (top->sym_filter_entry == NULL || 194 top->sym_filter_entry->ms.sym != sym))) 195 return; 196 197 notes = symbol__annotation(sym); 198 199 if (pthread_mutex_trylock(¬es->lock)) 200 return; 201 202 err = hist_entry__inc_addr_samples(he, counter, ip); 203 204 pthread_mutex_unlock(¬es->lock); 205 206 if (unlikely(err)) { 207 /* 208 * This function is now called with he->hists->lock held. 209 * Release it before going to sleep. 210 */ 211 pthread_mutex_unlock(&he->hists->lock); 212 213 if (err == -ERANGE && !he->ms.map->erange_warned) 214 ui__warn_map_erange(he->ms.map, sym, ip); 215 else if (err == -ENOMEM) { 216 pr_err("Not enough memory for annotating '%s' symbol!\n", 217 sym->name); 218 sleep(1); 219 } 220 221 pthread_mutex_lock(&he->hists->lock); 222 } 223 } 224 225 static void perf_top__show_details(struct perf_top *top) 226 { 227 struct hist_entry *he = top->sym_filter_entry; 228 struct annotation *notes; 229 struct symbol *symbol; 230 int more; 231 232 if (!he) 233 return; 234 235 symbol = he->ms.sym; 236 notes = symbol__annotation(symbol); 237 238 pthread_mutex_lock(¬es->lock); 239 240 if (notes->src == NULL) 241 goto out_unlock; 242 243 printf("Showing %s for %s\n", perf_evsel__name(top->sym_evsel), symbol->name); 244 printf(" Events Pcnt (>=%d%%)\n", top->sym_pcnt_filter); 245 246 more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel, 247 0, top->sym_pcnt_filter, top->print_entries, 4); 248 249 if (top->evlist->enabled) { 250 if (top->zero) 251 symbol__annotate_zero_histogram(symbol, top->sym_evsel->idx); 252 else 253 symbol__annotate_decay_histogram(symbol, top->sym_evsel->idx); 254 } 255 if (more != 0) 256 printf("%d lines not displayed, maybe increase display entries [e]\n", more); 257 out_unlock: 258 pthread_mutex_unlock(¬es->lock); 259 } 260 261 static void perf_top__print_sym_table(struct perf_top *top) 262 { 263 char bf[160]; 264 int printed = 0; 265 const int win_width = top->winsize.ws_col - 1; 266 struct perf_evsel *evsel = top->sym_evsel; 267 struct hists *hists = evsel__hists(evsel); 268 269 puts(CONSOLE_CLEAR); 270 271 perf_top__header_snprintf(top, bf, sizeof(bf)); 272 printf("%s\n", bf); 273 274 perf_top__reset_sample_counters(top); 275 276 printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 277 278 if (hists->stats.nr_lost_warned != 279 hists->stats.nr_events[PERF_RECORD_LOST]) { 280 hists->stats.nr_lost_warned = 281 hists->stats.nr_events[PERF_RECORD_LOST]; 282 color_fprintf(stdout, PERF_COLOR_RED, 283 "WARNING: LOST %d chunks, Check IO/CPU overload", 284 hists->stats.nr_lost_warned); 285 ++printed; 286 } 287 288 if (top->sym_filter_entry) { 289 perf_top__show_details(top); 290 return; 291 } 292 293 if (top->evlist->enabled) { 294 if (top->zero) { 295 hists__delete_entries(hists); 296 } else { 297 hists__decay_entries(hists, top->hide_user_symbols, 298 top->hide_kernel_symbols); 299 } 300 } 301 302 hists__collapse_resort(hists, NULL); 303 perf_evsel__output_resort(evsel, NULL); 304 305 hists__output_recalc_col_len(hists, top->print_entries - printed); 306 putchar('\n'); 307 hists__fprintf(hists, false, top->print_entries - printed, win_width, 308 top->min_percent, stdout, symbol_conf.use_callchain); 309 } 310 311 static void prompt_integer(int *target, const char *msg) 312 { 313 char *buf = malloc(0), *p; 314 size_t dummy = 0; 315 int tmp; 316 317 fprintf(stdout, "\n%s: ", msg); 318 if (getline(&buf, &dummy, stdin) < 0) 319 return; 320 321 p = strchr(buf, '\n'); 322 if (p) 323 *p = 0; 324 325 p = buf; 326 while(*p) { 327 if (!isdigit(*p)) 328 goto out_free; 329 p++; 330 } 331 tmp = strtoul(buf, NULL, 10); 332 *target = tmp; 333 out_free: 334 free(buf); 335 } 336 337 static void prompt_percent(int *target, const char *msg) 338 { 339 int tmp = 0; 340 341 prompt_integer(&tmp, msg); 342 if (tmp >= 0 && tmp <= 100) 343 *target = tmp; 344 } 345 346 static void perf_top__prompt_symbol(struct perf_top *top, const char *msg) 347 { 348 char *buf = malloc(0), *p; 349 struct hist_entry *syme = top->sym_filter_entry, *n, *found = NULL; 350 struct hists *hists = evsel__hists(top->sym_evsel); 351 struct rb_node *next; 352 size_t dummy = 0; 353 354 /* zero counters of active symbol */ 355 if (syme) { 356 __zero_source_counters(syme); 357 top->sym_filter_entry = NULL; 358 } 359 360 fprintf(stdout, "\n%s: ", msg); 361 if (getline(&buf, &dummy, stdin) < 0) 362 goto out_free; 363 364 p = strchr(buf, '\n'); 365 if (p) 366 *p = 0; 367 368 next = rb_first(&hists->entries); 369 while (next) { 370 n = rb_entry(next, struct hist_entry, rb_node); 371 if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) { 372 found = n; 373 break; 374 } 375 next = rb_next(&n->rb_node); 376 } 377 378 if (!found) { 379 fprintf(stderr, "Sorry, %s is not active.\n", buf); 380 sleep(1); 381 } else 382 perf_top__parse_source(top, found); 383 384 out_free: 385 free(buf); 386 } 387 388 static void perf_top__print_mapped_keys(struct perf_top *top) 389 { 390 char *name = NULL; 391 392 if (top->sym_filter_entry) { 393 struct symbol *sym = top->sym_filter_entry->ms.sym; 394 name = sym->name; 395 } 396 397 fprintf(stdout, "\nMapped keys:\n"); 398 fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", top->delay_secs); 399 fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", top->print_entries); 400 401 if (top->evlist->nr_entries > 1) 402 fprintf(stdout, "\t[E] active event counter. \t(%s)\n", perf_evsel__name(top->sym_evsel)); 403 404 fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", top->count_filter); 405 406 fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", top->sym_pcnt_filter); 407 fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL"); 408 fprintf(stdout, "\t[S] stop annotation.\n"); 409 410 fprintf(stdout, 411 "\t[K] hide kernel_symbols symbols. \t(%s)\n", 412 top->hide_kernel_symbols ? "yes" : "no"); 413 fprintf(stdout, 414 "\t[U] hide user symbols. \t(%s)\n", 415 top->hide_user_symbols ? "yes" : "no"); 416 fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", top->zero ? 1 : 0); 417 fprintf(stdout, "\t[qQ] quit.\n"); 418 } 419 420 static int perf_top__key_mapped(struct perf_top *top, int c) 421 { 422 switch (c) { 423 case 'd': 424 case 'e': 425 case 'f': 426 case 'z': 427 case 'q': 428 case 'Q': 429 case 'K': 430 case 'U': 431 case 'F': 432 case 's': 433 case 'S': 434 return 1; 435 case 'E': 436 return top->evlist->nr_entries > 1 ? 1 : 0; 437 default: 438 break; 439 } 440 441 return 0; 442 } 443 444 static bool perf_top__handle_keypress(struct perf_top *top, int c) 445 { 446 bool ret = true; 447 448 if (!perf_top__key_mapped(top, c)) { 449 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 450 struct termios save; 451 452 perf_top__print_mapped_keys(top); 453 fprintf(stdout, "\nEnter selection, or unmapped key to continue: "); 454 fflush(stdout); 455 456 set_term_quiet_input(&save); 457 458 poll(&stdin_poll, 1, -1); 459 c = getc(stdin); 460 461 tcsetattr(0, TCSAFLUSH, &save); 462 if (!perf_top__key_mapped(top, c)) 463 return ret; 464 } 465 466 switch (c) { 467 case 'd': 468 prompt_integer(&top->delay_secs, "Enter display delay"); 469 if (top->delay_secs < 1) 470 top->delay_secs = 1; 471 break; 472 case 'e': 473 prompt_integer(&top->print_entries, "Enter display entries (lines)"); 474 if (top->print_entries == 0) { 475 struct sigaction act = { 476 .sa_sigaction = perf_top__sig_winch, 477 .sa_flags = SA_SIGINFO, 478 }; 479 perf_top__sig_winch(SIGWINCH, NULL, top); 480 sigaction(SIGWINCH, &act, NULL); 481 } else { 482 signal(SIGWINCH, SIG_DFL); 483 } 484 break; 485 case 'E': 486 if (top->evlist->nr_entries > 1) { 487 /* Select 0 as the default event: */ 488 int counter = 0; 489 490 fprintf(stderr, "\nAvailable events:"); 491 492 evlist__for_each_entry(top->evlist, top->sym_evsel) 493 fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel)); 494 495 prompt_integer(&counter, "Enter details event counter"); 496 497 if (counter >= top->evlist->nr_entries) { 498 top->sym_evsel = perf_evlist__first(top->evlist); 499 fprintf(stderr, "Sorry, no such event, using %s.\n", perf_evsel__name(top->sym_evsel)); 500 sleep(1); 501 break; 502 } 503 evlist__for_each_entry(top->evlist, top->sym_evsel) 504 if (top->sym_evsel->idx == counter) 505 break; 506 } else 507 top->sym_evsel = perf_evlist__first(top->evlist); 508 break; 509 case 'f': 510 prompt_integer(&top->count_filter, "Enter display event count filter"); 511 break; 512 case 'F': 513 prompt_percent(&top->sym_pcnt_filter, 514 "Enter details display event filter (percent)"); 515 break; 516 case 'K': 517 top->hide_kernel_symbols = !top->hide_kernel_symbols; 518 break; 519 case 'q': 520 case 'Q': 521 printf("exiting.\n"); 522 if (top->dump_symtab) 523 perf_session__fprintf_dsos(top->session, stderr); 524 ret = false; 525 break; 526 case 's': 527 perf_top__prompt_symbol(top, "Enter details symbol"); 528 break; 529 case 'S': 530 if (!top->sym_filter_entry) 531 break; 532 else { 533 struct hist_entry *syme = top->sym_filter_entry; 534 535 top->sym_filter_entry = NULL; 536 __zero_source_counters(syme); 537 } 538 break; 539 case 'U': 540 top->hide_user_symbols = !top->hide_user_symbols; 541 break; 542 case 'z': 543 top->zero = !top->zero; 544 break; 545 default: 546 break; 547 } 548 549 return ret; 550 } 551 552 static void perf_top__sort_new_samples(void *arg) 553 { 554 struct perf_top *t = arg; 555 struct perf_evsel *evsel = t->sym_evsel; 556 struct hists *hists; 557 558 perf_top__reset_sample_counters(t); 559 560 if (t->evlist->selected != NULL) 561 t->sym_evsel = t->evlist->selected; 562 563 hists = evsel__hists(evsel); 564 565 if (t->evlist->enabled) { 566 if (t->zero) { 567 hists__delete_entries(hists); 568 } else { 569 hists__decay_entries(hists, t->hide_user_symbols, 570 t->hide_kernel_symbols); 571 } 572 } 573 574 hists__collapse_resort(hists, NULL); 575 perf_evsel__output_resort(evsel, NULL); 576 } 577 578 static void *display_thread_tui(void *arg) 579 { 580 struct perf_evsel *pos; 581 struct perf_top *top = arg; 582 const char *help = "For a higher level overview, try: perf top --sort comm,dso"; 583 struct hist_browser_timer hbt = { 584 .timer = perf_top__sort_new_samples, 585 .arg = top, 586 .refresh = top->delay_secs, 587 }; 588 589 perf_top__sort_new_samples(top); 590 591 /* 592 * Initialize the uid_filter_str, in the future the TUI will allow 593 * Zooming in/out UIDs. For now juse use whatever the user passed 594 * via --uid. 595 */ 596 evlist__for_each_entry(top->evlist, pos) { 597 struct hists *hists = evsel__hists(pos); 598 hists->uid_filter_str = top->record_opts.target.uid_str; 599 } 600 601 perf_evlist__tui_browse_hists(top->evlist, help, &hbt, 602 top->min_percent, 603 &top->session->header.env); 604 605 done = 1; 606 return NULL; 607 } 608 609 static void display_sig(int sig __maybe_unused) 610 { 611 done = 1; 612 } 613 614 static void display_setup_sig(void) 615 { 616 signal(SIGSEGV, sighandler_dump_stack); 617 signal(SIGFPE, sighandler_dump_stack); 618 signal(SIGINT, display_sig); 619 signal(SIGQUIT, display_sig); 620 signal(SIGTERM, display_sig); 621 } 622 623 static void *display_thread(void *arg) 624 { 625 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 626 struct termios save; 627 struct perf_top *top = arg; 628 int delay_msecs, c; 629 630 display_setup_sig(); 631 pthread__unblock_sigwinch(); 632 repeat: 633 delay_msecs = top->delay_secs * MSEC_PER_SEC; 634 set_term_quiet_input(&save); 635 /* trash return*/ 636 getc(stdin); 637 638 while (!done) { 639 perf_top__print_sym_table(top); 640 /* 641 * Either timeout expired or we got an EINTR due to SIGWINCH, 642 * refresh screen in both cases. 643 */ 644 switch (poll(&stdin_poll, 1, delay_msecs)) { 645 case 0: 646 continue; 647 case -1: 648 if (errno == EINTR) 649 continue; 650 __fallthrough; 651 default: 652 c = getc(stdin); 653 tcsetattr(0, TCSAFLUSH, &save); 654 655 if (perf_top__handle_keypress(top, c)) 656 goto repeat; 657 done = 1; 658 } 659 } 660 661 tcsetattr(0, TCSAFLUSH, &save); 662 return NULL; 663 } 664 665 static int hist_iter__top_callback(struct hist_entry_iter *iter, 666 struct addr_location *al, bool single, 667 void *arg) 668 { 669 struct perf_top *top = arg; 670 struct hist_entry *he = iter->he; 671 struct perf_evsel *evsel = iter->evsel; 672 673 if (perf_hpp_list.sym && single) 674 perf_top__record_precise_ip(top, he, evsel->idx, al->addr); 675 676 hist__account_cycles(iter->sample->branch_stack, al, iter->sample, 677 !(top->record_opts.branch_stack & PERF_SAMPLE_BRANCH_ANY)); 678 return 0; 679 } 680 681 static void perf_event__process_sample(struct perf_tool *tool, 682 const union perf_event *event, 683 struct perf_evsel *evsel, 684 struct perf_sample *sample, 685 struct machine *machine) 686 { 687 struct perf_top *top = container_of(tool, struct perf_top, tool); 688 struct addr_location al; 689 int err; 690 691 if (!machine && perf_guest) { 692 static struct intlist *seen; 693 694 if (!seen) 695 seen = intlist__new(NULL); 696 697 if (!intlist__has_entry(seen, sample->pid)) { 698 pr_err("Can't find guest [%d]'s kernel information\n", 699 sample->pid); 700 intlist__add(seen, sample->pid); 701 } 702 return; 703 } 704 705 if (!machine) { 706 pr_err("%u unprocessable samples recorded.\r", 707 top->session->evlist->stats.nr_unprocessable_samples++); 708 return; 709 } 710 711 if (event->header.misc & PERF_RECORD_MISC_EXACT_IP) 712 top->exact_samples++; 713 714 if (machine__resolve(machine, &al, sample) < 0) 715 return; 716 717 if (!machine->kptr_restrict_warned && 718 symbol_conf.kptr_restrict && 719 al.cpumode == PERF_RECORD_MISC_KERNEL) { 720 ui__warning( 721 "Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n" 722 "Check /proc/sys/kernel/kptr_restrict.\n\n" 723 "Kernel%s samples will not be resolved.\n", 724 al.map && !RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION]) ? 725 " modules" : ""); 726 if (use_browser <= 0) 727 sleep(5); 728 machine->kptr_restrict_warned = true; 729 } 730 731 if (al.sym == NULL) { 732 const char *msg = "Kernel samples will not be resolved.\n"; 733 /* 734 * As we do lazy loading of symtabs we only will know if the 735 * specified vmlinux file is invalid when we actually have a 736 * hit in kernel space and then try to load it. So if we get 737 * here and there are _no_ symbols in the DSO backing the 738 * kernel map, bail out. 739 * 740 * We may never get here, for instance, if we use -K/ 741 * --hide-kernel-symbols, even if the user specifies an 742 * invalid --vmlinux ;-) 743 */ 744 if (!machine->kptr_restrict_warned && !top->vmlinux_warned && 745 al.map == machine->vmlinux_maps[MAP__FUNCTION] && 746 RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 747 if (symbol_conf.vmlinux_name) { 748 char serr[256]; 749 dso__strerror_load(al.map->dso, serr, sizeof(serr)); 750 ui__warning("The %s file can't be used: %s\n%s", 751 symbol_conf.vmlinux_name, serr, msg); 752 } else { 753 ui__warning("A vmlinux file was not found.\n%s", 754 msg); 755 } 756 757 if (use_browser <= 0) 758 sleep(5); 759 top->vmlinux_warned = true; 760 } 761 } 762 763 if (al.sym == NULL || !al.sym->idle) { 764 struct hists *hists = evsel__hists(evsel); 765 struct hist_entry_iter iter = { 766 .evsel = evsel, 767 .sample = sample, 768 .add_entry_cb = hist_iter__top_callback, 769 }; 770 771 if (symbol_conf.cumulate_callchain) 772 iter.ops = &hist_iter_cumulative; 773 else 774 iter.ops = &hist_iter_normal; 775 776 pthread_mutex_lock(&hists->lock); 777 778 err = hist_entry_iter__add(&iter, &al, top->max_stack, top); 779 if (err < 0) 780 pr_err("Problem incrementing symbol period, skipping event\n"); 781 782 pthread_mutex_unlock(&hists->lock); 783 } 784 785 addr_location__put(&al); 786 } 787 788 static void perf_top__mmap_read_idx(struct perf_top *top, int idx) 789 { 790 struct perf_sample sample; 791 struct perf_evsel *evsel; 792 struct perf_session *session = top->session; 793 union perf_event *event; 794 struct machine *machine; 795 int ret; 796 797 while ((event = perf_evlist__mmap_read(top->evlist, idx)) != NULL) { 798 ret = perf_evlist__parse_sample(top->evlist, event, &sample); 799 if (ret) { 800 pr_err("Can't parse sample, err = %d\n", ret); 801 goto next_event; 802 } 803 804 evsel = perf_evlist__id2evsel(session->evlist, sample.id); 805 assert(evsel != NULL); 806 807 if (event->header.type == PERF_RECORD_SAMPLE) 808 ++top->samples; 809 810 switch (sample.cpumode) { 811 case PERF_RECORD_MISC_USER: 812 ++top->us_samples; 813 if (top->hide_user_symbols) 814 goto next_event; 815 machine = &session->machines.host; 816 break; 817 case PERF_RECORD_MISC_KERNEL: 818 ++top->kernel_samples; 819 if (top->hide_kernel_symbols) 820 goto next_event; 821 machine = &session->machines.host; 822 break; 823 case PERF_RECORD_MISC_GUEST_KERNEL: 824 ++top->guest_kernel_samples; 825 machine = perf_session__find_machine(session, 826 sample.pid); 827 break; 828 case PERF_RECORD_MISC_GUEST_USER: 829 ++top->guest_us_samples; 830 /* 831 * TODO: we don't process guest user from host side 832 * except simple counting. 833 */ 834 goto next_event; 835 default: 836 if (event->header.type == PERF_RECORD_SAMPLE) 837 goto next_event; 838 machine = &session->machines.host; 839 break; 840 } 841 842 843 if (event->header.type == PERF_RECORD_SAMPLE) { 844 perf_event__process_sample(&top->tool, event, evsel, 845 &sample, machine); 846 } else if (event->header.type < PERF_RECORD_MAX) { 847 hists__inc_nr_events(evsel__hists(evsel), event->header.type); 848 machine__process_event(machine, event, &sample); 849 } else 850 ++session->evlist->stats.nr_unknown_events; 851 next_event: 852 perf_evlist__mmap_consume(top->evlist, idx); 853 } 854 } 855 856 static void perf_top__mmap_read(struct perf_top *top) 857 { 858 int i; 859 860 for (i = 0; i < top->evlist->nr_mmaps; i++) 861 perf_top__mmap_read_idx(top, i); 862 } 863 864 static int perf_top__start_counters(struct perf_top *top) 865 { 866 char msg[BUFSIZ]; 867 struct perf_evsel *counter; 868 struct perf_evlist *evlist = top->evlist; 869 struct record_opts *opts = &top->record_opts; 870 871 perf_evlist__config(evlist, opts, &callchain_param); 872 873 evlist__for_each_entry(evlist, counter) { 874 try_again: 875 if (perf_evsel__open(counter, top->evlist->cpus, 876 top->evlist->threads) < 0) { 877 if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) { 878 if (verbose > 0) 879 ui__warning("%s\n", msg); 880 goto try_again; 881 } 882 883 perf_evsel__open_strerror(counter, &opts->target, 884 errno, msg, sizeof(msg)); 885 ui__error("%s\n", msg); 886 goto out_err; 887 } 888 } 889 890 if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) { 891 ui__error("Failed to mmap with %d (%s)\n", 892 errno, str_error_r(errno, msg, sizeof(msg))); 893 goto out_err; 894 } 895 896 return 0; 897 898 out_err: 899 return -1; 900 } 901 902 static int callchain_param__setup_sample_type(struct callchain_param *callchain) 903 { 904 if (!perf_hpp_list.sym) { 905 if (callchain->enabled) { 906 ui__error("Selected -g but \"sym\" not present in --sort/-s."); 907 return -EINVAL; 908 } 909 } else if (callchain->mode != CHAIN_NONE) { 910 if (callchain_register_param(callchain) < 0) { 911 ui__error("Can't register callchain params.\n"); 912 return -EINVAL; 913 } 914 } 915 916 return 0; 917 } 918 919 static int __cmd_top(struct perf_top *top) 920 { 921 char msg[512]; 922 struct perf_evsel *pos; 923 struct perf_evsel_config_term *err_term; 924 struct perf_evlist *evlist = top->evlist; 925 struct record_opts *opts = &top->record_opts; 926 pthread_t thread; 927 int ret; 928 929 top->session = perf_session__new(NULL, false, NULL); 930 if (top->session == NULL) 931 return -1; 932 933 if (!objdump_path) { 934 ret = perf_env__lookup_objdump(&top->session->header.env); 935 if (ret) 936 goto out_delete; 937 } 938 939 ret = callchain_param__setup_sample_type(&callchain_param); 940 if (ret) 941 goto out_delete; 942 943 if (perf_session__register_idle_thread(top->session) < 0) 944 goto out_delete; 945 946 machine__synthesize_threads(&top->session->machines.host, &opts->target, 947 top->evlist->threads, false, opts->proc_map_timeout); 948 949 if (perf_hpp_list.socket) { 950 ret = perf_env__read_cpu_topology_map(&perf_env); 951 if (ret < 0) 952 goto out_err_cpu_topo; 953 } 954 955 ret = perf_top__start_counters(top); 956 if (ret) 957 goto out_delete; 958 959 ret = perf_evlist__apply_drv_configs(evlist, &pos, &err_term); 960 if (ret) { 961 pr_err("failed to set config \"%s\" on event %s with %d (%s)\n", 962 err_term->val.drv_cfg, perf_evsel__name(pos), errno, 963 str_error_r(errno, msg, sizeof(msg))); 964 goto out_delete; 965 } 966 967 top->session->evlist = top->evlist; 968 perf_session__set_id_hdr_size(top->session); 969 970 /* 971 * When perf is starting the traced process, all the events (apart from 972 * group members) have enable_on_exec=1 set, so don't spoil it by 973 * prematurely enabling them. 974 * 975 * XXX 'top' still doesn't start workloads like record, trace, but should, 976 * so leave the check here. 977 */ 978 if (!target__none(&opts->target)) 979 perf_evlist__enable(top->evlist); 980 981 /* Wait for a minimal set of events before starting the snapshot */ 982 perf_evlist__poll(top->evlist, 100); 983 984 perf_top__mmap_read(top); 985 986 ret = -1; 987 if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui : 988 display_thread), top)) { 989 ui__error("Could not create display thread.\n"); 990 goto out_delete; 991 } 992 993 if (top->realtime_prio) { 994 struct sched_param param; 995 996 param.sched_priority = top->realtime_prio; 997 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 998 ui__error("Could not set realtime priority.\n"); 999 goto out_join; 1000 } 1001 } 1002 1003 while (!done) { 1004 u64 hits = top->samples; 1005 1006 perf_top__mmap_read(top); 1007 1008 if (hits == top->samples) 1009 ret = perf_evlist__poll(top->evlist, 100); 1010 } 1011 1012 ret = 0; 1013 out_join: 1014 pthread_join(thread, NULL); 1015 out_delete: 1016 perf_session__delete(top->session); 1017 top->session = NULL; 1018 1019 return ret; 1020 1021 out_err_cpu_topo: { 1022 char errbuf[BUFSIZ]; 1023 const char *err = str_error_r(-ret, errbuf, sizeof(errbuf)); 1024 1025 ui__error("Could not read the CPU topology map: %s\n", err); 1026 goto out_delete; 1027 } 1028 } 1029 1030 static int 1031 callchain_opt(const struct option *opt, const char *arg, int unset) 1032 { 1033 symbol_conf.use_callchain = true; 1034 return record_callchain_opt(opt, arg, unset); 1035 } 1036 1037 static int 1038 parse_callchain_opt(const struct option *opt, const char *arg, int unset) 1039 { 1040 struct callchain_param *callchain = opt->value; 1041 1042 callchain->enabled = !unset; 1043 callchain->record_mode = CALLCHAIN_FP; 1044 1045 /* 1046 * --no-call-graph 1047 */ 1048 if (unset) { 1049 symbol_conf.use_callchain = false; 1050 callchain->record_mode = CALLCHAIN_NONE; 1051 return 0; 1052 } 1053 1054 return parse_callchain_top_opt(arg); 1055 } 1056 1057 static int perf_top_config(const char *var, const char *value, void *cb __maybe_unused) 1058 { 1059 if (!strcmp(var, "top.call-graph")) 1060 var = "call-graph.record-mode"; /* fall-through */ 1061 if (!strcmp(var, "top.children")) { 1062 symbol_conf.cumulate_callchain = perf_config_bool(var, value); 1063 return 0; 1064 } 1065 1066 return 0; 1067 } 1068 1069 static int 1070 parse_percent_limit(const struct option *opt, const char *arg, 1071 int unset __maybe_unused) 1072 { 1073 struct perf_top *top = opt->value; 1074 1075 top->min_percent = strtof(arg, NULL); 1076 return 0; 1077 } 1078 1079 const char top_callchain_help[] = CALLCHAIN_RECORD_HELP CALLCHAIN_REPORT_HELP 1080 "\n\t\t\t\tDefault: fp,graph,0.5,caller,function"; 1081 1082 int cmd_top(int argc, const char **argv) 1083 { 1084 char errbuf[BUFSIZ]; 1085 struct perf_top top = { 1086 .count_filter = 5, 1087 .delay_secs = 2, 1088 .record_opts = { 1089 .mmap_pages = UINT_MAX, 1090 .user_freq = UINT_MAX, 1091 .user_interval = ULLONG_MAX, 1092 .freq = 4000, /* 4 KHz */ 1093 .target = { 1094 .uses_mmap = true, 1095 }, 1096 .proc_map_timeout = 500, 1097 }, 1098 .max_stack = sysctl_perf_event_max_stack, 1099 .sym_pcnt_filter = 5, 1100 }; 1101 struct record_opts *opts = &top.record_opts; 1102 struct target *target = &opts->target; 1103 const struct option options[] = { 1104 OPT_CALLBACK('e', "event", &top.evlist, "event", 1105 "event selector. use 'perf list' to list available events", 1106 parse_events_option), 1107 OPT_U64('c', "count", &opts->user_interval, "event period to sample"), 1108 OPT_STRING('p', "pid", &target->pid, "pid", 1109 "profile events on existing process id"), 1110 OPT_STRING('t', "tid", &target->tid, "tid", 1111 "profile events on existing thread id"), 1112 OPT_BOOLEAN('a', "all-cpus", &target->system_wide, 1113 "system-wide collection from all CPUs"), 1114 OPT_STRING('C', "cpu", &target->cpu_list, "cpu", 1115 "list of cpus to monitor"), 1116 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 1117 "file", "vmlinux pathname"), 1118 OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux, 1119 "don't load vmlinux even if found"), 1120 OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols, 1121 "hide kernel symbols"), 1122 OPT_CALLBACK('m', "mmap-pages", &opts->mmap_pages, "pages", 1123 "number of mmap data pages", 1124 perf_evlist__parse_mmap_pages), 1125 OPT_INTEGER('r', "realtime", &top.realtime_prio, 1126 "collect data with this RT SCHED_FIFO priority"), 1127 OPT_INTEGER('d', "delay", &top.delay_secs, 1128 "number of seconds to delay between refreshes"), 1129 OPT_BOOLEAN('D', "dump-symtab", &top.dump_symtab, 1130 "dump the symbol table used for profiling"), 1131 OPT_INTEGER('f', "count-filter", &top.count_filter, 1132 "only display functions with more events than this"), 1133 OPT_BOOLEAN(0, "group", &opts->group, 1134 "put the counters into a counter group"), 1135 OPT_BOOLEAN('i', "no-inherit", &opts->no_inherit, 1136 "child tasks do not inherit counters"), 1137 OPT_STRING(0, "sym-annotate", &top.sym_filter, "symbol name", 1138 "symbol to annotate"), 1139 OPT_BOOLEAN('z', "zero", &top.zero, "zero history across updates"), 1140 OPT_UINTEGER('F', "freq", &opts->user_freq, "profile at this frequency"), 1141 OPT_INTEGER('E', "entries", &top.print_entries, 1142 "display this many functions"), 1143 OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols, 1144 "hide user symbols"), 1145 OPT_BOOLEAN(0, "tui", &top.use_tui, "Use the TUI interface"), 1146 OPT_BOOLEAN(0, "stdio", &top.use_stdio, "Use the stdio interface"), 1147 OPT_INCR('v', "verbose", &verbose, 1148 "be more verbose (show counter open errors, etc)"), 1149 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 1150 "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..." 1151 " Please refer the man page for the complete list."), 1152 OPT_STRING(0, "fields", &field_order, "key[,keys...]", 1153 "output field(s): overhead, period, sample plus all of sort keys"), 1154 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples, 1155 "Show a column with the number of samples"), 1156 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param, 1157 NULL, "enables call-graph recording and display", 1158 &callchain_opt), 1159 OPT_CALLBACK(0, "call-graph", &callchain_param, 1160 "record_mode[,record_size],print_type,threshold[,print_limit],order,sort_key[,branch]", 1161 top_callchain_help, &parse_callchain_opt), 1162 OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain, 1163 "Accumulate callchains of children and show total overhead as well"), 1164 OPT_INTEGER(0, "max-stack", &top.max_stack, 1165 "Set the maximum stack depth when parsing the callchain. " 1166 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)), 1167 OPT_CALLBACK(0, "ignore-callees", NULL, "regex", 1168 "ignore callees of these functions in call graphs", 1169 report_parse_ignore_callees_opt), 1170 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period, 1171 "Show a column with the sum of periods"), 1172 OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 1173 "only consider symbols in these dsos"), 1174 OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 1175 "only consider symbols in these comms"), 1176 OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 1177 "only consider these symbols"), 1178 OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src, 1179 "Interleave source code with assembly code (default)"), 1180 OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw, 1181 "Display raw encoding of assembly instructions (default)"), 1182 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel, 1183 "Enable kernel symbol demangling"), 1184 OPT_STRING(0, "objdump", &objdump_path, "path", 1185 "objdump binary to use for disassembly and annotations"), 1186 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style", 1187 "Specify disassembler style (e.g. -M intel for intel syntax)"), 1188 OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"), 1189 OPT_CALLBACK(0, "percent-limit", &top, "percent", 1190 "Don't show entries under that percent", parse_percent_limit), 1191 OPT_CALLBACK(0, "percentage", NULL, "relative|absolute", 1192 "How to display percentage of filtered entries", parse_filter_percentage), 1193 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str, 1194 "width[,width...]", 1195 "don't try to adjust column width, use these fixed values"), 1196 OPT_UINTEGER(0, "proc-map-timeout", &opts->proc_map_timeout, 1197 "per thread proc mmap processing timeout in ms"), 1198 OPT_CALLBACK_NOOPT('b', "branch-any", &opts->branch_stack, 1199 "branch any", "sample any taken branches", 1200 parse_branch_stack), 1201 OPT_CALLBACK('j', "branch-filter", &opts->branch_stack, 1202 "branch filter mask", "branch stack filter modes", 1203 parse_branch_stack), 1204 OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace, 1205 "Show raw trace event output (do not use print fmt or plugins)"), 1206 OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy, 1207 "Show entries in a hierarchy"), 1208 OPT_END() 1209 }; 1210 const char * const top_usage[] = { 1211 "perf top [<options>]", 1212 NULL 1213 }; 1214 int status = hists__init(); 1215 1216 if (status < 0) 1217 return status; 1218 1219 top.evlist = perf_evlist__new(); 1220 if (top.evlist == NULL) 1221 return -ENOMEM; 1222 1223 status = perf_config(perf_top_config, &top); 1224 if (status) 1225 return status; 1226 1227 argc = parse_options(argc, argv, options, top_usage, 0); 1228 if (argc) 1229 usage_with_options(top_usage, options); 1230 1231 if (!top.evlist->nr_entries && 1232 perf_evlist__add_default(top.evlist) < 0) { 1233 pr_err("Not enough memory for event selector list\n"); 1234 goto out_delete_evlist; 1235 } 1236 1237 if (symbol_conf.report_hierarchy) { 1238 /* disable incompatible options */ 1239 symbol_conf.event_group = false; 1240 symbol_conf.cumulate_callchain = false; 1241 1242 if (field_order) { 1243 pr_err("Error: --hierarchy and --fields options cannot be used together\n"); 1244 parse_options_usage(top_usage, options, "fields", 0); 1245 parse_options_usage(NULL, options, "hierarchy", 0); 1246 goto out_delete_evlist; 1247 } 1248 } 1249 1250 sort__mode = SORT_MODE__TOP; 1251 /* display thread wants entries to be collapsed in a different tree */ 1252 perf_hpp_list.need_collapse = 1; 1253 1254 if (top.use_stdio) 1255 use_browser = 0; 1256 else if (top.use_tui) 1257 use_browser = 1; 1258 1259 setup_browser(false); 1260 1261 if (setup_sorting(top.evlist) < 0) { 1262 if (sort_order) 1263 parse_options_usage(top_usage, options, "s", 1); 1264 if (field_order) 1265 parse_options_usage(sort_order ? NULL : top_usage, 1266 options, "fields", 0); 1267 goto out_delete_evlist; 1268 } 1269 1270 status = target__validate(target); 1271 if (status) { 1272 target__strerror(target, status, errbuf, BUFSIZ); 1273 ui__warning("%s\n", errbuf); 1274 } 1275 1276 status = target__parse_uid(target); 1277 if (status) { 1278 int saved_errno = errno; 1279 1280 target__strerror(target, status, errbuf, BUFSIZ); 1281 ui__error("%s\n", errbuf); 1282 1283 status = -saved_errno; 1284 goto out_delete_evlist; 1285 } 1286 1287 if (target__none(target)) 1288 target->system_wide = true; 1289 1290 if (perf_evlist__create_maps(top.evlist, target) < 0) { 1291 ui__error("Couldn't create thread/CPU maps: %s\n", 1292 errno == ENOENT ? "No such process" : str_error_r(errno, errbuf, sizeof(errbuf))); 1293 goto out_delete_evlist; 1294 } 1295 1296 symbol_conf.nr_events = top.evlist->nr_entries; 1297 1298 if (top.delay_secs < 1) 1299 top.delay_secs = 1; 1300 1301 if (record_opts__config(opts)) { 1302 status = -EINVAL; 1303 goto out_delete_evlist; 1304 } 1305 1306 top.sym_evsel = perf_evlist__first(top.evlist); 1307 1308 if (!callchain_param.enabled) { 1309 symbol_conf.cumulate_callchain = false; 1310 perf_hpp__cancel_cumulate(); 1311 } 1312 1313 if (symbol_conf.cumulate_callchain && !callchain_param.order_set) 1314 callchain_param.order = ORDER_CALLER; 1315 1316 status = symbol__annotation_init(); 1317 if (status < 0) 1318 goto out_delete_evlist; 1319 1320 symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 1321 if (symbol__init(NULL) < 0) 1322 return -1; 1323 1324 sort__setup_elide(stdout); 1325 1326 get_term_dimensions(&top.winsize); 1327 if (top.print_entries == 0) { 1328 struct sigaction act = { 1329 .sa_sigaction = perf_top__sig_winch, 1330 .sa_flags = SA_SIGINFO, 1331 }; 1332 perf_top__update_print_entries(&top); 1333 sigaction(SIGWINCH, &act, NULL); 1334 } 1335 1336 status = __cmd_top(&top); 1337 1338 out_delete_evlist: 1339 perf_evlist__delete(top.evlist); 1340 1341 return status; 1342 } 1343