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