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