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 * 9 * Improvements and fixes by: 10 * 11 * Arjan van de Ven <arjan@linux.intel.com> 12 * Yanmin Zhang <yanmin.zhang@intel.com> 13 * Wu Fengguang <fengguang.wu@intel.com> 14 * Mike Galbraith <efault@gmx.de> 15 * Paul Mackerras <paulus@samba.org> 16 * 17 * Released under the GPL v2. (and only v2, not any later version) 18 */ 19 #include "builtin.h" 20 21 #include "perf.h" 22 23 #include "util/annotate.h" 24 #include "util/cache.h" 25 #include "util/color.h" 26 #include "util/evlist.h" 27 #include "util/evsel.h" 28 #include "util/session.h" 29 #include "util/symbol.h" 30 #include "util/thread.h" 31 #include "util/thread_map.h" 32 #include "util/top.h" 33 #include "util/util.h" 34 #include <linux/rbtree.h> 35 #include "util/parse-options.h" 36 #include "util/parse-events.h" 37 #include "util/cpumap.h" 38 #include "util/xyarray.h" 39 40 #include "util/debug.h" 41 42 #include <assert.h> 43 #include <fcntl.h> 44 45 #include <stdio.h> 46 #include <termios.h> 47 #include <unistd.h> 48 #include <inttypes.h> 49 50 #include <errno.h> 51 #include <time.h> 52 #include <sched.h> 53 54 #include <sys/syscall.h> 55 #include <sys/ioctl.h> 56 #include <sys/poll.h> 57 #include <sys/prctl.h> 58 #include <sys/wait.h> 59 #include <sys/uio.h> 60 #include <sys/mman.h> 61 62 #include <linux/unistd.h> 63 #include <linux/types.h> 64 65 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 66 67 static struct perf_top top = { 68 .count_filter = 5, 69 .delay_secs = 2, 70 .display_weighted = -1, 71 .target_pid = -1, 72 .target_tid = -1, 73 .active_symbols = LIST_HEAD_INIT(top.active_symbols), 74 .active_symbols_lock = PTHREAD_MUTEX_INITIALIZER, 75 .active_symbols_cond = PTHREAD_COND_INITIALIZER, 76 .freq = 1000, /* 1 KHz */ 77 }; 78 79 static bool system_wide = false; 80 81 static bool use_tui, use_stdio; 82 83 static int default_interval = 0; 84 85 static bool inherit = false; 86 static int realtime_prio = 0; 87 static bool group = false; 88 static unsigned int page_size; 89 static unsigned int mmap_pages = 128; 90 91 static bool dump_symtab = false; 92 93 static struct winsize winsize; 94 95 static const char *sym_filter = NULL; 96 struct sym_entry *sym_filter_entry_sched = NULL; 97 static int sym_pcnt_filter = 5; 98 99 /* 100 * Source functions 101 */ 102 103 void get_term_dimensions(struct winsize *ws) 104 { 105 char *s = getenv("LINES"); 106 107 if (s != NULL) { 108 ws->ws_row = atoi(s); 109 s = getenv("COLUMNS"); 110 if (s != NULL) { 111 ws->ws_col = atoi(s); 112 if (ws->ws_row && ws->ws_col) 113 return; 114 } 115 } 116 #ifdef TIOCGWINSZ 117 if (ioctl(1, TIOCGWINSZ, ws) == 0 && 118 ws->ws_row && ws->ws_col) 119 return; 120 #endif 121 ws->ws_row = 25; 122 ws->ws_col = 80; 123 } 124 125 static void update_print_entries(struct winsize *ws) 126 { 127 top.print_entries = ws->ws_row; 128 129 if (top.print_entries > 9) 130 top.print_entries -= 9; 131 } 132 133 static void sig_winch_handler(int sig __used) 134 { 135 get_term_dimensions(&winsize); 136 update_print_entries(&winsize); 137 } 138 139 static int parse_source(struct sym_entry *syme) 140 { 141 struct symbol *sym; 142 struct annotation *notes; 143 struct map *map; 144 int err = -1; 145 146 if (!syme) 147 return -1; 148 149 sym = sym_entry__symbol(syme); 150 map = syme->map; 151 152 /* 153 * We can't annotate with just /proc/kallsyms 154 */ 155 if (map->dso->symtab_type == SYMTAB__KALLSYMS) { 156 pr_err("Can't annotate %s: No vmlinux file was found in the " 157 "path\n", sym->name); 158 sleep(1); 159 return -1; 160 } 161 162 notes = symbol__annotation(sym); 163 if (notes->src != NULL) { 164 pthread_mutex_lock(¬es->lock); 165 goto out_assign; 166 } 167 168 pthread_mutex_lock(¬es->lock); 169 170 if (symbol__alloc_hist(sym, top.evlist->nr_entries) < 0) { 171 pthread_mutex_unlock(¬es->lock); 172 pr_err("Not enough memory for annotating '%s' symbol!\n", 173 sym->name); 174 sleep(1); 175 return err; 176 } 177 178 err = symbol__annotate(sym, syme->map, 0); 179 if (err == 0) { 180 out_assign: 181 top.sym_filter_entry = syme; 182 } 183 184 pthread_mutex_unlock(¬es->lock); 185 return err; 186 } 187 188 static void __zero_source_counters(struct sym_entry *syme) 189 { 190 struct symbol *sym = sym_entry__symbol(syme); 191 symbol__annotate_zero_histograms(sym); 192 } 193 194 static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip) 195 { 196 struct annotation *notes; 197 struct symbol *sym; 198 199 if (syme != top.sym_filter_entry) 200 return; 201 202 sym = sym_entry__symbol(syme); 203 notes = symbol__annotation(sym); 204 205 if (pthread_mutex_trylock(¬es->lock)) 206 return; 207 208 ip = syme->map->map_ip(syme->map, ip); 209 symbol__inc_addr_samples(sym, syme->map, counter, ip); 210 211 pthread_mutex_unlock(¬es->lock); 212 } 213 214 static void show_details(struct sym_entry *syme) 215 { 216 struct annotation *notes; 217 struct symbol *symbol; 218 int more; 219 220 if (!syme) 221 return; 222 223 symbol = sym_entry__symbol(syme); 224 notes = symbol__annotation(symbol); 225 226 pthread_mutex_lock(¬es->lock); 227 228 if (notes->src == NULL) 229 goto out_unlock; 230 231 printf("Showing %s for %s\n", event_name(top.sym_evsel), symbol->name); 232 printf(" Events Pcnt (>=%d%%)\n", sym_pcnt_filter); 233 234 more = symbol__annotate_printf(symbol, syme->map, top.sym_evsel->idx, 235 0, sym_pcnt_filter, top.print_entries, 4); 236 if (top.zero) 237 symbol__annotate_zero_histogram(symbol, top.sym_evsel->idx); 238 else 239 symbol__annotate_decay_histogram(symbol, top.sym_evsel->idx); 240 if (more != 0) 241 printf("%d lines not displayed, maybe increase display entries [e]\n", more); 242 out_unlock: 243 pthread_mutex_unlock(¬es->lock); 244 } 245 246 static const char CONSOLE_CLEAR[] = "[H[2J"; 247 248 static void __list_insert_active_sym(struct sym_entry *syme) 249 { 250 list_add(&syme->node, &top.active_symbols); 251 } 252 253 static void print_sym_table(struct perf_session *session) 254 { 255 char bf[160]; 256 int printed = 0; 257 struct rb_node *nd; 258 struct sym_entry *syme; 259 struct rb_root tmp = RB_ROOT; 260 const int win_width = winsize.ws_col - 1; 261 int sym_width, dso_width, dso_short_width; 262 float sum_ksamples = perf_top__decay_samples(&top, &tmp); 263 264 puts(CONSOLE_CLEAR); 265 266 perf_top__header_snprintf(&top, bf, sizeof(bf)); 267 printf("%s\n", bf); 268 269 perf_top__reset_sample_counters(&top); 270 271 printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 272 273 if (session->hists.stats.total_lost != 0) { 274 color_fprintf(stdout, PERF_COLOR_RED, "WARNING:"); 275 printf(" LOST %" PRIu64 " events, Check IO/CPU overload\n", 276 session->hists.stats.total_lost); 277 } 278 279 if (top.sym_filter_entry) { 280 show_details(top.sym_filter_entry); 281 return; 282 } 283 284 perf_top__find_widths(&top, &tmp, &dso_width, &dso_short_width, 285 &sym_width); 286 287 if (sym_width + dso_width > winsize.ws_col - 29) { 288 dso_width = dso_short_width; 289 if (sym_width + dso_width > winsize.ws_col - 29) 290 sym_width = winsize.ws_col - dso_width - 29; 291 } 292 putchar('\n'); 293 if (top.evlist->nr_entries == 1) 294 printf(" samples pcnt"); 295 else 296 printf(" weight samples pcnt"); 297 298 if (verbose) 299 printf(" RIP "); 300 printf(" %-*.*s DSO\n", sym_width, sym_width, "function"); 301 printf(" %s _______ _____", 302 top.evlist->nr_entries == 1 ? " " : "______"); 303 if (verbose) 304 printf(" ________________"); 305 printf(" %-*.*s", sym_width, sym_width, graph_line); 306 printf(" %-*.*s", dso_width, dso_width, graph_line); 307 puts("\n"); 308 309 for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) { 310 struct symbol *sym; 311 double pcnt; 312 313 syme = rb_entry(nd, struct sym_entry, rb_node); 314 sym = sym_entry__symbol(syme); 315 if (++printed > top.print_entries || 316 (int)syme->snap_count < top.count_filter) 317 continue; 318 319 pcnt = 100.0 - (100.0 * ((sum_ksamples - syme->snap_count) / 320 sum_ksamples)); 321 322 if (top.evlist->nr_entries == 1 || !top.display_weighted) 323 printf("%20.2f ", syme->weight); 324 else 325 printf("%9.1f %10ld ", syme->weight, syme->snap_count); 326 327 percent_color_fprintf(stdout, "%4.1f%%", pcnt); 328 if (verbose) 329 printf(" %016" PRIx64, sym->start); 330 printf(" %-*.*s", sym_width, sym_width, sym->name); 331 printf(" %-*.*s\n", dso_width, dso_width, 332 dso_width >= syme->map->dso->long_name_len ? 333 syme->map->dso->long_name : 334 syme->map->dso->short_name); 335 } 336 } 337 338 static void prompt_integer(int *target, const char *msg) 339 { 340 char *buf = malloc(0), *p; 341 size_t dummy = 0; 342 int tmp; 343 344 fprintf(stdout, "\n%s: ", msg); 345 if (getline(&buf, &dummy, stdin) < 0) 346 return; 347 348 p = strchr(buf, '\n'); 349 if (p) 350 *p = 0; 351 352 p = buf; 353 while(*p) { 354 if (!isdigit(*p)) 355 goto out_free; 356 p++; 357 } 358 tmp = strtoul(buf, NULL, 10); 359 *target = tmp; 360 out_free: 361 free(buf); 362 } 363 364 static void prompt_percent(int *target, const char *msg) 365 { 366 int tmp = 0; 367 368 prompt_integer(&tmp, msg); 369 if (tmp >= 0 && tmp <= 100) 370 *target = tmp; 371 } 372 373 static void prompt_symbol(struct sym_entry **target, const char *msg) 374 { 375 char *buf = malloc(0), *p; 376 struct sym_entry *syme = *target, *n, *found = NULL; 377 size_t dummy = 0; 378 379 /* zero counters of active symbol */ 380 if (syme) { 381 __zero_source_counters(syme); 382 *target = NULL; 383 } 384 385 fprintf(stdout, "\n%s: ", msg); 386 if (getline(&buf, &dummy, stdin) < 0) 387 goto out_free; 388 389 p = strchr(buf, '\n'); 390 if (p) 391 *p = 0; 392 393 pthread_mutex_lock(&top.active_symbols_lock); 394 syme = list_entry(top.active_symbols.next, struct sym_entry, node); 395 pthread_mutex_unlock(&top.active_symbols_lock); 396 397 list_for_each_entry_safe_from(syme, n, &top.active_symbols, node) { 398 struct symbol *sym = sym_entry__symbol(syme); 399 400 if (!strcmp(buf, sym->name)) { 401 found = syme; 402 break; 403 } 404 } 405 406 if (!found) { 407 fprintf(stderr, "Sorry, %s is not active.\n", buf); 408 sleep(1); 409 return; 410 } else 411 parse_source(found); 412 413 out_free: 414 free(buf); 415 } 416 417 static void print_mapped_keys(void) 418 { 419 char *name = NULL; 420 421 if (top.sym_filter_entry) { 422 struct symbol *sym = sym_entry__symbol(top.sym_filter_entry); 423 name = sym->name; 424 } 425 426 fprintf(stdout, "\nMapped keys:\n"); 427 fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", top.delay_secs); 428 fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", top.print_entries); 429 430 if (top.evlist->nr_entries > 1) 431 fprintf(stdout, "\t[E] active event counter. \t(%s)\n", event_name(top.sym_evsel)); 432 433 fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", top.count_filter); 434 435 fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter); 436 fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL"); 437 fprintf(stdout, "\t[S] stop annotation.\n"); 438 439 if (top.evlist->nr_entries > 1) 440 fprintf(stdout, "\t[w] toggle display weighted/count[E]r. \t(%d)\n", top.display_weighted ? 1 : 0); 441 442 fprintf(stdout, 443 "\t[K] hide kernel_symbols symbols. \t(%s)\n", 444 top.hide_kernel_symbols ? "yes" : "no"); 445 fprintf(stdout, 446 "\t[U] hide user symbols. \t(%s)\n", 447 top.hide_user_symbols ? "yes" : "no"); 448 fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", top.zero ? 1 : 0); 449 fprintf(stdout, "\t[qQ] quit.\n"); 450 } 451 452 static int key_mapped(int c) 453 { 454 switch (c) { 455 case 'd': 456 case 'e': 457 case 'f': 458 case 'z': 459 case 'q': 460 case 'Q': 461 case 'K': 462 case 'U': 463 case 'F': 464 case 's': 465 case 'S': 466 return 1; 467 case 'E': 468 case 'w': 469 return top.evlist->nr_entries > 1 ? 1 : 0; 470 default: 471 break; 472 } 473 474 return 0; 475 } 476 477 static void handle_keypress(struct perf_session *session, int c) 478 { 479 if (!key_mapped(c)) { 480 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 481 struct termios tc, save; 482 483 print_mapped_keys(); 484 fprintf(stdout, "\nEnter selection, or unmapped key to continue: "); 485 fflush(stdout); 486 487 tcgetattr(0, &save); 488 tc = save; 489 tc.c_lflag &= ~(ICANON | ECHO); 490 tc.c_cc[VMIN] = 0; 491 tc.c_cc[VTIME] = 0; 492 tcsetattr(0, TCSANOW, &tc); 493 494 poll(&stdin_poll, 1, -1); 495 c = getc(stdin); 496 497 tcsetattr(0, TCSAFLUSH, &save); 498 if (!key_mapped(c)) 499 return; 500 } 501 502 switch (c) { 503 case 'd': 504 prompt_integer(&top.delay_secs, "Enter display delay"); 505 if (top.delay_secs < 1) 506 top.delay_secs = 1; 507 break; 508 case 'e': 509 prompt_integer(&top.print_entries, "Enter display entries (lines)"); 510 if (top.print_entries == 0) { 511 sig_winch_handler(SIGWINCH); 512 signal(SIGWINCH, sig_winch_handler); 513 } else 514 signal(SIGWINCH, SIG_DFL); 515 break; 516 case 'E': 517 if (top.evlist->nr_entries > 1) { 518 int counter; 519 fprintf(stderr, "\nAvailable events:"); 520 521 list_for_each_entry(top.sym_evsel, &top.evlist->entries, node) 522 fprintf(stderr, "\n\t%d %s", top.sym_evsel->idx, event_name(top.sym_evsel)); 523 524 prompt_integer(&counter, "Enter details event counter"); 525 526 if (counter >= top.evlist->nr_entries) { 527 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 528 fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(top.sym_evsel)); 529 sleep(1); 530 break; 531 } 532 list_for_each_entry(top.sym_evsel, &top.evlist->entries, node) 533 if (top.sym_evsel->idx == counter) 534 break; 535 } else 536 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 537 break; 538 case 'f': 539 prompt_integer(&top.count_filter, "Enter display event count filter"); 540 break; 541 case 'F': 542 prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)"); 543 break; 544 case 'K': 545 top.hide_kernel_symbols = !top.hide_kernel_symbols; 546 break; 547 case 'q': 548 case 'Q': 549 printf("exiting.\n"); 550 if (dump_symtab) 551 perf_session__fprintf_dsos(session, stderr); 552 exit(0); 553 case 's': 554 prompt_symbol(&top.sym_filter_entry, "Enter details symbol"); 555 break; 556 case 'S': 557 if (!top.sym_filter_entry) 558 break; 559 else { 560 struct sym_entry *syme = top.sym_filter_entry; 561 562 top.sym_filter_entry = NULL; 563 __zero_source_counters(syme); 564 } 565 break; 566 case 'U': 567 top.hide_user_symbols = !top.hide_user_symbols; 568 break; 569 case 'w': 570 top.display_weighted = ~top.display_weighted; 571 break; 572 case 'z': 573 top.zero = !top.zero; 574 break; 575 default: 576 break; 577 } 578 } 579 580 static void *display_thread_tui(void *arg __used) 581 { 582 int err = 0; 583 pthread_mutex_lock(&top.active_symbols_lock); 584 while (list_empty(&top.active_symbols)) { 585 err = pthread_cond_wait(&top.active_symbols_cond, 586 &top.active_symbols_lock); 587 if (err) 588 break; 589 } 590 pthread_mutex_unlock(&top.active_symbols_lock); 591 if (!err) 592 perf_top__tui_browser(&top); 593 exit_browser(0); 594 exit(0); 595 return NULL; 596 } 597 598 static void *display_thread(void *arg __used) 599 { 600 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 601 struct termios tc, save; 602 int delay_msecs, c; 603 struct perf_session *session = (struct perf_session *) arg; 604 605 tcgetattr(0, &save); 606 tc = save; 607 tc.c_lflag &= ~(ICANON | ECHO); 608 tc.c_cc[VMIN] = 0; 609 tc.c_cc[VTIME] = 0; 610 611 repeat: 612 delay_msecs = top.delay_secs * 1000; 613 tcsetattr(0, TCSANOW, &tc); 614 /* trash return*/ 615 getc(stdin); 616 617 do { 618 print_sym_table(session); 619 } while (!poll(&stdin_poll, 1, delay_msecs) == 1); 620 621 c = getc(stdin); 622 tcsetattr(0, TCSAFLUSH, &save); 623 624 handle_keypress(session, c); 625 goto repeat; 626 627 return NULL; 628 } 629 630 /* Tag samples to be skipped. */ 631 static const char *skip_symbols[] = { 632 "default_idle", 633 "native_safe_halt", 634 "cpu_idle", 635 "enter_idle", 636 "exit_idle", 637 "mwait_idle", 638 "mwait_idle_with_hints", 639 "poll_idle", 640 "ppc64_runlatch_off", 641 "pseries_dedicated_idle_sleep", 642 NULL 643 }; 644 645 static int symbol_filter(struct map *map, struct symbol *sym) 646 { 647 struct sym_entry *syme; 648 const char *name = sym->name; 649 int i; 650 651 /* 652 * ppc64 uses function descriptors and appends a '.' to the 653 * start of every instruction address. Remove it. 654 */ 655 if (name[0] == '.') 656 name++; 657 658 if (!strcmp(name, "_text") || 659 !strcmp(name, "_etext") || 660 !strcmp(name, "_sinittext") || 661 !strncmp("init_module", name, 11) || 662 !strncmp("cleanup_module", name, 14) || 663 strstr(name, "_text_start") || 664 strstr(name, "_text_end")) 665 return 1; 666 667 syme = symbol__priv(sym); 668 syme->map = map; 669 symbol__annotate_init(map, sym); 670 671 if (!top.sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) { 672 /* schedule initial sym_filter_entry setup */ 673 sym_filter_entry_sched = syme; 674 sym_filter = NULL; 675 } 676 677 for (i = 0; skip_symbols[i]; i++) { 678 if (!strcmp(skip_symbols[i], name)) { 679 sym->ignore = true; 680 break; 681 } 682 } 683 684 return 0; 685 } 686 687 static void perf_event__process_sample(const union perf_event *event, 688 struct perf_sample *sample, 689 struct perf_session *session) 690 { 691 u64 ip = event->ip.ip; 692 struct sym_entry *syme; 693 struct addr_location al; 694 struct machine *machine; 695 u8 origin = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 696 697 ++top.samples; 698 699 switch (origin) { 700 case PERF_RECORD_MISC_USER: 701 ++top.us_samples; 702 if (top.hide_user_symbols) 703 return; 704 machine = perf_session__find_host_machine(session); 705 break; 706 case PERF_RECORD_MISC_KERNEL: 707 ++top.kernel_samples; 708 if (top.hide_kernel_symbols) 709 return; 710 machine = perf_session__find_host_machine(session); 711 break; 712 case PERF_RECORD_MISC_GUEST_KERNEL: 713 ++top.guest_kernel_samples; 714 machine = perf_session__find_machine(session, event->ip.pid); 715 break; 716 case PERF_RECORD_MISC_GUEST_USER: 717 ++top.guest_us_samples; 718 /* 719 * TODO: we don't process guest user from host side 720 * except simple counting. 721 */ 722 return; 723 default: 724 return; 725 } 726 727 if (!machine && perf_guest) { 728 pr_err("Can't find guest [%d]'s kernel information\n", 729 event->ip.pid); 730 return; 731 } 732 733 if (event->header.misc & PERF_RECORD_MISC_EXACT_IP) 734 top.exact_samples++; 735 736 if (perf_event__preprocess_sample(event, session, &al, sample, 737 symbol_filter) < 0 || 738 al.filtered) 739 return; 740 741 if (al.sym == NULL) { 742 /* 743 * As we do lazy loading of symtabs we only will know if the 744 * specified vmlinux file is invalid when we actually have a 745 * hit in kernel space and then try to load it. So if we get 746 * here and there are _no_ symbols in the DSO backing the 747 * kernel map, bail out. 748 * 749 * We may never get here, for instance, if we use -K/ 750 * --hide-kernel-symbols, even if the user specifies an 751 * invalid --vmlinux ;-) 752 */ 753 if (al.map == machine->vmlinux_maps[MAP__FUNCTION] && 754 RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 755 ui__warning("The %s file can't be used\n", 756 symbol_conf.vmlinux_name); 757 exit_browser(0); 758 exit(1); 759 } 760 761 return; 762 } 763 764 /* let's see, whether we need to install initial sym_filter_entry */ 765 if (sym_filter_entry_sched) { 766 top.sym_filter_entry = sym_filter_entry_sched; 767 sym_filter_entry_sched = NULL; 768 if (parse_source(top.sym_filter_entry) < 0) { 769 struct symbol *sym = sym_entry__symbol(top.sym_filter_entry); 770 771 pr_err("Can't annotate %s", sym->name); 772 if (top.sym_filter_entry->map->dso->symtab_type == SYMTAB__KALLSYMS) { 773 pr_err(": No vmlinux file was found in the path:\n"); 774 machine__fprintf_vmlinux_path(machine, stderr); 775 } else 776 pr_err(".\n"); 777 exit(1); 778 } 779 } 780 781 syme = symbol__priv(al.sym); 782 if (!al.sym->ignore) { 783 struct perf_evsel *evsel; 784 785 evsel = perf_evlist__id2evsel(top.evlist, sample->id); 786 assert(evsel != NULL); 787 syme->count[evsel->idx]++; 788 record_precise_ip(syme, evsel->idx, ip); 789 pthread_mutex_lock(&top.active_symbols_lock); 790 if (list_empty(&syme->node) || !syme->node.next) { 791 static bool first = true; 792 __list_insert_active_sym(syme); 793 if (first) { 794 pthread_cond_broadcast(&top.active_symbols_cond); 795 first = false; 796 } 797 } 798 pthread_mutex_unlock(&top.active_symbols_lock); 799 } 800 } 801 802 static void perf_session__mmap_read_cpu(struct perf_session *self, int cpu) 803 { 804 struct perf_sample sample; 805 union perf_event *event; 806 807 while ((event = perf_evlist__read_on_cpu(top.evlist, cpu)) != NULL) { 808 perf_session__parse_sample(self, event, &sample); 809 810 if (event->header.type == PERF_RECORD_SAMPLE) 811 perf_event__process_sample(event, &sample, self); 812 else 813 perf_event__process(event, &sample, self); 814 } 815 } 816 817 static void perf_session__mmap_read(struct perf_session *self) 818 { 819 int i; 820 821 for (i = 0; i < top.evlist->cpus->nr; i++) 822 perf_session__mmap_read_cpu(self, i); 823 } 824 825 static void start_counters(struct perf_evlist *evlist) 826 { 827 struct perf_evsel *counter; 828 829 list_for_each_entry(counter, &evlist->entries, node) { 830 struct perf_event_attr *attr = &counter->attr; 831 832 attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID; 833 834 if (top.freq) { 835 attr->sample_type |= PERF_SAMPLE_PERIOD; 836 attr->freq = 1; 837 attr->sample_freq = top.freq; 838 } 839 840 if (evlist->nr_entries > 1) { 841 attr->sample_type |= PERF_SAMPLE_ID; 842 attr->read_format |= PERF_FORMAT_ID; 843 } 844 845 attr->mmap = 1; 846 try_again: 847 if (perf_evsel__open(counter, top.evlist->cpus, 848 top.evlist->threads, group, inherit) < 0) { 849 int err = errno; 850 851 if (err == EPERM || err == EACCES) 852 die("Permission error - are you root?\n" 853 "\t Consider tweaking" 854 " /proc/sys/kernel/perf_event_paranoid.\n"); 855 /* 856 * If it's cycles then fall back to hrtimer 857 * based cpu-clock-tick sw counter, which 858 * is always available even if no PMU support: 859 */ 860 if (attr->type == PERF_TYPE_HARDWARE && 861 attr->config == PERF_COUNT_HW_CPU_CYCLES) { 862 863 if (verbose) 864 warning(" ... trying to fall back to cpu-clock-ticks\n"); 865 866 attr->type = PERF_TYPE_SOFTWARE; 867 attr->config = PERF_COUNT_SW_CPU_CLOCK; 868 goto try_again; 869 } 870 printf("\n"); 871 error("sys_perf_event_open() syscall returned with %d " 872 "(%s). /bin/dmesg may provide additional information.\n", 873 err, strerror(err)); 874 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n"); 875 exit(-1); 876 } 877 } 878 879 if (perf_evlist__mmap(evlist, mmap_pages, false) < 0) 880 die("failed to mmap with %d (%s)\n", errno, strerror(errno)); 881 } 882 883 static int __cmd_top(void) 884 { 885 pthread_t thread; 886 int ret __used; 887 /* 888 * FIXME: perf_session__new should allow passing a O_MMAP, so that all this 889 * mmap reading, etc is encapsulated in it. Use O_WRONLY for now. 890 */ 891 struct perf_session *session = perf_session__new(NULL, O_WRONLY, false, false, NULL); 892 if (session == NULL) 893 return -ENOMEM; 894 895 if (top.target_tid != -1) 896 perf_event__synthesize_thread_map(top.evlist->threads, 897 perf_event__process, session); 898 else 899 perf_event__synthesize_threads(perf_event__process, session); 900 901 start_counters(top.evlist); 902 session->evlist = top.evlist; 903 perf_session__update_sample_type(session); 904 905 /* Wait for a minimal set of events before starting the snapshot */ 906 poll(top.evlist->pollfd, top.evlist->nr_fds, 100); 907 908 perf_session__mmap_read(session); 909 910 if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui : 911 display_thread), session)) { 912 printf("Could not create display thread.\n"); 913 exit(-1); 914 } 915 916 if (realtime_prio) { 917 struct sched_param param; 918 919 param.sched_priority = realtime_prio; 920 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 921 printf("Could not set realtime priority.\n"); 922 exit(-1); 923 } 924 } 925 926 while (1) { 927 u64 hits = top.samples; 928 929 perf_session__mmap_read(session); 930 931 if (hits == top.samples) 932 ret = poll(top.evlist->pollfd, top.evlist->nr_fds, 100); 933 } 934 935 return 0; 936 } 937 938 static const char * const top_usage[] = { 939 "perf top [<options>]", 940 NULL 941 }; 942 943 static const struct option options[] = { 944 OPT_CALLBACK('e', "event", &top.evlist, "event", 945 "event selector. use 'perf list' to list available events", 946 parse_events), 947 OPT_INTEGER('c', "count", &default_interval, 948 "event period to sample"), 949 OPT_INTEGER('p', "pid", &top.target_pid, 950 "profile events on existing process id"), 951 OPT_INTEGER('t', "tid", &top.target_tid, 952 "profile events on existing thread id"), 953 OPT_BOOLEAN('a', "all-cpus", &system_wide, 954 "system-wide collection from all CPUs"), 955 OPT_STRING('C', "cpu", &top.cpu_list, "cpu", 956 "list of cpus to monitor"), 957 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 958 "file", "vmlinux pathname"), 959 OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols, 960 "hide kernel symbols"), 961 OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"), 962 OPT_INTEGER('r', "realtime", &realtime_prio, 963 "collect data with this RT SCHED_FIFO priority"), 964 OPT_INTEGER('d', "delay", &top.delay_secs, 965 "number of seconds to delay between refreshes"), 966 OPT_BOOLEAN('D', "dump-symtab", &dump_symtab, 967 "dump the symbol table used for profiling"), 968 OPT_INTEGER('f', "count-filter", &top.count_filter, 969 "only display functions with more events than this"), 970 OPT_BOOLEAN('g', "group", &group, 971 "put the counters into a counter group"), 972 OPT_BOOLEAN('i', "inherit", &inherit, 973 "child tasks inherit counters"), 974 OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name", 975 "symbol to annotate"), 976 OPT_BOOLEAN('z', "zero", &top.zero, 977 "zero history across updates"), 978 OPT_INTEGER('F', "freq", &top.freq, 979 "profile at this frequency"), 980 OPT_INTEGER('E', "entries", &top.print_entries, 981 "display this many functions"), 982 OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols, 983 "hide user symbols"), 984 OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"), 985 OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"), 986 OPT_INCR('v', "verbose", &verbose, 987 "be more verbose (show counter open errors, etc)"), 988 OPT_END() 989 }; 990 991 int cmd_top(int argc, const char **argv, const char *prefix __used) 992 { 993 struct perf_evsel *pos; 994 int status = -ENOMEM; 995 996 top.evlist = perf_evlist__new(NULL, NULL); 997 if (top.evlist == NULL) 998 return -ENOMEM; 999 1000 page_size = sysconf(_SC_PAGE_SIZE); 1001 1002 argc = parse_options(argc, argv, options, top_usage, 0); 1003 if (argc) 1004 usage_with_options(top_usage, options); 1005 1006 /* 1007 * XXX For now start disabled, only using TUI if explicitely asked for. 1008 * Change that when handle_keys equivalent gets written, live annotation 1009 * done, etc. 1010 */ 1011 use_browser = 0; 1012 1013 if (use_stdio) 1014 use_browser = 0; 1015 else if (use_tui) 1016 use_browser = 1; 1017 1018 setup_browser(false); 1019 1020 /* CPU and PID are mutually exclusive */ 1021 if (top.target_tid > 0 && top.cpu_list) { 1022 printf("WARNING: PID switch overriding CPU\n"); 1023 sleep(1); 1024 top.cpu_list = NULL; 1025 } 1026 1027 if (top.target_pid != -1) 1028 top.target_tid = top.target_pid; 1029 1030 if (perf_evlist__create_maps(top.evlist, top.target_pid, 1031 top.target_tid, top.cpu_list) < 0) 1032 usage_with_options(top_usage, options); 1033 1034 if (!top.evlist->nr_entries && 1035 perf_evlist__add_default(top.evlist) < 0) { 1036 pr_err("Not enough memory for event selector list\n"); 1037 return -ENOMEM; 1038 } 1039 1040 if (top.delay_secs < 1) 1041 top.delay_secs = 1; 1042 1043 /* 1044 * User specified count overrides default frequency. 1045 */ 1046 if (default_interval) 1047 top.freq = 0; 1048 else if (top.freq) { 1049 default_interval = top.freq; 1050 } else { 1051 fprintf(stderr, "frequency and count are zero, aborting\n"); 1052 exit(EXIT_FAILURE); 1053 } 1054 1055 list_for_each_entry(pos, &top.evlist->entries, node) { 1056 if (perf_evsel__alloc_fd(pos, top.evlist->cpus->nr, 1057 top.evlist->threads->nr) < 0) 1058 goto out_free_fd; 1059 /* 1060 * Fill in the ones not specifically initialized via -c: 1061 */ 1062 if (pos->attr.sample_period) 1063 continue; 1064 1065 pos->attr.sample_period = default_interval; 1066 } 1067 1068 if (perf_evlist__alloc_pollfd(top.evlist) < 0 || 1069 perf_evlist__alloc_mmap(top.evlist) < 0) 1070 goto out_free_fd; 1071 1072 top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node); 1073 1074 symbol_conf.priv_size = (sizeof(struct sym_entry) + sizeof(struct annotation) + 1075 (top.evlist->nr_entries + 1) * sizeof(unsigned long)); 1076 1077 symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 1078 if (symbol__init() < 0) 1079 return -1; 1080 1081 get_term_dimensions(&winsize); 1082 if (top.print_entries == 0) { 1083 update_print_entries(&winsize); 1084 signal(SIGWINCH, sig_winch_handler); 1085 } 1086 1087 status = __cmd_top(); 1088 out_free_fd: 1089 perf_evlist__delete(top.evlist); 1090 1091 return status; 1092 } 1093