Root/tools/perf/builtin-top.c

Source at commit ec7cab4cbb721bff91ec924ec691efd8daf36579 created 9 years 7 months ago.
By Maarten ter Huurne, MIPS: JZ4740: A320: Updated quickstart documentation.
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
67static 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
79static bool system_wide = false;
80
81static bool use_tui, use_stdio;
82
83static int default_interval = 0;
84
85static bool inherit = false;
86static int realtime_prio = 0;
87static bool group = false;
88static unsigned int page_size;
89static unsigned int mmap_pages = 128;
90
91static bool dump_symtab = false;
92
93static struct winsize winsize;
94
95static const char *sym_filter = NULL;
96struct sym_entry *sym_filter_entry_sched = NULL;
97static int sym_pcnt_filter = 5;
98
99/*
100 * Source functions
101 */
102
103void 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
125static 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
133static void sig_winch_handler(int sig __used)
134{
135    get_term_dimensions(&winsize);
136    update_print_entries(&winsize);
137}
138
139static 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(&notes->lock);
165        goto out_assign;
166    }
167
168    pthread_mutex_lock(&notes->lock);
169
170    if (symbol__alloc_hist(sym, top.evlist->nr_entries) < 0) {
171        pthread_mutex_unlock(&notes->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) {
180out_assign:
181        top.sym_filter_entry = syme;
182    }
183
184    pthread_mutex_unlock(&notes->lock);
185    return err;
186}
187
188static 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
194static 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(&notes->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(&notes->lock);
212}
213
214static 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(&notes->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);
242out_unlock:
243    pthread_mutex_unlock(&notes->lock);
244}
245
246static const char CONSOLE_CLEAR[] = "";
247
248static void __list_insert_active_sym(struct sym_entry *syme)
249{
250    list_add(&syme->node, &top.active_symbols);
251}
252
253static 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
338static 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;
360out_free:
361    free(buf);
362}
363
364static 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
373static 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
413out_free:
414    free(buf);
415}
416
417static 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
452static 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
477static 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                /* Select 0 as the default event: */
519                int counter = 0;
520
521                fprintf(stderr, "\nAvailable events:");
522
523                list_for_each_entry(top.sym_evsel, &top.evlist->entries, node)
524                    fprintf(stderr, "\n\t%d %s", top.sym_evsel->idx, event_name(top.sym_evsel));
525
526                prompt_integer(&counter, "Enter details event counter");
527
528                if (counter >= top.evlist->nr_entries) {
529                    top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node);
530                    fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(top.sym_evsel));
531                    sleep(1);
532                    break;
533                }
534                list_for_each_entry(top.sym_evsel, &top.evlist->entries, node)
535                    if (top.sym_evsel->idx == counter)
536                        break;
537            } else
538                top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node);
539            break;
540        case 'f':
541            prompt_integer(&top.count_filter, "Enter display event count filter");
542            break;
543        case 'F':
544            prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)");
545            break;
546        case 'K':
547            top.hide_kernel_symbols = !top.hide_kernel_symbols;
548            break;
549        case 'q':
550        case 'Q':
551            printf("exiting.\n");
552            if (dump_symtab)
553                perf_session__fprintf_dsos(session, stderr);
554            exit(0);
555        case 's':
556            prompt_symbol(&top.sym_filter_entry, "Enter details symbol");
557            break;
558        case 'S':
559            if (!top.sym_filter_entry)
560                break;
561            else {
562                struct sym_entry *syme = top.sym_filter_entry;
563
564                top.sym_filter_entry = NULL;
565                __zero_source_counters(syme);
566            }
567            break;
568        case 'U':
569            top.hide_user_symbols = !top.hide_user_symbols;
570            break;
571        case 'w':
572            top.display_weighted = ~top.display_weighted;
573            break;
574        case 'z':
575            top.zero = !top.zero;
576            break;
577        default:
578            break;
579    }
580}
581
582static void *display_thread_tui(void *arg __used)
583{
584    int err = 0;
585    pthread_mutex_lock(&top.active_symbols_lock);
586    while (list_empty(&top.active_symbols)) {
587        err = pthread_cond_wait(&top.active_symbols_cond,
588                    &top.active_symbols_lock);
589        if (err)
590            break;
591    }
592    pthread_mutex_unlock(&top.active_symbols_lock);
593    if (!err)
594        perf_top__tui_browser(&top);
595    exit_browser(0);
596    exit(0);
597    return NULL;
598}
599
600static void *display_thread(void *arg __used)
601{
602    struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
603    struct termios tc, save;
604    int delay_msecs, c;
605    struct perf_session *session = (struct perf_session *) arg;
606
607    tcgetattr(0, &save);
608    tc = save;
609    tc.c_lflag &= ~(ICANON | ECHO);
610    tc.c_cc[VMIN] = 0;
611    tc.c_cc[VTIME] = 0;
612
613repeat:
614    delay_msecs = top.delay_secs * 1000;
615    tcsetattr(0, TCSANOW, &tc);
616    /* trash return*/
617    getc(stdin);
618
619    do {
620        print_sym_table(session);
621    } while (!poll(&stdin_poll, 1, delay_msecs) == 1);
622
623    c = getc(stdin);
624    tcsetattr(0, TCSAFLUSH, &save);
625
626    handle_keypress(session, c);
627    goto repeat;
628
629    return NULL;
630}
631
632/* Tag samples to be skipped. */
633static const char *skip_symbols[] = {
634    "default_idle",
635    "native_safe_halt",
636    "cpu_idle",
637    "enter_idle",
638    "exit_idle",
639    "mwait_idle",
640    "mwait_idle_with_hints",
641    "poll_idle",
642    "ppc64_runlatch_off",
643    "pseries_dedicated_idle_sleep",
644    NULL
645};
646
647static int symbol_filter(struct map *map, struct symbol *sym)
648{
649    struct sym_entry *syme;
650    const char *name = sym->name;
651    int i;
652
653    /*
654     * ppc64 uses function descriptors and appends a '.' to the
655     * start of every instruction address. Remove it.
656     */
657    if (name[0] == '.')
658        name++;
659
660    if (!strcmp(name, "_text") ||
661        !strcmp(name, "_etext") ||
662        !strcmp(name, "_sinittext") ||
663        !strncmp("init_module", name, 11) ||
664        !strncmp("cleanup_module", name, 14) ||
665        strstr(name, "_text_start") ||
666        strstr(name, "_text_end"))
667        return 1;
668
669    syme = symbol__priv(sym);
670    syme->map = map;
671    symbol__annotate_init(map, sym);
672
673    if (!top.sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) {
674        /* schedule initial sym_filter_entry setup */
675        sym_filter_entry_sched = syme;
676        sym_filter = NULL;
677    }
678
679    for (i = 0; skip_symbols[i]; i++) {
680        if (!strcmp(skip_symbols[i], name)) {
681            sym->ignore = true;
682            break;
683        }
684    }
685
686    return 0;
687}
688
689static void perf_event__process_sample(const union perf_event *event,
690                       struct perf_sample *sample,
691                       struct perf_session *session)
692{
693    u64 ip = event->ip.ip;
694    struct sym_entry *syme;
695    struct addr_location al;
696    struct machine *machine;
697    u8 origin = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
698
699    ++top.samples;
700
701    switch (origin) {
702    case PERF_RECORD_MISC_USER:
703        ++top.us_samples;
704        if (top.hide_user_symbols)
705            return;
706        machine = perf_session__find_host_machine(session);
707        break;
708    case PERF_RECORD_MISC_KERNEL:
709        ++top.kernel_samples;
710        if (top.hide_kernel_symbols)
711            return;
712        machine = perf_session__find_host_machine(session);
713        break;
714    case PERF_RECORD_MISC_GUEST_KERNEL:
715        ++top.guest_kernel_samples;
716        machine = perf_session__find_machine(session, event->ip.pid);
717        break;
718    case PERF_RECORD_MISC_GUEST_USER:
719        ++top.guest_us_samples;
720        /*
721         * TODO: we don't process guest user from host side
722         * except simple counting.
723         */
724        return;
725    default:
726        return;
727    }
728
729    if (!machine && perf_guest) {
730        pr_err("Can't find guest [%d]'s kernel information\n",
731            event->ip.pid);
732        return;
733    }
734
735    if (event->header.misc & PERF_RECORD_MISC_EXACT_IP)
736        top.exact_samples++;
737
738    if (perf_event__preprocess_sample(event, session, &al, sample,
739                      symbol_filter) < 0 ||
740        al.filtered)
741        return;
742
743    if (al.sym == NULL) {
744        /*
745         * As we do lazy loading of symtabs we only will know if the
746         * specified vmlinux file is invalid when we actually have a
747         * hit in kernel space and then try to load it. So if we get
748         * here and there are _no_ symbols in the DSO backing the
749         * kernel map, bail out.
750         *
751         * We may never get here, for instance, if we use -K/
752         * --hide-kernel-symbols, even if the user specifies an
753         * invalid --vmlinux ;-)
754         */
755        if (al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
756            RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
757            ui__warning("The %s file can't be used\n",
758                    symbol_conf.vmlinux_name);
759            exit_browser(0);
760            exit(1);
761        }
762
763        return;
764    }
765
766    /* let's see, whether we need to install initial sym_filter_entry */
767    if (sym_filter_entry_sched) {
768        top.sym_filter_entry = sym_filter_entry_sched;
769        sym_filter_entry_sched = NULL;
770        if (parse_source(top.sym_filter_entry) < 0) {
771            struct symbol *sym = sym_entry__symbol(top.sym_filter_entry);
772
773            pr_err("Can't annotate %s", sym->name);
774            if (top.sym_filter_entry->map->dso->symtab_type == SYMTAB__KALLSYMS) {
775                pr_err(": No vmlinux file was found in the path:\n");
776                machine__fprintf_vmlinux_path(machine, stderr);
777            } else
778                pr_err(".\n");
779            exit(1);
780        }
781    }
782
783    syme = symbol__priv(al.sym);
784    if (!al.sym->ignore) {
785        struct perf_evsel *evsel;
786
787        evsel = perf_evlist__id2evsel(top.evlist, sample->id);
788        assert(evsel != NULL);
789        syme->count[evsel->idx]++;
790        record_precise_ip(syme, evsel->idx, ip);
791        pthread_mutex_lock(&top.active_symbols_lock);
792        if (list_empty(&syme->node) || !syme->node.next) {
793            static bool first = true;
794            __list_insert_active_sym(syme);
795            if (first) {
796                pthread_cond_broadcast(&top.active_symbols_cond);
797                first = false;
798            }
799        }
800        pthread_mutex_unlock(&top.active_symbols_lock);
801    }
802}
803
804static void perf_session__mmap_read_idx(struct perf_session *self, int idx)
805{
806    struct perf_sample sample;
807    union perf_event *event;
808
809    while ((event = perf_evlist__mmap_read(top.evlist, idx)) != NULL) {
810        perf_session__parse_sample(self, event, &sample);
811
812        if (event->header.type == PERF_RECORD_SAMPLE)
813            perf_event__process_sample(event, &sample, self);
814        else
815            perf_event__process(event, &sample, self);
816    }
817}
818
819static void perf_session__mmap_read(struct perf_session *self)
820{
821    int i;
822
823    for (i = 0; i < top.evlist->nr_mmaps; i++)
824        perf_session__mmap_read_idx(self, i);
825}
826
827static void start_counters(struct perf_evlist *evlist)
828{
829    struct perf_evsel *counter;
830
831    list_for_each_entry(counter, &evlist->entries, node) {
832        struct perf_event_attr *attr = &counter->attr;
833
834        attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
835
836        if (top.freq) {
837            attr->sample_type |= PERF_SAMPLE_PERIOD;
838            attr->freq = 1;
839            attr->sample_freq = top.freq;
840        }
841
842        if (evlist->nr_entries > 1) {
843            attr->sample_type |= PERF_SAMPLE_ID;
844            attr->read_format |= PERF_FORMAT_ID;
845        }
846
847        attr->mmap = 1;
848        attr->inherit = inherit;
849try_again:
850        if (perf_evsel__open(counter, top.evlist->cpus,
851                     top.evlist->threads, group) < 0) {
852            int err = errno;
853
854            if (err == EPERM || err == EACCES) {
855                ui__warning_paranoid();
856                goto out_err;
857            }
858            /*
859             * If it's cycles then fall back to hrtimer
860             * based cpu-clock-tick sw counter, which
861             * is always available even if no PMU support:
862             */
863            if (attr->type == PERF_TYPE_HARDWARE &&
864                attr->config == PERF_COUNT_HW_CPU_CYCLES) {
865                if (verbose)
866                    ui__warning("Cycles event not supported,\n"
867                            "trying to fall back to cpu-clock-ticks\n");
868
869                attr->type = PERF_TYPE_SOFTWARE;
870                attr->config = PERF_COUNT_SW_CPU_CLOCK;
871                goto try_again;
872            }
873
874            if (err == ENOENT) {
875                ui__warning("The %s event is not supported.\n",
876                        event_name(counter));
877                goto out_err;
878            }
879
880            ui__warning("The sys_perf_event_open() syscall "
881                    "returned with %d (%s). /bin/dmesg "
882                    "may provide additional information.\n"
883                    "No CONFIG_PERF_EVENTS=y kernel support "
884                    "configured?\n", err, strerror(err));
885            goto out_err;
886        }
887    }
888
889    if (perf_evlist__mmap(evlist, mmap_pages, false) < 0) {
890        ui__warning("Failed to mmap with %d (%s)\n",
891                errno, strerror(errno));
892        goto out_err;
893    }
894
895    return;
896
897out_err:
898    exit_browser(0);
899    exit(0);
900}
901
902static int __cmd_top(void)
903{
904    pthread_t thread;
905    int ret __used;
906    /*
907     * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
908     * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
909     */
910    struct perf_session *session = perf_session__new(NULL, O_WRONLY, false, false, NULL);
911    if (session == NULL)
912        return -ENOMEM;
913
914    if (top.target_tid != -1)
915        perf_event__synthesize_thread_map(top.evlist->threads,
916                          perf_event__process, session);
917    else
918        perf_event__synthesize_threads(perf_event__process, session);
919
920    start_counters(top.evlist);
921    session->evlist = top.evlist;
922    perf_session__update_sample_type(session);
923
924    /* Wait for a minimal set of events before starting the snapshot */
925    poll(top.evlist->pollfd, top.evlist->nr_fds, 100);
926
927    perf_session__mmap_read(session);
928
929    if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
930                                 display_thread), session)) {
931        printf("Could not create display thread.\n");
932        exit(-1);
933    }
934
935    if (realtime_prio) {
936        struct sched_param param;
937
938        param.sched_priority = realtime_prio;
939        if (sched_setscheduler(0, SCHED_FIFO, &param)) {
940            printf("Could not set realtime priority.\n");
941            exit(-1);
942        }
943    }
944
945    while (1) {
946        u64 hits = top.samples;
947
948        perf_session__mmap_read(session);
949
950        if (hits == top.samples)
951            ret = poll(top.evlist->pollfd, top.evlist->nr_fds, 100);
952    }
953
954    return 0;
955}
956
957static const char * const top_usage[] = {
958    "perf top [<options>]",
959    NULL
960};
961
962static const struct option options[] = {
963    OPT_CALLBACK('e', "event", &top.evlist, "event",
964             "event selector. use 'perf list' to list available events",
965             parse_events),
966    OPT_INTEGER('c', "count", &default_interval,
967            "event period to sample"),
968    OPT_INTEGER('p', "pid", &top.target_pid,
969            "profile events on existing process id"),
970    OPT_INTEGER('t', "tid", &top.target_tid,
971            "profile events on existing thread id"),
972    OPT_BOOLEAN('a', "all-cpus", &system_wide,
973                "system-wide collection from all CPUs"),
974    OPT_STRING('C', "cpu", &top.cpu_list, "cpu",
975            "list of cpus to monitor"),
976    OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
977           "file", "vmlinux pathname"),
978    OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols,
979            "hide kernel symbols"),
980    OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
981    OPT_INTEGER('r', "realtime", &realtime_prio,
982            "collect data with this RT SCHED_FIFO priority"),
983    OPT_INTEGER('d', "delay", &top.delay_secs,
984            "number of seconds to delay between refreshes"),
985    OPT_BOOLEAN('D', "dump-symtab", &dump_symtab,
986                "dump the symbol table used for profiling"),
987    OPT_INTEGER('f', "count-filter", &top.count_filter,
988            "only display functions with more events than this"),
989    OPT_BOOLEAN('g', "group", &group,
990                "put the counters into a counter group"),
991    OPT_BOOLEAN('i', "inherit", &inherit,
992            "child tasks inherit counters"),
993    OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name",
994            "symbol to annotate"),
995    OPT_BOOLEAN('z', "zero", &top.zero,
996            "zero history across updates"),
997    OPT_INTEGER('F', "freq", &top.freq,
998            "profile at this frequency"),
999    OPT_INTEGER('E', "entries", &top.print_entries,
1000            "display this many functions"),
1001    OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols,
1002            "hide user symbols"),
1003    OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"),
1004    OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
1005    OPT_INCR('v', "verbose", &verbose,
1006            "be more verbose (show counter open errors, etc)"),
1007    OPT_END()
1008};
1009
1010int cmd_top(int argc, const char **argv, const char *prefix __used)
1011{
1012    struct perf_evsel *pos;
1013    int status = -ENOMEM;
1014
1015    top.evlist = perf_evlist__new(NULL, NULL);
1016    if (top.evlist == NULL)
1017        return -ENOMEM;
1018
1019    page_size = sysconf(_SC_PAGE_SIZE);
1020
1021    argc = parse_options(argc, argv, options, top_usage, 0);
1022    if (argc)
1023        usage_with_options(top_usage, options);
1024
1025    /*
1026      * XXX For now start disabled, only using TUI if explicitely asked for.
1027      * Change that when handle_keys equivalent gets written, live annotation
1028      * done, etc.
1029      */
1030    use_browser = 0;
1031
1032    if (use_stdio)
1033        use_browser = 0;
1034    else if (use_tui)
1035        use_browser = 1;
1036
1037    setup_browser(false);
1038
1039    /* CPU and PID are mutually exclusive */
1040    if (top.target_tid > 0 && top.cpu_list) {
1041        printf("WARNING: PID switch overriding CPU\n");
1042        sleep(1);
1043        top.cpu_list = NULL;
1044    }
1045
1046    if (top.target_pid != -1)
1047        top.target_tid = top.target_pid;
1048
1049    if (perf_evlist__create_maps(top.evlist, top.target_pid,
1050                     top.target_tid, top.cpu_list) < 0)
1051        usage_with_options(top_usage, options);
1052
1053    if (!top.evlist->nr_entries &&
1054        perf_evlist__add_default(top.evlist) < 0) {
1055        pr_err("Not enough memory for event selector list\n");
1056        return -ENOMEM;
1057    }
1058
1059    if (top.delay_secs < 1)
1060        top.delay_secs = 1;
1061
1062    /*
1063     * User specified count overrides default frequency.
1064     */
1065    if (default_interval)
1066        top.freq = 0;
1067    else if (top.freq) {
1068        default_interval = top.freq;
1069    } else {
1070        fprintf(stderr, "frequency and count are zero, aborting\n");
1071        exit(EXIT_FAILURE);
1072    }
1073
1074    list_for_each_entry(pos, &top.evlist->entries, node) {
1075        if (perf_evsel__alloc_fd(pos, top.evlist->cpus->nr,
1076                     top.evlist->threads->nr) < 0)
1077            goto out_free_fd;
1078        /*
1079         * Fill in the ones not specifically initialized via -c:
1080         */
1081        if (pos->attr.sample_period)
1082            continue;
1083
1084        pos->attr.sample_period = default_interval;
1085    }
1086
1087    if (perf_evlist__alloc_pollfd(top.evlist) < 0 ||
1088        perf_evlist__alloc_mmap(top.evlist) < 0)
1089        goto out_free_fd;
1090
1091    top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node);
1092
1093    symbol_conf.priv_size = (sizeof(struct sym_entry) + sizeof(struct annotation) +
1094                 (top.evlist->nr_entries + 1) * sizeof(unsigned long));
1095
1096    symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
1097    if (symbol__init() < 0)
1098        return -1;
1099
1100    get_term_dimensions(&winsize);
1101    if (top.print_entries == 0) {
1102        update_print_entries(&winsize);
1103        signal(SIGWINCH, sig_winch_handler);
1104    }
1105
1106    status = __cmd_top();
1107out_free_fd:
1108    perf_evlist__delete(top.evlist);
1109
1110    return status;
1111}
1112

Archive Download this file



interactive