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/cache.h" 26 #include "util/color.h" 27 #include "util/evlist.h" 28 #include "util/evsel.h" 29 #include "util/session.h" 30 #include "util/symbol.h" 31 #include "util/thread.h" 32 #include "util/thread_map.h" 33 #include "util/top.h" 34 #include "util/util.h" 35 #include <linux/rbtree.h> 36 #include "util/parse-options.h" 37 #include "util/parse-events.h" 38 #include "util/cpumap.h" 39 #include "util/xyarray.h" 40 #include "util/sort.h" 41 42 #include "util/debug.h" 43 44 #include <assert.h> 45 #include <fcntl.h> 46 47 #include <stdio.h> 48 #include <termios.h> 49 #include <unistd.h> 50 #include <inttypes.h> 51 52 #include <errno.h> 53 #include <time.h> 54 #include <sched.h> 55 56 #include <sys/syscall.h> 57 #include <sys/ioctl.h> 58 #include <sys/poll.h> 59 #include <sys/prctl.h> 60 #include <sys/wait.h> 61 #include <sys/uio.h> 62 #include <sys/mman.h> 63 64 #include <linux/unistd.h> 65 #include <linux/types.h> 66 67 static struct perf_top top = { 68 .count_filter = 5, 69 .delay_secs = 2, 70 .target_pid = -1, 71 .target_tid = -1, 72 .freq = 1000, /* 1 KHz */ 73 }; 74 75 static bool system_wide = false; 76 77 static bool use_tui, use_stdio; 78 79 static bool sort_has_symbols; 80 81 static bool dont_use_callchains; 82 static char callchain_default_opt[] = "fractal,0.5,callee"; 83 84 85 static int default_interval = 0; 86 87 static bool kptr_restrict_warned; 88 static bool vmlinux_warned; 89 static bool inherit = false; 90 static int realtime_prio = 0; 91 static bool group = false; 92 static unsigned int mmap_pages = 128; 93 94 static bool dump_symtab = false; 95 96 static struct winsize winsize; 97 98 static const char *sym_filter = NULL; 99 static int sym_pcnt_filter = 5; 100 101 /* 102 * Source functions 103 */ 104 105 void get_term_dimensions(struct winsize *ws) 106 { 107 char *s = getenv("LINES"); 108 109 if (s != NULL) { 110 ws->ws_row = atoi(s); 111 s = getenv("COLUMNS"); 112 if (s != NULL) { 113 ws->ws_col = atoi(s); 114 if (ws->ws_row && ws->ws_col) 115 return; 116 } 117 } 118 #ifdef TIOCGWINSZ 119 if (ioctl(1, TIOCGWINSZ, ws) == 0 && 120 ws->ws_row && ws->ws_col) 121 return; 122 #endif 123 ws->ws_row = 25; 124 ws->ws_col = 80; 125 } 126 127 static void update_print_entries(struct winsize *ws) 128 { 129 top.print_entries = ws->ws_row; 130 131 if (top.print_entries > 9) 132 top.print_entries -= 9; 133 } 134 135 static void sig_winch_handler(int sig __used) 136 { 137 get_term_dimensions(&winsize); 138 update_print_entries(&winsize); 139 } 140 141 static int parse_source(struct hist_entry *he) 142 { 143 struct symbol *sym; 144 struct annotation *notes; 145 struct map *map; 146 int err = -1; 147 148 if (!he || !he->ms.sym) 149 return -1; 150 151 sym = he->ms.sym; 152 map = he->ms.map; 153 154 /* 155 * We can't annotate with just /proc/kallsyms 156 */ 157 if (map->dso->symtab_type == SYMTAB__KALLSYMS) { 158 pr_err("Can't annotate %s: No vmlinux file was found in the " 159 "path\n", sym->name); 160 sleep(1); 161 return -1; 162 } 163 164 notes = symbol__annotation(sym); 165 if (notes->src != NULL) { 166 pthread_mutex_lock(¬es->lock); 167 goto out_assign; 168 } 169 170 pthread_mutex_lock(¬es->lock); 171 172 if (symbol__alloc_hist(sym, top.evlist->nr_entries) < 0) { 173 pthread_mutex_unlock(¬es->lock); 174 pr_err("Not enough memory for annotating '%s' symbol!\n", 175 sym->name); 176 sleep(1); 177 return err; 178 } 179 180 err = symbol__annotate(sym, map, 0); 181 if (err == 0) { 182 out_assign: 183 top.sym_filter_entry = he; 184 } 185 186 pthread_mutex_unlock(¬es->lock); 187 return err; 188 } 189 190 static void __zero_source_counters(struct hist_entry *he) 191 { 192 struct symbol *sym = he->ms.sym; 193 symbol__annotate_zero_histograms(sym); 194 } 195 196 static void record_precise_ip(struct hist_entry *he, int counter, u64 ip) 197 { 198 struct annotation *notes; 199 struct symbol *sym; 200 201 if (he == NULL || he->ms.sym == NULL || 202 (he != top.sym_filter_entry && use_browser != 1)) 203 return; 204 205 sym = he->ms.sym; 206 notes = symbol__annotation(sym); 207 208 if (pthread_mutex_trylock(¬es->lock)) 209 return; 210 211 if (notes->src == NULL && 212 symbol__alloc_hist(sym, top.evlist->nr_entries) < 0) { 213 pthread_mutex_unlock(¬es->lock); 214 pr_err("Not enough memory for annotating '%s' symbol!\n", 215 sym->name); 216 sleep(1); 217 return; 218 } 219 220 ip = he->ms.map->map_ip(he->ms.map, ip); 221 symbol__inc_addr_samples(sym, he->ms.map, counter, ip); 222 223 pthread_mutex_unlock(¬es->lock); 224 } 225 226 static void show_details(struct hist_entry *he) 227 { 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", event_name(top.sym_evsel), symbol->name); 244 printf(" Events Pcnt (>=%d%%)\n", sym_pcnt_filter); 245 246 more = symbol__annotate_printf(symbol, he->ms.map, top.sym_evsel->idx, 247 0, sym_pcnt_filter, top.print_entries, 4); 248 if (top.zero) 249 symbol__annotate_zero_histogram(symbol, top.sym_evsel->idx); 250 else 251 symbol__annotate_decay_histogram(symbol, top.sym_evsel->idx); 252 if (more != 0) 253 printf("%d lines not displayed, maybe increase display entries [e]\n", more); 254 out_unlock: 255 pthread_mutex_unlock(¬es->lock); 256 } 257 258 static const char CONSOLE_CLEAR[] = "[H[2J"; 259 260 static struct hist_entry * 261 perf_session__add_hist_entry(struct perf_session *session, 262 struct addr_location *al, 263 struct perf_sample *sample, 264 struct perf_evsel *evsel) 265 { 266 struct hist_entry *he; 267 268 he = __hists__add_entry(&evsel->hists, al, NULL, sample->period); 269 if (he == NULL) 270 return NULL; 271 272 session->hists.stats.total_period += sample->period; 273 hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE); 274 return he; 275 } 276 277 static void print_sym_table(void) 278 { 279 char bf[160]; 280 int printed = 0; 281 const int win_width = winsize.ws_col - 1; 282 283 puts(CONSOLE_CLEAR); 284 285 perf_top__header_snprintf(&top, bf, sizeof(bf)); 286 printf("%s\n", bf); 287 288 perf_top__reset_sample_counters(&top); 289 290 printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 291 292 if (top.total_lost_warned != top.session->hists.stats.total_lost) { 293 top.total_lost_warned = top.session->hists.stats.total_lost; 294 color_fprintf(stdout, PERF_COLOR_RED, "WARNING:"); 295 printf(" LOST %" PRIu64 " events, Check IO/CPU overload\n", 296 top.total_lost_warned); 297 ++printed; 298 } 299 300 if (top.sym_filter_entry) { 301 show_details(top.sym_filter_entry); 302 return; 303 } 304 305 hists__collapse_resort_threaded(&top.sym_evsel->hists); 306 hists__output_resort_threaded(&top.sym_evsel->hists); 307 hists__decay_entries_threaded(&top.sym_evsel->hists, 308 top.hide_user_symbols, 309 top.hide_kernel_symbols); 310 hists__output_recalc_col_len(&top.sym_evsel->hists, winsize.ws_row - 3); 311 putchar('\n'); 312 hists__fprintf(&top.sym_evsel->hists, NULL, false, false, 313 winsize.ws_row - 4 - printed, win_width, stdout); 314 } 315 316 static void prompt_integer(int *target, const char *msg) 317 { 318 char *buf = malloc(0), *p; 319 size_t dummy = 0; 320 int tmp; 321 322 fprintf(stdout, "\n%s: ", msg); 323 if (getline(&buf, &dummy, stdin) < 0) 324 return; 325 326 p = strchr(buf, '\n'); 327 if (p) 328 *p = 0; 329 330 p = buf; 331 while(*p) { 332 if (!isdigit(*p)) 333 goto out_free; 334 p++; 335 } 336 tmp = strtoul(buf, NULL, 10); 337 *target = tmp; 338 out_free: 339 free(buf); 340 } 341 342 static void prompt_percent(int *target, const char *msg) 343 { 344 int tmp = 0; 345 346 prompt_integer(&tmp, msg); 347 if (tmp >= 0 && tmp <= 100) 348 *target = tmp; 349 } 350 351 static void prompt_symbol(struct hist_entry **target, const char *msg) 352 { 353 char *buf = malloc(0), *p; 354 struct hist_entry *syme = *target, *n, *found = NULL; 355 struct rb_node *next; 356 size_t dummy = 0; 357 358 /* zero counters of active symbol */ 359 if (syme) { 360 __zero_source_counters(syme); 361 *target = NULL; 362 } 363 364 fprintf(stdout, "\n%s: ", msg); 365 if (getline(&buf, &dummy, stdin) < 0) 366 goto out_free; 367 368 p = strchr(buf, '\n'); 369 if (p) 370 *p = 0; 371 372 next = rb_first(&top.sym_evsel->hists.entries); 373 while (next) { 374 n = rb_entry(next, struct hist_entry, rb_node); 375 if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) { 376 found = n; 377 break; 378 } 379 next = rb_next(&n->rb_node); 380 } 381 382 if (!found) { 383 fprintf(stderr, "Sorry, %s is not active.\n", buf); 384 sleep(1); 385 return; 386 } else 387 parse_source(found); 388 389 out_free: 390 free(buf); 391 } 392 393 static void print_mapped_keys(void) 394 { 395 char *name = NULL; 396 397 if (top.sym_filter_entry) { 398 struct symbol *sym = top.sym_filter_entry->ms.sym; 399 name = sym->name; 400 } 401 402 fprintf(stdout, "\nMapped keys:\n"); 403 fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", top.delay_secs); 404 fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", top.print_entries); 405 406 if (top.evlist->nr_entries > 1) 407 fprintf(stdout, "\t[E] active event counter. \t(%s)\n", event_name(top.sym_evsel)); 408 409 fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", top.count_filter); 410 411 fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter); 412 fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL"); 413 fprintf(stdout, "\t[S] stop annotation.\n"); 414 415 fprintf(stdout, 416 "\t[K] hide kernel_symbols symbols. \t(%s)\n", 417 top.hide_kernel_symbols ? "yes" : "no"); 418 fprintf(stdout, 419 "\t[U] hide user symbols. \t(%s)\n", 420 top.hide_user_symbols ? "yes" : "no"); 421 fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", top.zero ? 1 : 0); 422 fprintf(stdout, "\t[qQ] quit.\n"); 423 } 424 425 static int key_mapped(int c) 426 { 427 switch (c) { 428 case 'd': 429 case 'e': 430 case 'f': 431 case 'z': 432 case 'q': 433 case 'Q': 434 case 'K': 435 case 'U': 436 case 'F': 437 case 's': 438 case 'S': 439 return 1; 440 case 'E': 441 return top.evlist->nr_entries > 1 ? 1 : 0; 442 default: 443 break; 444 } 445 446 return 0; 447 } 448 449 static void handle_keypress(int c) 450 { 451 if (!key_mapped(c)) { 452 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 453 struct termios tc, save; 454 455 print_mapped_keys(); 456 fprintf(stdout, "\nEnter selection, or unmapped key to continue: "); 457 fflush(stdout); 458 459 tcgetattr(0, &save); 460 tc = save; 461 tc.c_lflag &= ~(ICANON | ECHO); 462 tc.c_cc[VMIN] = 0; 463 tc.c_cc[VTIME] = 0; 464 tcsetattr(0, TCSANOW, &tc); 465 466 poll(&stdin_poll, 1, -1); 467 c = getc(stdin); 468 469 tcsetattr(0, TCSAFLUSH, &save); 470 if (!key_mapped(c)) 471 return; 472 } 473 474 switch (c) { 475 case 'd': 476 prompt_integer(&top.delay_secs, "Enter display delay"); 477 if (top.delay_secs < 1) 478 top.delay_secs = 1; 479 break; 480 case 'e': 481 prompt_integer(&top.print_entries, "Enter display entries (lines)"); 482 if (top.print_entries == 0) { 483 sig_winch_handler(SIGWINCH); 484 signal(SIGWINCH, sig_winch_handler); 485 } else 486 signal(SIGWINCH, SIG_DFL); 487 break; 488 case 'E': 489 if (top.evlist->nr_entries > 1) { 490 /* Select 0 as the default event: */ 491 int counter = 0; 492 493 fprintf(stderr, "\nAvailable events:"); 494 495 list_for_each_entry(top.sym_evsel, &top.evlist->entries, node) 496 fprintf(stderr, "\n\t%d %s", top.sym_evsel->idx, event_name(top.sym_evsel)); 497 498 prompt_integer(&counter, "Enter details event counter"); 499 500 if (counter >= top.evlist->nr_entries) { 501 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 502 fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(top.sym_evsel)); 503 sleep(1); 504 break; 505 } 506 list_for_each_entry(top.sym_evsel, &top.evlist->entries, node) 507 if (top.sym_evsel->idx == counter) 508 break; 509 } else 510 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 511 break; 512 case 'f': 513 prompt_integer(&top.count_filter, "Enter display event count filter"); 514 break; 515 case 'F': 516 prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)"); 517 break; 518 case 'K': 519 top.hide_kernel_symbols = !top.hide_kernel_symbols; 520 break; 521 case 'q': 522 case 'Q': 523 printf("exiting.\n"); 524 if (dump_symtab) 525 perf_session__fprintf_dsos(top.session, stderr); 526 exit(0); 527 case 's': 528 prompt_symbol(&top.sym_filter_entry, "Enter details symbol"); 529 break; 530 case 'S': 531 if (!top.sym_filter_entry) 532 break; 533 else { 534 struct hist_entry *syme = top.sym_filter_entry; 535 536 top.sym_filter_entry = NULL; 537 __zero_source_counters(syme); 538 } 539 break; 540 case 'U': 541 top.hide_user_symbols = !top.hide_user_symbols; 542 break; 543 case 'z': 544 top.zero = !top.zero; 545 break; 546 default: 547 break; 548 } 549 } 550 551 static void perf_top__sort_new_samples(void *arg) 552 { 553 struct perf_top *t = arg; 554 perf_top__reset_sample_counters(t); 555 556 if (t->evlist->selected != NULL) 557 t->sym_evsel = t->evlist->selected; 558 559 hists__collapse_resort_threaded(&t->sym_evsel->hists); 560 hists__output_resort_threaded(&t->sym_evsel->hists); 561 hists__decay_entries_threaded(&t->sym_evsel->hists, 562 top.hide_user_symbols, 563 top.hide_kernel_symbols); 564 hists__output_recalc_col_len(&t->sym_evsel->hists, winsize.ws_row - 3); 565 } 566 567 static void *display_thread_tui(void *arg __used) 568 { 569 const char *help = "For a higher level overview, try: perf top --sort comm,dso"; 570 571 perf_top__sort_new_samples(&top); 572 perf_evlist__tui_browse_hists(top.evlist, help, 573 perf_top__sort_new_samples, 574 &top, top.delay_secs); 575 576 exit_browser(0); 577 exit(0); 578 return NULL; 579 } 580 581 static void *display_thread(void *arg __used) 582 { 583 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 584 struct termios tc, save; 585 int delay_msecs, c; 586 587 tcgetattr(0, &save); 588 tc = save; 589 tc.c_lflag &= ~(ICANON | ECHO); 590 tc.c_cc[VMIN] = 0; 591 tc.c_cc[VTIME] = 0; 592 593 pthread__unblock_sigwinch(); 594 repeat: 595 delay_msecs = top.delay_secs * 1000; 596 tcsetattr(0, TCSANOW, &tc); 597 /* trash return*/ 598 getc(stdin); 599 600 while (1) { 601 print_sym_table(); 602 /* 603 * Either timeout expired or we got an EINTR due to SIGWINCH, 604 * refresh screen in both cases. 605 */ 606 switch (poll(&stdin_poll, 1, delay_msecs)) { 607 case 0: 608 continue; 609 case -1: 610 if (errno == EINTR) 611 continue; 612 /* Fall trhu */ 613 default: 614 goto process_hotkey; 615 } 616 } 617 process_hotkey: 618 c = getc(stdin); 619 tcsetattr(0, TCSAFLUSH, &save); 620 621 handle_keypress(c); 622 goto repeat; 623 624 return NULL; 625 } 626 627 /* Tag samples to be skipped. */ 628 static const char *skip_symbols[] = { 629 "default_idle", 630 "native_safe_halt", 631 "cpu_idle", 632 "enter_idle", 633 "exit_idle", 634 "mwait_idle", 635 "mwait_idle_with_hints", 636 "poll_idle", 637 "ppc64_runlatch_off", 638 "pseries_dedicated_idle_sleep", 639 NULL 640 }; 641 642 static int symbol_filter(struct map *map __used, struct symbol *sym) 643 { 644 const char *name = sym->name; 645 int i; 646 647 /* 648 * ppc64 uses function descriptors and appends a '.' to the 649 * start of every instruction address. Remove it. 650 */ 651 if (name[0] == '.') 652 name++; 653 654 if (!strcmp(name, "_text") || 655 !strcmp(name, "_etext") || 656 !strcmp(name, "_sinittext") || 657 !strncmp("init_module", name, 11) || 658 !strncmp("cleanup_module", name, 14) || 659 strstr(name, "_text_start") || 660 strstr(name, "_text_end")) 661 return 1; 662 663 for (i = 0; skip_symbols[i]; i++) { 664 if (!strcmp(skip_symbols[i], name)) { 665 sym->ignore = true; 666 break; 667 } 668 } 669 670 return 0; 671 } 672 673 static void perf_event__process_sample(const union perf_event *event, 674 struct perf_sample *sample, 675 struct perf_session *session) 676 { 677 struct symbol *parent = NULL; 678 u64 ip = event->ip.ip; 679 struct addr_location al; 680 struct machine *machine; 681 int err; 682 u8 origin = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 683 684 ++top.samples; 685 686 switch (origin) { 687 case PERF_RECORD_MISC_USER: 688 ++top.us_samples; 689 if (top.hide_user_symbols) 690 return; 691 machine = perf_session__find_host_machine(session); 692 break; 693 case PERF_RECORD_MISC_KERNEL: 694 ++top.kernel_samples; 695 if (top.hide_kernel_symbols) 696 return; 697 machine = perf_session__find_host_machine(session); 698 break; 699 case PERF_RECORD_MISC_GUEST_KERNEL: 700 ++top.guest_kernel_samples; 701 machine = perf_session__find_machine(session, event->ip.pid); 702 break; 703 case PERF_RECORD_MISC_GUEST_USER: 704 ++top.guest_us_samples; 705 /* 706 * TODO: we don't process guest user from host side 707 * except simple counting. 708 */ 709 return; 710 default: 711 return; 712 } 713 714 if (!machine && perf_guest) { 715 pr_err("Can't find guest [%d]'s kernel information\n", 716 event->ip.pid); 717 return; 718 } 719 720 if (event->header.misc & PERF_RECORD_MISC_EXACT_IP) 721 top.exact_samples++; 722 723 if (perf_event__preprocess_sample(event, session, &al, sample, 724 symbol_filter) < 0 || 725 al.filtered) 726 return; 727 728 if (!kptr_restrict_warned && 729 symbol_conf.kptr_restrict && 730 al.cpumode == PERF_RECORD_MISC_KERNEL) { 731 ui__warning( 732 "Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n" 733 "Check /proc/sys/kernel/kptr_restrict.\n\n" 734 "Kernel%s samples will not be resolved.\n", 735 !RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION]) ? 736 " modules" : ""); 737 if (use_browser <= 0) 738 sleep(5); 739 kptr_restrict_warned = true; 740 } 741 742 if (al.sym == NULL) { 743 const char *msg = "Kernel samples will not be resolved.\n"; 744 /* 745 * As we do lazy loading of symtabs we only will know if the 746 * specified vmlinux file is invalid when we actually have a 747 * hit in kernel space and then try to load it. So if we get 748 * here and there are _no_ symbols in the DSO backing the 749 * kernel map, bail out. 750 * 751 * We may never get here, for instance, if we use -K/ 752 * --hide-kernel-symbols, even if the user specifies an 753 * invalid --vmlinux ;-) 754 */ 755 if (!kptr_restrict_warned && !vmlinux_warned && 756 al.map == machine->vmlinux_maps[MAP__FUNCTION] && 757 RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 758 if (symbol_conf.vmlinux_name) { 759 ui__warning("The %s file can't be used.\n%s", 760 symbol_conf.vmlinux_name, msg); 761 } else { 762 ui__warning("A vmlinux file was not found.\n%s", 763 msg); 764 } 765 766 if (use_browser <= 0) 767 sleep(5); 768 vmlinux_warned = true; 769 } 770 } 771 772 if (al.sym == NULL || !al.sym->ignore) { 773 struct perf_evsel *evsel; 774 struct hist_entry *he; 775 776 evsel = perf_evlist__id2evsel(top.evlist, sample->id); 777 assert(evsel != NULL); 778 779 if ((sort__has_parent || symbol_conf.use_callchain) && 780 sample->callchain) { 781 err = perf_session__resolve_callchain(session, al.thread, 782 sample->callchain, &parent); 783 if (err) 784 return; 785 } 786 787 he = perf_session__add_hist_entry(session, &al, sample, evsel); 788 if (he == NULL) { 789 pr_err("Problem incrementing symbol period, skipping event\n"); 790 return; 791 } 792 793 if (symbol_conf.use_callchain) { 794 err = callchain_append(he->callchain, &session->callchain_cursor, 795 sample->period); 796 if (err) 797 return; 798 } 799 800 if (sort_has_symbols) 801 record_precise_ip(he, evsel->idx, ip); 802 } 803 804 return; 805 } 806 807 static void perf_session__mmap_read_idx(struct perf_session *self, int idx) 808 { 809 struct perf_sample sample; 810 union perf_event *event; 811 int ret; 812 813 while ((event = perf_evlist__mmap_read(top.evlist, idx)) != NULL) { 814 ret = perf_session__parse_sample(self, event, &sample); 815 if (ret) { 816 pr_err("Can't parse sample, err = %d\n", ret); 817 continue; 818 } 819 820 if (event->header.type == PERF_RECORD_SAMPLE) 821 perf_event__process_sample(event, &sample, self); 822 else 823 perf_event__process(event, &sample, self); 824 } 825 } 826 827 static void perf_session__mmap_read(struct perf_session *self) 828 { 829 int i; 830 831 for (i = 0; i < top.evlist->nr_mmaps; i++) 832 perf_session__mmap_read_idx(self, i); 833 } 834 835 static void start_counters(struct perf_evlist *evlist) 836 { 837 struct perf_evsel *counter; 838 839 list_for_each_entry(counter, &evlist->entries, node) { 840 struct perf_event_attr *attr = &counter->attr; 841 842 attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID; 843 844 if (top.freq) { 845 attr->sample_type |= PERF_SAMPLE_PERIOD; 846 attr->freq = 1; 847 attr->sample_freq = top.freq; 848 } 849 850 if (evlist->nr_entries > 1) { 851 attr->sample_type |= PERF_SAMPLE_ID; 852 attr->read_format |= PERF_FORMAT_ID; 853 } 854 855 if (symbol_conf.use_callchain) 856 attr->sample_type |= PERF_SAMPLE_CALLCHAIN; 857 858 attr->mmap = 1; 859 attr->comm = 1; 860 attr->inherit = inherit; 861 try_again: 862 if (perf_evsel__open(counter, top.evlist->cpus, 863 top.evlist->threads, group) < 0) { 864 int err = errno; 865 866 if (err == EPERM || err == EACCES) { 867 ui__warning_paranoid(); 868 goto out_err; 869 } 870 /* 871 * If it's cycles then fall back to hrtimer 872 * based cpu-clock-tick sw counter, which 873 * is always available even if no PMU support: 874 */ 875 if (attr->type == PERF_TYPE_HARDWARE && 876 attr->config == PERF_COUNT_HW_CPU_CYCLES) { 877 if (verbose) 878 ui__warning("Cycles event not supported,\n" 879 "trying to fall back to cpu-clock-ticks\n"); 880 881 attr->type = PERF_TYPE_SOFTWARE; 882 attr->config = PERF_COUNT_SW_CPU_CLOCK; 883 goto try_again; 884 } 885 886 if (err == ENOENT) { 887 ui__warning("The %s event is not supported.\n", 888 event_name(counter)); 889 goto out_err; 890 } 891 892 ui__warning("The sys_perf_event_open() syscall " 893 "returned with %d (%s). /bin/dmesg " 894 "may provide additional information.\n" 895 "No CONFIG_PERF_EVENTS=y kernel support " 896 "configured?\n", err, strerror(err)); 897 goto out_err; 898 } 899 } 900 901 if (perf_evlist__mmap(evlist, mmap_pages, false) < 0) { 902 ui__warning("Failed to mmap with %d (%s)\n", 903 errno, strerror(errno)); 904 goto out_err; 905 } 906 907 return; 908 909 out_err: 910 exit_browser(0); 911 exit(0); 912 } 913 914 static int setup_sample_type(void) 915 { 916 if (!sort_has_symbols) { 917 if (symbol_conf.use_callchain) { 918 ui__warning("Selected -g but \"sym\" not present in --sort/-s."); 919 return -EINVAL; 920 } 921 } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE) { 922 if (callchain_register_param(&callchain_param) < 0) { 923 ui__warning("Can't register callchain params.\n"); 924 return -EINVAL; 925 } 926 } 927 928 return 0; 929 } 930 931 static int __cmd_top(void) 932 { 933 pthread_t thread; 934 int ret; 935 /* 936 * FIXME: perf_session__new should allow passing a O_MMAP, so that all this 937 * mmap reading, etc is encapsulated in it. Use O_WRONLY for now. 938 */ 939 top.session = perf_session__new(NULL, O_WRONLY, false, false, NULL); 940 if (top.session == NULL) 941 return -ENOMEM; 942 943 ret = setup_sample_type(); 944 if (ret) 945 goto out_delete; 946 947 if (top.target_tid != -1) 948 perf_event__synthesize_thread_map(top.evlist->threads, 949 perf_event__process, top.session); 950 else 951 perf_event__synthesize_threads(perf_event__process, top.session); 952 953 start_counters(top.evlist); 954 top.session->evlist = top.evlist; 955 perf_session__update_sample_type(top.session); 956 957 /* Wait for a minimal set of events before starting the snapshot */ 958 poll(top.evlist->pollfd, top.evlist->nr_fds, 100); 959 960 perf_session__mmap_read(top.session); 961 962 if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui : 963 display_thread), NULL)) { 964 printf("Could not create display thread.\n"); 965 exit(-1); 966 } 967 968 if (realtime_prio) { 969 struct sched_param param; 970 971 param.sched_priority = realtime_prio; 972 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 973 printf("Could not set realtime priority.\n"); 974 exit(-1); 975 } 976 } 977 978 while (1) { 979 u64 hits = top.samples; 980 981 perf_session__mmap_read(top.session); 982 983 if (hits == top.samples) 984 ret = poll(top.evlist->pollfd, top.evlist->nr_fds, 100); 985 } 986 987 out_delete: 988 perf_session__delete(top.session); 989 top.session = NULL; 990 991 return 0; 992 } 993 994 static int 995 parse_callchain_opt(const struct option *opt __used, const char *arg, 996 int unset) 997 { 998 char *tok, *tok2; 999 char *endptr; 1000 1001 /* 1002 * --no-call-graph 1003 */ 1004 if (unset) { 1005 dont_use_callchains = true; 1006 return 0; 1007 } 1008 1009 symbol_conf.use_callchain = true; 1010 1011 if (!arg) 1012 return 0; 1013 1014 tok = strtok((char *)arg, ","); 1015 if (!tok) 1016 return -1; 1017 1018 /* get the output mode */ 1019 if (!strncmp(tok, "graph", strlen(arg))) 1020 callchain_param.mode = CHAIN_GRAPH_ABS; 1021 1022 else if (!strncmp(tok, "flat", strlen(arg))) 1023 callchain_param.mode = CHAIN_FLAT; 1024 1025 else if (!strncmp(tok, "fractal", strlen(arg))) 1026 callchain_param.mode = CHAIN_GRAPH_REL; 1027 1028 else if (!strncmp(tok, "none", strlen(arg))) { 1029 callchain_param.mode = CHAIN_NONE; 1030 symbol_conf.use_callchain = false; 1031 1032 return 0; 1033 } 1034 1035 else 1036 return -1; 1037 1038 /* get the min percentage */ 1039 tok = strtok(NULL, ","); 1040 if (!tok) 1041 goto setup; 1042 1043 callchain_param.min_percent = strtod(tok, &endptr); 1044 if (tok == endptr) 1045 return -1; 1046 1047 /* get the print limit */ 1048 tok2 = strtok(NULL, ","); 1049 if (!tok2) 1050 goto setup; 1051 1052 if (tok2[0] != 'c') { 1053 callchain_param.print_limit = strtod(tok2, &endptr); 1054 tok2 = strtok(NULL, ","); 1055 if (!tok2) 1056 goto setup; 1057 } 1058 1059 /* get the call chain order */ 1060 if (!strcmp(tok2, "caller")) 1061 callchain_param.order = ORDER_CALLER; 1062 else if (!strcmp(tok2, "callee")) 1063 callchain_param.order = ORDER_CALLEE; 1064 else 1065 return -1; 1066 setup: 1067 if (callchain_register_param(&callchain_param) < 0) { 1068 fprintf(stderr, "Can't register callchain params\n"); 1069 return -1; 1070 } 1071 return 0; 1072 } 1073 1074 static const char * const top_usage[] = { 1075 "perf top [<options>]", 1076 NULL 1077 }; 1078 1079 static const struct option options[] = { 1080 OPT_CALLBACK('e', "event", &top.evlist, "event", 1081 "event selector. use 'perf list' to list available events", 1082 parse_events_option), 1083 OPT_INTEGER('c', "count", &default_interval, 1084 "event period to sample"), 1085 OPT_INTEGER('p', "pid", &top.target_pid, 1086 "profile events on existing process id"), 1087 OPT_INTEGER('t', "tid", &top.target_tid, 1088 "profile events on existing thread id"), 1089 OPT_BOOLEAN('a', "all-cpus", &system_wide, 1090 "system-wide collection from all CPUs"), 1091 OPT_STRING('C', "cpu", &top.cpu_list, "cpu", 1092 "list of cpus to monitor"), 1093 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 1094 "file", "vmlinux pathname"), 1095 OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols, 1096 "hide kernel symbols"), 1097 OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"), 1098 OPT_INTEGER('r', "realtime", &realtime_prio, 1099 "collect data with this RT SCHED_FIFO priority"), 1100 OPT_INTEGER('d', "delay", &top.delay_secs, 1101 "number of seconds to delay between refreshes"), 1102 OPT_BOOLEAN('D', "dump-symtab", &dump_symtab, 1103 "dump the symbol table used for profiling"), 1104 OPT_INTEGER('f', "count-filter", &top.count_filter, 1105 "only display functions with more events than this"), 1106 OPT_BOOLEAN('g', "group", &group, 1107 "put the counters into a counter group"), 1108 OPT_BOOLEAN('i', "inherit", &inherit, 1109 "child tasks inherit counters"), 1110 OPT_STRING(0, "sym-annotate", &sym_filter, "symbol name", 1111 "symbol to annotate"), 1112 OPT_BOOLEAN('z', "zero", &top.zero, 1113 "zero history across updates"), 1114 OPT_INTEGER('F', "freq", &top.freq, 1115 "profile at this frequency"), 1116 OPT_INTEGER('E', "entries", &top.print_entries, 1117 "display this many functions"), 1118 OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols, 1119 "hide user symbols"), 1120 OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"), 1121 OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"), 1122 OPT_INCR('v', "verbose", &verbose, 1123 "be more verbose (show counter open errors, etc)"), 1124 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 1125 "sort by key(s): pid, comm, dso, symbol, parent"), 1126 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples, 1127 "Show a column with the number of samples"), 1128 OPT_CALLBACK_DEFAULT('G', "call-graph", NULL, "output_type,min_percent, call_order", 1129 "Display callchains using output_type (graph, flat, fractal, or none), min percent threshold and callchain order. " 1130 "Default: fractal,0.5,callee", &parse_callchain_opt, 1131 callchain_default_opt), 1132 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period, 1133 "Show a column with the sum of periods"), 1134 OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 1135 "only consider symbols in these dsos"), 1136 OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 1137 "only consider symbols in these comms"), 1138 OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 1139 "only consider these symbols"), 1140 OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src, 1141 "Interleave source code with assembly code (default)"), 1142 OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw, 1143 "Display raw encoding of assembly instructions (default)"), 1144 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style", 1145 "Specify disassembler style (e.g. -M intel for intel syntax)"), 1146 OPT_END() 1147 }; 1148 1149 int cmd_top(int argc, const char **argv, const char *prefix __used) 1150 { 1151 struct perf_evsel *pos; 1152 int status = -ENOMEM; 1153 1154 top.evlist = perf_evlist__new(NULL, NULL); 1155 if (top.evlist == NULL) 1156 return -ENOMEM; 1157 1158 symbol_conf.exclude_other = false; 1159 1160 argc = parse_options(argc, argv, options, top_usage, 0); 1161 if (argc) 1162 usage_with_options(top_usage, options); 1163 1164 if (sort_order == default_sort_order) 1165 sort_order = "dso,symbol"; 1166 1167 setup_sorting(top_usage, options); 1168 1169 if (use_stdio) 1170 use_browser = 0; 1171 else if (use_tui) 1172 use_browser = 1; 1173 1174 setup_browser(false); 1175 1176 /* CPU and PID are mutually exclusive */ 1177 if (top.target_tid > 0 && top.cpu_list) { 1178 printf("WARNING: PID switch overriding CPU\n"); 1179 sleep(1); 1180 top.cpu_list = NULL; 1181 } 1182 1183 if (top.target_pid != -1) 1184 top.target_tid = top.target_pid; 1185 1186 if (perf_evlist__create_maps(top.evlist, top.target_pid, 1187 top.target_tid, top.cpu_list) < 0) 1188 usage_with_options(top_usage, options); 1189 1190 if (!top.evlist->nr_entries && 1191 perf_evlist__add_default(top.evlist) < 0) { 1192 pr_err("Not enough memory for event selector list\n"); 1193 return -ENOMEM; 1194 } 1195 1196 if (top.delay_secs < 1) 1197 top.delay_secs = 1; 1198 1199 /* 1200 * User specified count overrides default frequency. 1201 */ 1202 if (default_interval) 1203 top.freq = 0; 1204 else if (top.freq) { 1205 default_interval = top.freq; 1206 } else { 1207 fprintf(stderr, "frequency and count are zero, aborting\n"); 1208 exit(EXIT_FAILURE); 1209 } 1210 1211 list_for_each_entry(pos, &top.evlist->entries, node) { 1212 if (perf_evsel__alloc_fd(pos, top.evlist->cpus->nr, 1213 top.evlist->threads->nr) < 0) 1214 goto out_free_fd; 1215 /* 1216 * Fill in the ones not specifically initialized via -c: 1217 */ 1218 if (pos->attr.sample_period) 1219 continue; 1220 1221 pos->attr.sample_period = default_interval; 1222 } 1223 1224 if (perf_evlist__alloc_pollfd(top.evlist) < 0 || 1225 perf_evlist__alloc_mmap(top.evlist) < 0) 1226 goto out_free_fd; 1227 1228 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 1229 1230 symbol_conf.priv_size = sizeof(struct annotation); 1231 1232 symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 1233 if (symbol__init() < 0) 1234 return -1; 1235 1236 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout); 1237 sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout); 1238 sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout); 1239 1240 /* 1241 * Avoid annotation data structures overhead when symbols aren't on the 1242 * sort list. 1243 */ 1244 sort_has_symbols = sort_sym.list.next != NULL; 1245 1246 get_term_dimensions(&winsize); 1247 if (top.print_entries == 0) { 1248 update_print_entries(&winsize); 1249 signal(SIGWINCH, sig_winch_handler); 1250 } 1251 1252 status = __cmd_top(); 1253 out_free_fd: 1254 perf_evlist__delete(top.evlist); 1255 1256 return status; 1257 } 1258