Linux Perf
builtin-top.c
Go to the documentation of this file.
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/config.h"
26 #include "util/color.h"
27 #include "util/drv_configs.h"
28 #include "util/evlist.h"
29 #include "util/evsel.h"
30 #include "util/event.h"
31 #include "util/machine.h"
32 #include "util/session.h"
33 #include "util/symbol.h"
34 #include "util/thread.h"
35 #include "util/thread_map.h"
36 #include "util/top.h"
37 #include <linux/rbtree.h>
38 #include <subcmd/parse-options.h>
39 #include "util/parse-events.h"
40 #include "util/cpumap.h"
41 #include "util/xyarray.h"
42 #include "util/sort.h"
43 #include "util/term.h"
44 #include "util/intlist.h"
46 #include "arch/common.h"
47 
48 #include "util/debug.h"
49 
50 #include <assert.h>
51 #include <elf.h>
52 #include <fcntl.h>
53 
54 #include <stdio.h>
55 #include <termios.h>
56 #include <unistd.h>
57 #include <inttypes.h>
58 
59 #include <errno.h>
60 #include <time.h>
61 #include <sched.h>
62 #include <signal.h>
63 
64 #include <sys/syscall.h>
65 #include <sys/ioctl.h>
66 #include <poll.h>
67 #include <sys/prctl.h>
68 #include <sys/wait.h>
69 #include <sys/uio.h>
70 #include <sys/utsname.h>
71 #include <sys/mman.h>
72 
73 #include <linux/stringify.h>
74 #include <linux/time64.h>
75 #include <linux/types.h>
76 
77 #include "sane_ctype.h"
78 
79 static volatile int done;
80 static volatile int resize;
81 
82 #define HEADER_LINE_NR 5
83 
84 static void perf_top__update_print_entries(struct perf_top *top)
85 {
86  top->print_entries = top->winsize.ws_row - HEADER_LINE_NR;
87 }
88 
89 static void winch_sig(int sig __maybe_unused)
90 {
91  resize = 1;
92 }
93 
94 static void perf_top__resize(struct perf_top *top)
95 {
98 }
99 
100 static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
101 {
102  struct perf_evsel *evsel = hists_to_evsel(he->hists);
103  struct symbol *sym;
104  struct annotation *notes;
105  struct map *map;
106  int err = -1;
107 
108  if (!he || !he->ms.sym)
109  return -1;
110 
111  sym = he->ms.sym;
112  map = he->ms.map;
113 
114  /*
115  * We can't annotate with just /proc/kallsyms
116  */
118  !dso__is_kcore(map->dso)) {
119  pr_err("Can't annotate %s: No vmlinux file was found in the "
120  "path\n", sym->name);
121  sleep(1);
122  return -1;
123  }
124 
125  notes = symbol__annotation(sym);
126  pthread_mutex_lock(&notes->lock);
127 
128  if (!symbol__hists(sym, top->evlist->nr_entries)) {
129  pthread_mutex_unlock(&notes->lock);
130  pr_err("Not enough memory for annotating '%s' symbol!\n",
131  sym->name);
132  sleep(1);
133  return err;
134  }
135 
136  err = symbol__annotate(sym, map, evsel, 0, &top->annotation_opts, NULL);
137  if (err == 0) {
138  top->sym_filter_entry = he;
139  } else {
140  char msg[BUFSIZ];
141  symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
142  pr_err("Couldn't annotate %s: %s\n", sym->name, msg);
143  }
144 
145  pthread_mutex_unlock(&notes->lock);
146  return err;
147 }
148 
149 static void __zero_source_counters(struct hist_entry *he)
150 {
151  struct symbol *sym = he->ms.sym;
153 }
154 
155 static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip)
156 {
157  struct utsname uts;
158  int err = uname(&uts);
159 
160  ui__warning("Out of bounds address found:\n\n"
161  "Addr: %" PRIx64 "\n"
162  "DSO: %s %c\n"
163  "Map: %" PRIx64 "-%" PRIx64 "\n"
164  "Symbol: %" PRIx64 "-%" PRIx64 " %c %s\n"
165  "Arch: %s\n"
166  "Kernel: %s\n"
167  "Tools: %s\n\n"
168  "Not all samples will be on the annotation output.\n\n"
169  "Please report to linux-kernel@vger.kernel.org\n",
170  ip, map->dso->long_name, dso__symtab_origin(map->dso),
171  map->start, map->end, sym->start, sym->end,
172  sym->binding == STB_GLOBAL ? 'g' :
173  sym->binding == STB_LOCAL ? 'l' : 'w', sym->name,
174  err ? "[unknown]" : uts.machine,
175  err ? "[unknown]" : uts.release, perf_version_string);
176  if (use_browser <= 0)
177  sleep(5);
178 
179  map->erange_warned = true;
180 }
181 
182 static void perf_top__record_precise_ip(struct perf_top *top,
183  struct hist_entry *he,
184  struct perf_sample *sample,
185  struct perf_evsel *evsel, u64 ip)
186 {
187  struct annotation *notes;
188  struct symbol *sym = he->ms.sym;
189  int err = 0;
190 
191  if (sym == NULL || (use_browser == 0 &&
192  (top->sym_filter_entry == NULL ||
193  top->sym_filter_entry->ms.sym != sym)))
194  return;
195 
196  notes = symbol__annotation(sym);
197 
198  if (pthread_mutex_trylock(&notes->lock))
199  return;
200 
201  err = hist_entry__inc_addr_samples(he, sample, evsel, ip);
202 
203  pthread_mutex_unlock(&notes->lock);
204 
205  if (unlikely(err)) {
206  /*
207  * This function is now called with he->hists->lock held.
208  * Release it before going to sleep.
209  */
210  pthread_mutex_unlock(&he->hists->lock);
211 
212  if (err == -ERANGE && !he->ms.map->erange_warned)
213  ui__warn_map_erange(he->ms.map, sym, ip);
214  else if (err == -ENOMEM) {
215  pr_err("Not enough memory for annotating '%s' symbol!\n",
216  sym->name);
217  sleep(1);
218  }
219 
220  pthread_mutex_lock(&he->hists->lock);
221  }
222 }
223 
224 static void perf_top__show_details(struct perf_top *top)
225 {
226  struct hist_entry *he = top->sym_filter_entry;
227  struct perf_evsel *evsel = hists_to_evsel(he->hists);
228  struct annotation *notes;
229  struct symbol *symbol;
230  int more;
231 
232  if (!he)
233  return;
234 
235  symbol = he->ms.sym;
236  notes = symbol__annotation(symbol);
237 
238  pthread_mutex_lock(&notes->lock);
239 
240  symbol__calc_percent(symbol, evsel);
241 
242  if (notes->src == NULL)
243  goto out_unlock;
244 
245  printf("Showing %s for %s\n", perf_evsel__name(top->sym_evsel), symbol->name);
246  printf(" Events Pcnt (>=%d%%)\n", top->annotation_opts.min_pcnt);
247 
248  more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel, &top->annotation_opts);
249 
250  if (top->evlist->enabled) {
251  if (top->zero)
253  else
255  }
256  if (more != 0)
257  printf("%d lines not displayed, maybe increase display entries [e]\n", more);
258 out_unlock:
259  pthread_mutex_unlock(&notes->lock);
260 }
261 
262 static void perf_top__print_sym_table(struct perf_top *top)
263 {
264  char bf[160];
265  int printed = 0;
266  const int win_width = top->winsize.ws_col - 1;
267  struct perf_evsel *evsel = top->sym_evsel;
268  struct hists *hists = evsel__hists(evsel);
269 
270  puts(CONSOLE_CLEAR);
271 
272  perf_top__header_snprintf(top, bf, sizeof(bf));
273  printf("%s\n", bf);
274 
276 
277  printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
278 
279  if (!top->record_opts.overwrite &&
280  (hists->stats.nr_lost_warned !=
281  hists->stats.nr_events[PERF_RECORD_LOST])) {
282  hists->stats.nr_lost_warned =
283  hists->stats.nr_events[PERF_RECORD_LOST];
285  "WARNING: LOST %d chunks, Check IO/CPU overload",
286  hists->stats.nr_lost_warned);
287  ++printed;
288  }
289 
290  if (top->sym_filter_entry) {
292  return;
293  }
294 
295  if (top->evlist->enabled) {
296  if (top->zero) {
297  hists__delete_entries(hists);
298  } else {
300  top->hide_kernel_symbols);
301  }
302  }
303 
304  hists__collapse_resort(hists, NULL);
305  perf_evsel__output_resort(evsel, NULL);
306 
307  hists__output_recalc_col_len(hists, top->print_entries - printed);
308  putchar('\n');
309  hists__fprintf(hists, false, top->print_entries - printed, win_width,
310  top->min_percent, stdout, symbol_conf.use_callchain);
311 }
312 
313 static void prompt_integer(int *target, const char *msg)
314 {
315  char *buf = malloc(0), *p;
316  size_t dummy = 0;
317  int tmp;
318 
319  fprintf(stdout, "\n%s: ", msg);
320  if (getline(&buf, &dummy, stdin) < 0)
321  return;
322 
323  p = strchr(buf, '\n');
324  if (p)
325  *p = 0;
326 
327  p = buf;
328  while(*p) {
329  if (!isdigit(*p))
330  goto out_free;
331  p++;
332  }
333  tmp = strtoul(buf, NULL, 10);
334  *target = tmp;
335 out_free:
336  free(buf);
337 }
338 
339 static void prompt_percent(int *target, const char *msg)
340 {
341  int tmp = 0;
342 
343  prompt_integer(&tmp, msg);
344  if (tmp >= 0 && tmp <= 100)
345  *target = tmp;
346 }
347 
348 static void perf_top__prompt_symbol(struct perf_top *top, const char *msg)
349 {
350  char *buf = malloc(0), *p;
351  struct hist_entry *syme = top->sym_filter_entry, *n, *found = NULL;
352  struct hists *hists = evsel__hists(top->sym_evsel);
353  struct rb_node *next;
354  size_t dummy = 0;
355 
356  /* zero counters of active symbol */
357  if (syme) {
359  top->sym_filter_entry = NULL;
360  }
361 
362  fprintf(stdout, "\n%s: ", msg);
363  if (getline(&buf, &dummy, stdin) < 0)
364  goto out_free;
365 
366  p = strchr(buf, '\n');
367  if (p)
368  *p = 0;
369 
370  next = rb_first(&hists->entries);
371  while (next) {
372  n = rb_entry(next, struct hist_entry, rb_node);
373  if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) {
374  found = n;
375  break;
376  }
377  next = rb_next(&n->rb_node);
378  }
379 
380  if (!found) {
381  fprintf(stderr, "Sorry, %s is not active.\n", buf);
382  sleep(1);
383  } else
384  perf_top__parse_source(top, found);
385 
386 out_free:
387  free(buf);
388 }
389 
390 static void perf_top__print_mapped_keys(struct perf_top *top)
391 {
392  char *name = NULL;
393 
394  if (top->sym_filter_entry) {
395  struct symbol *sym = top->sym_filter_entry->ms.sym;
396  name = sym->name;
397  }
398 
399  fprintf(stdout, "\nMapped keys:\n");
400  fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", top->delay_secs);
401  fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", top->print_entries);
402 
403  if (top->evlist->nr_entries > 1)
404  fprintf(stdout, "\t[E] active event counter. \t(%s)\n", perf_evsel__name(top->sym_evsel));
405 
406  fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", top->count_filter);
407 
408  fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", top->annotation_opts.min_pcnt);
409  fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL");
410  fprintf(stdout, "\t[S] stop annotation.\n");
411 
412  fprintf(stdout,
413  "\t[K] hide kernel symbols. \t(%s)\n",
414  top->hide_kernel_symbols ? "yes" : "no");
415  fprintf(stdout,
416  "\t[U] hide user symbols. \t(%s)\n",
417  top->hide_user_symbols ? "yes" : "no");
418  fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", top->zero ? 1 : 0);
419  fprintf(stdout, "\t[qQ] quit.\n");
420 }
421 
422 static int perf_top__key_mapped(struct perf_top *top, int c)
423 {
424  switch (c) {
425  case 'd':
426  case 'e':
427  case 'f':
428  case 'z':
429  case 'q':
430  case 'Q':
431  case 'K':
432  case 'U':
433  case 'F':
434  case 's':
435  case 'S':
436  return 1;
437  case 'E':
438  return top->evlist->nr_entries > 1 ? 1 : 0;
439  default:
440  break;
441  }
442 
443  return 0;
444 }
445 
446 static bool perf_top__handle_keypress(struct perf_top *top, int c)
447 {
448  bool ret = true;
449 
450  if (!perf_top__key_mapped(top, c)) {
451  struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
452  struct termios save;
453 
455  fprintf(stdout, "\nEnter selection, or unmapped key to continue: ");
456  fflush(stdout);
457 
458  set_term_quiet_input(&save);
459 
460  poll(&stdin_poll, 1, -1);
461  c = getc(stdin);
462 
463  tcsetattr(0, TCSAFLUSH, &save);
464  if (!perf_top__key_mapped(top, c))
465  return ret;
466  }
467 
468  switch (c) {
469  case 'd':
470  prompt_integer(&top->delay_secs, "Enter display delay");
471  if (top->delay_secs < 1)
472  top->delay_secs = 1;
473  break;
474  case 'e':
475  prompt_integer(&top->print_entries, "Enter display entries (lines)");
476  if (top->print_entries == 0) {
477  perf_top__resize(top);
478  signal(SIGWINCH, winch_sig);
479  } else {
480  signal(SIGWINCH, SIG_DFL);
481  }
482  break;
483  case 'E':
484  if (top->evlist->nr_entries > 1) {
485  /* Select 0 as the default event: */
486  int counter = 0;
487 
488  fprintf(stderr, "\nAvailable events:");
489 
491  fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel));
492 
493  prompt_integer(&counter, "Enter details event counter");
494 
495  if (counter >= top->evlist->nr_entries) {
496  top->sym_evsel = perf_evlist__first(top->evlist);
497  fprintf(stderr, "Sorry, no such event, using %s.\n", perf_evsel__name(top->sym_evsel));
498  sleep(1);
499  break;
500  }
502  if (top->sym_evsel->idx == counter)
503  break;
504  } else
505  top->sym_evsel = perf_evlist__first(top->evlist);
506  break;
507  case 'f':
508  prompt_integer(&top->count_filter, "Enter display event count filter");
509  break;
510  case 'F':
512  "Enter details display event filter (percent)");
513  break;
514  case 'K':
516  break;
517  case 'q':
518  case 'Q':
519  printf("exiting.\n");
520  if (top->dump_symtab)
521  perf_session__fprintf_dsos(top->session, stderr);
522  ret = false;
523  break;
524  case 's':
525  perf_top__prompt_symbol(top, "Enter details symbol");
526  break;
527  case 'S':
528  if (!top->sym_filter_entry)
529  break;
530  else {
531  struct hist_entry *syme = top->sym_filter_entry;
532 
533  top->sym_filter_entry = NULL;
535  }
536  break;
537  case 'U':
539  break;
540  case 'z':
541  top->zero = !top->zero;
542  break;
543  default:
544  break;
545  }
546 
547  return ret;
548 }
549 
550 static void perf_top__sort_new_samples(void *arg)
551 {
552  struct perf_top *t = arg;
553  struct perf_evsel *evsel = t->sym_evsel;
554  struct hists *hists;
555 
557 
558  if (t->evlist->selected != NULL)
559  t->sym_evsel = t->evlist->selected;
560 
561  hists = evsel__hists(evsel);
562 
563  if (t->evlist->enabled) {
564  if (t->zero) {
565  hists__delete_entries(hists);
566  } else {
569  }
570  }
571 
572  hists__collapse_resort(hists, NULL);
573  perf_evsel__output_resort(evsel, NULL);
574 }
575 
576 static void *display_thread_tui(void *arg)
577 {
578  struct perf_evsel *pos;
579  struct perf_top *top = arg;
580  const char *help = "For a higher level overview, try: perf top --sort comm,dso";
581  struct hist_browser_timer hbt = {
583  .arg = top,
584  .refresh = top->delay_secs,
585  };
586 
587  /* In order to read symbols from other namespaces perf to needs to call
588  * setns(2). This isn't permitted if the struct_fs has multiple users.
589  * unshare(2) the fs so that we may continue to setns into namespaces
590  * that we're observing.
591  */
592  unshare(CLONE_FS);
593 
595 
596  /*
597  * Initialize the uid_filter_str, in the future the TUI will allow
598  * Zooming in/out UIDs. For now juse use whatever the user passed
599  * via --uid.
600  */
601  evlist__for_each_entry(top->evlist, pos) {
602  struct hists *hists = evsel__hists(pos);
604  }
605 
606  perf_evlist__tui_browse_hists(top->evlist, help, &hbt,
607  top->min_percent,
608  &top->session->header.env,
609  !top->record_opts.overwrite,
610  &top->annotation_opts);
611 
612  done = 1;
613  return NULL;
614 }
615 
616 static void display_sig(int sig __maybe_unused)
617 {
618  done = 1;
619 }
620 
621 static void display_setup_sig(void)
622 {
623  signal(SIGSEGV, sighandler_dump_stack);
624  signal(SIGFPE, sighandler_dump_stack);
625  signal(SIGINT, display_sig);
626  signal(SIGQUIT, display_sig);
627  signal(SIGTERM, display_sig);
628 }
629 
630 static void *display_thread(void *arg)
631 {
632  struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
633  struct termios save;
634  struct perf_top *top = arg;
635  int delay_msecs, c;
636 
637  /* In order to read symbols from other namespaces perf to needs to call
638  * setns(2). This isn't permitted if the struct_fs has multiple users.
639  * unshare(2) the fs so that we may continue to setns into namespaces
640  * that we're observing.
641  */
642  unshare(CLONE_FS);
643 
646 repeat:
647  delay_msecs = top->delay_secs * MSEC_PER_SEC;
648  set_term_quiet_input(&save);
649  /* trash return*/
650  getc(stdin);
651 
652  while (!done) {
654  /*
655  * Either timeout expired or we got an EINTR due to SIGWINCH,
656  * refresh screen in both cases.
657  */
658  switch (poll(&stdin_poll, 1, delay_msecs)) {
659  case 0:
660  continue;
661  case -1:
662  if (errno == EINTR)
663  continue;
664  __fallthrough;
665  default:
666  c = getc(stdin);
667  tcsetattr(0, TCSAFLUSH, &save);
668 
669  if (perf_top__handle_keypress(top, c))
670  goto repeat;
671  done = 1;
672  }
673  }
674 
675  tcsetattr(0, TCSAFLUSH, &save);
676  return NULL;
677 }
678 
679 static int hist_iter__top_callback(struct hist_entry_iter *iter,
680  struct addr_location *al, bool single,
681  void *arg)
682 {
683  struct perf_top *top = arg;
684  struct hist_entry *he = iter->he;
685  struct perf_evsel *evsel = iter->evsel;
686 
687  if (perf_hpp_list.sym && single)
688  perf_top__record_precise_ip(top, he, iter->sample, evsel, al->addr);
689 
691  !(top->record_opts.branch_stack & PERF_SAMPLE_BRANCH_ANY));
692  return 0;
693 }
694 
696  const union perf_event *event,
697  struct perf_evsel *evsel,
698  struct perf_sample *sample,
699  struct machine *machine)
700 {
701  struct perf_top *top = container_of(tool, struct perf_top, tool);
702  struct addr_location al;
703  int err;
704 
705  if (!machine && perf_guest) {
706  static struct intlist *seen;
707 
708  if (!seen)
709  seen = intlist__new(NULL);
710 
711  if (!intlist__has_entry(seen, sample->pid)) {
712  pr_err("Can't find guest [%d]'s kernel information\n",
713  sample->pid);
714  intlist__add(seen, sample->pid);
715  }
716  return;
717  }
718 
719  if (!machine) {
720  pr_err("%u unprocessable samples recorded.\r",
722  return;
723  }
724 
725  if (event->header.misc & PERF_RECORD_MISC_EXACT_IP)
726  top->exact_samples++;
727 
728  if (machine__resolve(machine, &al, sample) < 0)
729  return;
730 
731  if (!machine->kptr_restrict_warned &&
733  al.cpumode == PERF_RECORD_MISC_KERNEL) {
735  ui__warning(
736 "Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
737 "Check /proc/sys/kernel/kptr_restrict.\n\n"
738 "Kernel%s samples will not be resolved.\n",
739  al.map && map__has_symbols(al.map) ?
740  " modules" : "");
741  if (use_browser <= 0)
742  sleep(5);
743  }
744  machine->kptr_restrict_warned = true;
745  }
746 
747  if (al.sym == NULL && al.map != NULL) {
748  const char *msg = "Kernel samples will not be resolved.\n";
749  /*
750  * As we do lazy loading of symtabs we only will know if the
751  * specified vmlinux file is invalid when we actually have a
752  * hit in kernel space and then try to load it. So if we get
753  * here and there are _no_ symbols in the DSO backing the
754  * kernel map, bail out.
755  *
756  * We may never get here, for instance, if we use -K/
757  * --hide-kernel-symbols, even if the user specifies an
758  * invalid --vmlinux ;-)
759  */
760  if (!machine->kptr_restrict_warned && !top->vmlinux_warned &&
763  char serr[256];
764  dso__strerror_load(al.map->dso, serr, sizeof(serr));
765  ui__warning("The %s file can't be used: %s\n%s",
766  symbol_conf.vmlinux_name, serr, msg);
767  } else {
768  ui__warning("A vmlinux file was not found.\n%s",
769  msg);
770  }
771 
772  if (use_browser <= 0)
773  sleep(5);
774  top->vmlinux_warned = true;
775  }
776  }
777 
778  if (al.sym == NULL || !al.sym->idle) {
779  struct hists *hists = evsel__hists(evsel);
780  struct hist_entry_iter iter = {
781  .evsel = evsel,
782  .sample = sample,
783  .add_entry_cb = hist_iter__top_callback,
784  };
785 
787  iter.ops = &hist_iter_cumulative;
788  else
789  iter.ops = &hist_iter_normal;
790 
791  pthread_mutex_lock(&hists->lock);
792 
793  err = hist_entry_iter__add(&iter, &al, top->max_stack, top);
794  if (err < 0)
795  pr_err("Problem incrementing symbol period, skipping event\n");
796 
797  pthread_mutex_unlock(&hists->lock);
798  }
799 
800  addr_location__put(&al);
801 }
802 
803 static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
804 {
805  struct record_opts *opts = &top->record_opts;
806  struct perf_evlist *evlist = top->evlist;
807  struct perf_sample sample;
808  struct perf_evsel *evsel;
809  struct perf_mmap *md;
810  struct perf_session *session = top->session;
811  union perf_event *event;
812  struct machine *machine;
813  int ret;
814 
815  md = opts->overwrite ? &evlist->overwrite_mmap[idx] : &evlist->mmap[idx];
816  if (perf_mmap__read_init(md) < 0)
817  return;
818 
819  while ((event = perf_mmap__read_event(md)) != NULL) {
820  ret = perf_evlist__parse_sample(evlist, event, &sample);
821  if (ret) {
822  pr_err("Can't parse sample, err = %d\n", ret);
823  goto next_event;
824  }
825 
826  evsel = perf_evlist__id2evsel(session->evlist, sample.id);
827  assert(evsel != NULL);
828 
829  if (event->header.type == PERF_RECORD_SAMPLE)
830  ++top->samples;
831 
832  switch (sample.cpumode) {
833  case PERF_RECORD_MISC_USER:
834  ++top->us_samples;
835  if (top->hide_user_symbols)
836  goto next_event;
837  machine = &session->machines.host;
838  break;
839  case PERF_RECORD_MISC_KERNEL:
840  ++top->kernel_samples;
841  if (top->hide_kernel_symbols)
842  goto next_event;
843  machine = &session->machines.host;
844  break;
845  case PERF_RECORD_MISC_GUEST_KERNEL:
846  ++top->guest_kernel_samples;
847  machine = perf_session__find_machine(session,
848  sample.pid);
849  break;
850  case PERF_RECORD_MISC_GUEST_USER:
851  ++top->guest_us_samples;
852  /*
853  * TODO: we don't process guest user from host side
854  * except simple counting.
855  */
856  goto next_event;
857  default:
858  if (event->header.type == PERF_RECORD_SAMPLE)
859  goto next_event;
860  machine = &session->machines.host;
861  break;
862  }
863 
864 
865  if (event->header.type == PERF_RECORD_SAMPLE) {
866  perf_event__process_sample(&top->tool, event, evsel,
867  &sample, machine);
868  } else if (event->header.type < PERF_RECORD_MAX) {
869  hists__inc_nr_events(evsel__hists(evsel), event->header.type);
870  machine__process_event(machine, event, &sample);
871  } else
872  ++session->evlist->stats.nr_unknown_events;
873 next_event:
874  perf_mmap__consume(md);
875  }
876 
878 }
879 
880 static void perf_top__mmap_read(struct perf_top *top)
881 {
882  bool overwrite = top->record_opts.overwrite;
883  struct perf_evlist *evlist = top->evlist;
884  unsigned long long start, end;
885  int i;
886 
887  start = rdclock();
888  if (overwrite)
890 
891  for (i = 0; i < top->evlist->nr_mmaps; i++)
892  perf_top__mmap_read_idx(top, i);
893 
894  if (overwrite) {
897  }
898  end = rdclock();
899 
900  if ((end - start) > (unsigned long long)top->delay_secs * NSEC_PER_SEC)
901  ui__warning("Too slow to read ring buffer.\n"
902  "Please try increasing the period (-c) or\n"
903  "decreasing the freq (-F) or\n"
904  "limiting the number of CPUs (-C)\n");
905 }
906 
907 /*
908  * Check per-event overwrite term.
909  * perf top should support consistent term for all events.
910  * - All events don't have per-event term
911  * E.g. "cpu/cpu-cycles/,cpu/instructions/"
912  * Nothing change, return 0.
913  * - All events have same per-event term
914  * E.g. "cpu/cpu-cycles,no-overwrite/,cpu/instructions,no-overwrite/
915  * Using the per-event setting to replace the opts->overwrite if
916  * they are different, then return 0.
917  * - Events have different per-event term
918  * E.g. "cpu/cpu-cycles,overwrite/,cpu/instructions,no-overwrite/"
919  * Return -1
920  * - Some of the event set per-event term, but some not.
921  * E.g. "cpu/cpu-cycles/,cpu/instructions,no-overwrite/"
922  * Return -1
923  */
924 static int perf_top__overwrite_check(struct perf_top *top)
925 {
926  struct record_opts *opts = &top->record_opts;
927  struct perf_evlist *evlist = top->evlist;
929  struct list_head *config_terms;
930  struct perf_evsel *evsel;
931  int set, overwrite = -1;
932 
933  evlist__for_each_entry(evlist, evsel) {
934  set = -1;
935  config_terms = &evsel->config_terms;
936  list_for_each_entry(term, config_terms, list) {
938  set = term->val.overwrite ? 1 : 0;
939  }
940 
941  /* no term for current and previous event (likely) */
942  if ((overwrite < 0) && (set < 0))
943  continue;
944 
945  /* has term for both current and previous event, compare */
946  if ((overwrite >= 0) && (set >= 0) && (overwrite != set))
947  return -1;
948 
949  /* no term for current event but has term for previous one */
950  if ((overwrite >= 0) && (set < 0))
951  return -1;
952 
953  /* has term for current event */
954  if ((overwrite < 0) && (set >= 0)) {
955  /* if it's first event, set overwrite */
956  if (evsel == perf_evlist__first(evlist))
957  overwrite = set;
958  else
959  return -1;
960  }
961  }
962 
963  if ((overwrite >= 0) && (opts->overwrite != overwrite))
964  opts->overwrite = overwrite;
965 
966  return 0;
967 }
968 
969 static int perf_top_overwrite_fallback(struct perf_top *top,
970  struct perf_evsel *evsel)
971 {
972  struct record_opts *opts = &top->record_opts;
973  struct perf_evlist *evlist = top->evlist;
974  struct perf_evsel *counter;
975 
976  if (!opts->overwrite)
977  return 0;
978 
979  /* only fall back when first event fails */
980  if (evsel != perf_evlist__first(evlist))
981  return 0;
982 
983  evlist__for_each_entry(evlist, counter)
984  counter->attr.write_backward = false;
985  opts->overwrite = false;
986  pr_debug2("fall back to non-overwrite mode\n");
987  return 1;
988 }
989 
990 static int perf_top__start_counters(struct perf_top *top)
991 {
992  char msg[BUFSIZ];
993  struct perf_evsel *counter;
994  struct perf_evlist *evlist = top->evlist;
995  struct record_opts *opts = &top->record_opts;
996 
997  if (perf_top__overwrite_check(top)) {
998  ui__error("perf top only support consistent per-event "
999  "overwrite setting for all events\n");
1000  goto out_err;
1001  }
1002 
1003  perf_evlist__config(evlist, opts, &callchain_param);
1004 
1005  evlist__for_each_entry(evlist, counter) {
1006 try_again:
1007  if (perf_evsel__open(counter, top->evlist->cpus,
1008  top->evlist->threads) < 0) {
1009 
1010  /*
1011  * Specially handle overwrite fall back.
1012  * Because perf top is the only tool which has
1013  * overwrite mode by default, support
1014  * both overwrite and non-overwrite mode, and
1015  * require consistent mode for all events.
1016  *
1017  * May move it to generic code with more tools
1018  * have similar attribute.
1019  */
1021  perf_top_overwrite_fallback(top, counter))
1022  goto try_again;
1023 
1024  if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
1025  if (verbose > 0)
1026  ui__warning("%s\n", msg);
1027  goto try_again;
1028  }
1029 
1030  perf_evsel__open_strerror(counter, &opts->target,
1031  errno, msg, sizeof(msg));
1032  ui__error("%s\n", msg);
1033  goto out_err;
1034  }
1035  }
1036 
1037  if (perf_evlist__mmap(evlist, opts->mmap_pages) < 0) {
1038  ui__error("Failed to mmap with %d (%s)\n",
1039  errno, str_error_r(errno, msg, sizeof(msg)));
1040  goto out_err;
1041  }
1042 
1043  return 0;
1044 
1045 out_err:
1046  return -1;
1047 }
1048 
1050 {
1051  if (!perf_hpp_list.sym) {
1052  if (callchain->enabled) {
1053  ui__error("Selected -g but \"sym\" not present in --sort/-s.");
1054  return -EINVAL;
1055  }
1056  } else if (callchain->mode != CHAIN_NONE) {
1057  if (callchain_register_param(callchain) < 0) {
1058  ui__error("Can't register callchain params.\n");
1059  return -EINVAL;
1060  }
1061  }
1062 
1063  return 0;
1064 }
1065 
1066 static int __cmd_top(struct perf_top *top)
1067 {
1068  char msg[512];
1069  struct perf_evsel *pos;
1070  struct perf_evsel_config_term *err_term;
1071  struct perf_evlist *evlist = top->evlist;
1072  struct record_opts *opts = &top->record_opts;
1073  pthread_t thread;
1074  int ret;
1075 
1076  top->session = perf_session__new(NULL, false, NULL);
1077  if (top->session == NULL)
1078  return -1;
1079 
1080  if (!top->annotation_opts.objdump_path) {
1083  if (ret)
1084  goto out_delete;
1085  }
1086 
1088  if (ret)
1089  goto out_delete;
1090 
1092  goto out_delete;
1093 
1094  if (top->nr_threads_synthesize > 1)
1096 
1098  top->evlist->threads, false,
1099  opts->proc_map_timeout,
1100  top->nr_threads_synthesize);
1101 
1102  if (top->nr_threads_synthesize > 1)
1104 
1105  if (perf_hpp_list.socket) {
1107  if (ret < 0)
1108  goto out_err_cpu_topo;
1109  }
1110 
1111  ret = perf_top__start_counters(top);
1112  if (ret)
1113  goto out_delete;
1114 
1115  ret = perf_evlist__apply_drv_configs(evlist, &pos, &err_term);
1116  if (ret) {
1117  pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
1118  err_term->val.drv_cfg, perf_evsel__name(pos), errno,
1119  str_error_r(errno, msg, sizeof(msg)));
1120  goto out_delete;
1121  }
1122 
1123  top->session->evlist = top->evlist;
1125 
1126  /*
1127  * When perf is starting the traced process, all the events (apart from
1128  * group members) have enable_on_exec=1 set, so don't spoil it by
1129  * prematurely enabling them.
1130  *
1131  * XXX 'top' still doesn't start workloads like record, trace, but should,
1132  * so leave the check here.
1133  */
1134  if (!target__none(&opts->target))
1136 
1137  /* Wait for a minimal set of events before starting the snapshot */
1138  perf_evlist__poll(top->evlist, 100);
1139 
1140  perf_top__mmap_read(top);
1141 
1142  ret = -1;
1143  if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
1144  display_thread), top)) {
1145  ui__error("Could not create display thread.\n");
1146  goto out_delete;
1147  }
1148 
1149  if (top->realtime_prio) {
1150  struct sched_param param;
1151 
1152  param.sched_priority = top->realtime_prio;
1153  if (sched_setscheduler(0, SCHED_FIFO, &param)) {
1154  ui__error("Could not set realtime priority.\n");
1155  goto out_join;
1156  }
1157  }
1158 
1159  while (!done) {
1160  u64 hits = top->samples;
1161 
1162  perf_top__mmap_read(top);
1163 
1164  if (opts->overwrite || (hits == top->samples))
1165  ret = perf_evlist__poll(top->evlist, 100);
1166 
1167  if (resize) {
1168  perf_top__resize(top);
1169  resize = 0;
1170  }
1171  }
1172 
1173  ret = 0;
1174 out_join:
1175  pthread_join(thread, NULL);
1176 out_delete:
1178  top->session = NULL;
1179 
1180  return ret;
1181 
1182 out_err_cpu_topo: {
1183  char errbuf[BUFSIZ];
1184  const char *err = str_error_r(-ret, errbuf, sizeof(errbuf));
1185 
1186  ui__error("Could not read the CPU topology map: %s\n", err);
1187  goto out_delete;
1188 }
1189 }
1190 
1191 static int
1192 callchain_opt(const struct option *opt, const char *arg, int unset)
1193 {
1194  symbol_conf.use_callchain = true;
1195  return record_callchain_opt(opt, arg, unset);
1196 }
1197 
1198 static int
1199 parse_callchain_opt(const struct option *opt, const char *arg, int unset)
1200 {
1201  struct callchain_param *callchain = opt->value;
1202 
1203  callchain->enabled = !unset;
1204  callchain->record_mode = CALLCHAIN_FP;
1205 
1206  /*
1207  * --no-call-graph
1208  */
1209  if (unset) {
1210  symbol_conf.use_callchain = false;
1211  callchain->record_mode = CALLCHAIN_NONE;
1212  return 0;
1213  }
1214 
1215  return parse_callchain_top_opt(arg);
1216 }
1217 
1218 static int perf_top_config(const char *var, const char *value, void *cb __maybe_unused)
1219 {
1220  if (!strcmp(var, "top.call-graph")) {
1221  var = "call-graph.record-mode";
1222  return perf_default_config(var, value, cb);
1223  }
1224  if (!strcmp(var, "top.children")) {
1226  return 0;
1227  }
1228 
1229  return 0;
1230 }
1231 
1232 static int
1233 parse_percent_limit(const struct option *opt, const char *arg,
1234  int unset __maybe_unused)
1235 {
1236  struct perf_top *top = opt->value;
1237 
1238  top->min_percent = strtof(arg, NULL);
1239  return 0;
1240 }
1241 
1243  "\n\t\t\t\tDefault: fp,graph,0.5,caller,function";
1244 
1245 int cmd_top(int argc, const char **argv)
1246 {
1247  char errbuf[BUFSIZ];
1248  struct perf_top top = {
1249  .count_filter = 5,
1250  .delay_secs = 2,
1251  .record_opts = {
1252  .mmap_pages = UINT_MAX,
1253  .user_freq = UINT_MAX,
1254  .user_interval = ULLONG_MAX,
1255  .freq = 4000, /* 4 KHz */
1256  .target = {
1257  .uses_mmap = true,
1258  },
1259  .proc_map_timeout = 500,
1260  .overwrite = 1,
1261  },
1262  .max_stack = sysctl__max_stack(),
1263  .annotation_opts = annotation__default_options,
1264  .nr_threads_synthesize = UINT_MAX,
1265  };
1266  struct record_opts *opts = &top.record_opts;
1267  struct target *target = &opts->target;
1268  const struct option options[] = {
1269  OPT_CALLBACK('e', "event", &top.evlist, "event",
1270  "event selector. use 'perf list' to list available events",
1272  OPT_U64('c', "count", &opts->user_interval, "event period to sample"),
1273  OPT_STRING('p', "pid", &target->pid, "pid",
1274  "profile events on existing process id"),
1275  OPT_STRING('t', "tid", &target->tid, "tid",
1276  "profile events on existing thread id"),
1277  OPT_BOOLEAN('a', "all-cpus", &target->system_wide,
1278  "system-wide collection from all CPUs"),
1279  OPT_STRING('C', "cpu", &target->cpu_list, "cpu",
1280  "list of cpus to monitor"),
1281  OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
1282  "file", "vmlinux pathname"),
1283  OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
1284  "don't load vmlinux even if found"),
1285  OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols,
1286  "hide kernel symbols"),
1287  OPT_CALLBACK('m', "mmap-pages", &opts->mmap_pages, "pages",
1288  "number of mmap data pages",
1290  OPT_INTEGER('r', "realtime", &top.realtime_prio,
1291  "collect data with this RT SCHED_FIFO priority"),
1292  OPT_INTEGER('d', "delay", &top.delay_secs,
1293  "number of seconds to delay between refreshes"),
1294  OPT_BOOLEAN('D', "dump-symtab", &top.dump_symtab,
1295  "dump the symbol table used for profiling"),
1296  OPT_INTEGER('f', "count-filter", &top.count_filter,
1297  "only display functions with more events than this"),
1298  OPT_BOOLEAN(0, "group", &opts->group,
1299  "put the counters into a counter group"),
1300  OPT_BOOLEAN('i', "no-inherit", &opts->no_inherit,
1301  "child tasks do not inherit counters"),
1302  OPT_STRING(0, "sym-annotate", &top.sym_filter, "symbol name",
1303  "symbol to annotate"),
1304  OPT_BOOLEAN('z', "zero", &top.zero, "zero history across updates"),
1305  OPT_CALLBACK('F', "freq", &top.record_opts, "freq or 'max'",
1306  "profile at this frequency",
1308  OPT_INTEGER('E', "entries", &top.print_entries,
1309  "display this many functions"),
1310  OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols,
1311  "hide user symbols"),
1312  OPT_BOOLEAN(0, "tui", &top.use_tui, "Use the TUI interface"),
1313  OPT_BOOLEAN(0, "stdio", &top.use_stdio, "Use the stdio interface"),
1314  OPT_INCR('v', "verbose", &verbose,
1315  "be more verbose (show counter open errors, etc)"),
1316  OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1317  "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
1318  " Please refer the man page for the complete list."),
1319  OPT_STRING(0, "fields", &field_order, "key[,keys...]",
1320  "output field(s): overhead, period, sample plus all of sort keys"),
1321  OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
1322  "Show a column with the number of samples"),
1323  OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
1324  NULL, "enables call-graph recording and display",
1325  &callchain_opt),
1326  OPT_CALLBACK(0, "call-graph", &callchain_param,
1327  "record_mode[,record_size],print_type,threshold[,print_limit],order,sort_key[,branch]",
1329  OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
1330  "Accumulate callchains of children and show total overhead as well"),
1331  OPT_INTEGER(0, "max-stack", &top.max_stack,
1332  "Set the maximum stack depth when parsing the callchain. "
1333  "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
1334  OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
1335  "ignore callees of these functions in call graphs",
1337  OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
1338  "Show a column with the sum of periods"),
1339  OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
1340  "only consider symbols in these dsos"),
1341  OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
1342  "only consider symbols in these comms"),
1343  OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
1344  "only consider these symbols"),
1345  OPT_BOOLEAN(0, "source", &top.annotation_opts.annotate_src,
1346  "Interleave source code with assembly code (default)"),
1347  OPT_BOOLEAN(0, "asm-raw", &top.annotation_opts.show_asm_raw,
1348  "Display raw encoding of assembly instructions (default)"),
1349  OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
1350  "Enable kernel symbol demangling"),
1351  OPT_STRING(0, "objdump", &top.annotation_opts.objdump_path, "path",
1352  "objdump binary to use for disassembly and annotations"),
1353  OPT_STRING('M', "disassembler-style", &top.annotation_opts.disassembler_style, "disassembler style",
1354  "Specify disassembler style (e.g. -M intel for intel syntax)"),
1355  OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
1356  OPT_CALLBACK(0, "percent-limit", &top, "percent",
1357  "Don't show entries under that percent", parse_percent_limit),
1358  OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
1359  "How to display percentage of filtered entries", parse_filter_percentage),
1360  OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
1361  "width[,width...]",
1362  "don't try to adjust column width, use these fixed values"),
1363  OPT_UINTEGER(0, "proc-map-timeout", &opts->proc_map_timeout,
1364  "per thread proc mmap processing timeout in ms"),
1365  OPT_CALLBACK_NOOPT('b', "branch-any", &opts->branch_stack,
1366  "branch any", "sample any taken branches",
1368  OPT_CALLBACK('j', "branch-filter", &opts->branch_stack,
1369  "branch filter mask", "branch stack filter modes",
1371  OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,
1372  "Show raw trace event output (do not use print fmt or plugins)"),
1373  OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
1374  "Show entries in a hierarchy"),
1375  OPT_BOOLEAN(0, "force", &symbol_conf.force, "don't complain, do it"),
1376  OPT_UINTEGER(0, "num-thread-synthesize", &top.nr_threads_synthesize,
1377  "number of thread to run event synthesize"),
1378  OPT_END()
1379  };
1380  const char * const top_usage[] = {
1381  "perf top [<options>]",
1382  NULL
1383  };
1384  int status = hists__init();
1385 
1386  if (status < 0)
1387  return status;
1388 
1389  top.annotation_opts.min_pcnt = 5;
1390  top.annotation_opts.context = 4;
1391 
1392  top.evlist = perf_evlist__new();
1393  if (top.evlist == NULL)
1394  return -ENOMEM;
1395 
1396  status = perf_config(perf_top_config, &top);
1397  if (status)
1398  return status;
1399 
1400  argc = parse_options(argc, argv, options, top_usage, 0);
1401  if (argc)
1402  usage_with_options(top_usage, options);
1403 
1404  if (!top.evlist->nr_entries &&
1405  perf_evlist__add_default(top.evlist) < 0) {
1406  pr_err("Not enough memory for event selector list\n");
1407  goto out_delete_evlist;
1408  }
1409 
1411  /* disable incompatible options */
1412  symbol_conf.event_group = false;
1414 
1415  if (field_order) {
1416  pr_err("Error: --hierarchy and --fields options cannot be used together\n");
1417  parse_options_usage(top_usage, options, "fields", 0);
1418  parse_options_usage(NULL, options, "hierarchy", 0);
1419  goto out_delete_evlist;
1420  }
1421  }
1422 
1424  /* display thread wants entries to be collapsed in a different tree */
1426 
1427  if (top.use_stdio)
1428  use_browser = 0;
1429  else if (top.use_tui)
1430  use_browser = 1;
1431 
1432  setup_browser(false);
1433 
1434  if (setup_sorting(top.evlist) < 0) {
1435  if (sort_order)
1436  parse_options_usage(top_usage, options, "s", 1);
1437  if (field_order)
1438  parse_options_usage(sort_order ? NULL : top_usage,
1439  options, "fields", 0);
1440  goto out_delete_evlist;
1441  }
1442 
1443  status = target__validate(target);
1444  if (status) {
1445  target__strerror(target, status, errbuf, BUFSIZ);
1446  ui__warning("%s\n", errbuf);
1447  }
1448 
1449  status = target__parse_uid(target);
1450  if (status) {
1451  int saved_errno = errno;
1452 
1453  target__strerror(target, status, errbuf, BUFSIZ);
1454  ui__error("%s\n", errbuf);
1455 
1456  status = -saved_errno;
1457  goto out_delete_evlist;
1458  }
1459 
1460  if (target__none(target))
1461  target->system_wide = true;
1462 
1463  if (perf_evlist__create_maps(top.evlist, target) < 0) {
1464  ui__error("Couldn't create thread/CPU maps: %s\n",
1465  errno == ENOENT ? "No such process" : str_error_r(errno, errbuf, sizeof(errbuf)));
1466  goto out_delete_evlist;
1467  }
1468 
1469  if (top.delay_secs < 1)
1470  top.delay_secs = 1;
1471 
1472  if (record_opts__config(opts)) {
1473  status = -EINVAL;
1474  goto out_delete_evlist;
1475  }
1476 
1477  top.sym_evsel = perf_evlist__first(top.evlist);
1478 
1479  if (!callchain_param.enabled) {
1482  }
1483 
1486 
1487  status = symbol__annotation_init();
1488  if (status < 0)
1489  goto out_delete_evlist;
1490 
1492 
1494  if (symbol__init(NULL) < 0)
1495  return -1;
1496 
1497  sort__setup_elide(stdout);
1498 
1500  if (top.print_entries == 0) {
1502  signal(SIGWINCH, winch_sig);
1503  }
1504 
1505  status = __cmd_top(&top);
1506 
1507 out_delete_evlist:
1509 
1510  return status;
1511 }
static void setup_sorting(struct perf_sched *sched, const struct option *options, const char *const usage_msg[])
enum target_errno target__parse_uid(struct target *target)
Definition: target.c:69
bool event_group
Definition: symbol.h:93
char dso__symtab_origin(const struct dso *dso)
Definition: dso.c:30
void perf_session__set_id_hdr_size(struct perf_session *session)
Definition: session.c:66
void hists__inc_nr_events(struct hists *hists, u32 type)
Definition: hist.c:2124
u64 user_interval
Definition: perf.h:74
const char * comm_list_str
Definition: symbol.h:131
const char * col_width_list_str
Definition: symbol.h:131
int color_fprintf(FILE *fp, const char *color, const char *fmt,...)
Definition: color.c:123
struct perf_sample * sample
Definition: hist.h:113
void perf_mmap__consume(struct perf_mmap *map)
Definition: mmap.c:118
bool hide_kernel_symbols
Definition: top.h:31
int value
Definition: python.c:1143
Definition: env.h:36
float min_percent
Definition: top.h:41
void perf_hpp__cancel_cumulate(void)
Definition: hist.c:539
void symbol__calc_percent(struct symbol *sym, struct perf_evsel *evsel)
Definition: annotate.c:1803
struct perf_evlist * evlist
Definition: session.h:25
static void perf_top__update_print_entries(struct perf_top *top)
Definition: builtin-top.c:84
const char * uid_str
Definition: target.h:12
union perf_evsel_config_term::@112 val
bool group
Definition: perf.h:39
int machine__resolve(struct machine *machine, struct addr_location *al, struct perf_sample *sample)
Definition: event.c:1601
int max_stack
Definition: top.h:30
const char * vmlinux_name
Definition: symbol.h:123
int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
Definition: evlist.c:1066
void symbol__annotate_zero_histograms(struct symbol *sym)
Definition: annotate.c:743
void symbol__annotate_zero_histogram(struct symbol *sym, int evidx)
Definition: annotate.c:2188
static struct machine * perf_session__find_machine(struct perf_session *session, pid_t pid)
Definition: session.h:75
bool cumulate_callchain
Definition: symbol.h:93
struct perf_mmap * mmap
Definition: evlist.h:45
enum sort_mode sort__mode
Definition: sort.c:31
u64 samples
Definition: top.h:25
int ui__error(const char *format,...)
Definition: util.c:32
#define CALLCHAIN_REPORT_HELP
Definition: callchain.h:25
struct map_symbol ms
Definition: sort.h:98
int hist_entry__inc_addr_samples(struct hist_entry *he, struct perf_sample *sample, struct perf_evsel *evsel, u64 ip)
Definition: annotate.c:1022
int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help, struct hist_browser_timer *hbt, float min_pcnt, struct perf_env *env, bool warn_lost_event, struct annotation_options *annotation_opts)
Definition: hists.c:3266
struct perf_tool tool
Definition: top.h:17
int perf_default_config(const char *var, const char *value, void *dummy __maybe_unused)
Definition: config.c:435
struct machine host
Definition: machine.h:136
#define CONSOLE_CLEAR
Definition: top.h:45
enum target_errno target__validate(struct target *target)
Definition: target.c:17
static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip)
Definition: builtin-top.c:155
struct symbol * sym
Definition: symbol.h:181
const char perf_version_string[]
Definition: header.c:60
const char * graph_dotted_line
Definition: ctype.c:38
#define CALLCHAIN_RECORD_HELP
Definition: callchain.h:23
struct map * map
Definition: symbol.h:180
void perf_evlist__enable(struct perf_evlist *evlist)
Definition: evlist.c:369
int intlist__add(struct intlist *ilist, int i)
Definition: intlist.c:51
static int machine__synthesize_threads(struct machine *machine, struct target *target, struct thread_map *threads, bool data_mmap, unsigned int proc_map_timeout, unsigned int nr_threads_synthesize)
Definition: machine.h:253
Definition: hist.h:106
int count_filter
Definition: top.h:29
void perf_set_singlethreaded(void)
Definition: util.c:30
int ui__warning(const char *format,...)
Definition: util.c:44
void hists__output_recalc_col_len(struct hists *hists, int max_rows)
Definition: hist.c:210
int int err
Definition: 5sec.c:44
int hists__collapse_resort(struct hists *hists, struct ui_progress *prog)
Definition: hist.c:1464
int perf_config_bool(const char *name, const char *value)
Definition: config.c:389
bool try_vmlinux_path
Definition: symbol.h:93
struct perf_evsel * sym_evsel
Definition: top.h:36
bool perf_evlist__exclude_kernel(struct perf_evlist *evlist)
Definition: evlist.c:1787
unsigned int proc_map_timeout
Definition: perf.h:81
u8 idle
Definition: symbol.h:62
int dso__strerror_load(struct dso *dso, char *buf, size_t buflen)
Definition: dso.c:1497
static void perf_top__print_mapped_keys(struct perf_top *top)
Definition: builtin-top.c:390
#define pr_debug2(fmt,...)
Definition: debug.h:33
enum perf_call_graph_mode record_mode
Definition: callchain.h:96
enum chain_value value
Definition: callchain.h:107
bool zero
Definition: top.h:31
struct perf_env env
Definition: header.h:82
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
Definition: session.c:2005
static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
Definition: builtin-top.c:803
int socket
Definition: hist.h:278
void perf_evlist__delete(struct perf_evlist *evlist)
Definition: evlist.c:133
struct annotation_options annotation_opts
Definition: top.h:20
void set_term_quiet_input(struct termios *old)
Definition: term.c:30
const char * long_name
Definition: dso.h:173
struct hist_entry * sym_filter_entry
Definition: top.h:35
pthread_mutex_t lock
Definition: hist.h:84
u64 end
Definition: symbol.h:58
static int term(yyscan_t scanner, int type)
u64 guest_us_samples
Definition: top.h:28
const char * uid_filter_str
Definition: hist.h:82
static void perf_event__process_sample(struct perf_tool *tool, const union perf_event *event, struct perf_evsel *evsel, struct perf_sample *sample, struct machine *machine)
Definition: builtin-top.c:695
static struct hists * evsel__hists(struct perf_evsel *evsel)
Definition: hist.h:217
int delay_secs
Definition: top.h:29
const char * sym_filter
Definition: top.h:40
struct thread_map * threads
Definition: evlist.h:47
Definition: mmap.h:17
int idx
Definition: evsel.h:100
bool enabled
Definition: evlist.h:33
int print_entries
Definition: top.h:29
static bool target__none(struct target *target)
Definition: target.h:62
bool force
Definition: symbol.h:93
u64 us_samples
Definition: top.h:26
int machine__process_event(struct machine *machine, union perf_event *event, struct perf_sample *sample)
Definition: machine.c:1729
static unsigned long long rdclock(void)
Definition: perf.h:19
unsigned int nr_threads_synthesize
Definition: top.h:42
#define pr_err(fmt,...)
Definition: json.h:21
int symbol__strerror_disassemble(struct symbol *sym __maybe_unused, struct map *map, int errnum, char *buf, size_t buflen)
Definition: annotate.c:1524
struct hist_entry * he
Definition: hist.h:114
u32 nr_lost_warned
Definition: event.h:409
int nr_entries
Definition: evlist.h:30
void perf_session__delete(struct perf_session *session)
Definition: session.c:187
int use_browser
Definition: setup.c:12
int record_opts__config(struct record_opts *opts)
Definition: record.c:254
static int callchain_param__setup_sample_type(struct callchain_param *callchain)
Definition: builtin-top.c:1049
int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str, int unset __maybe_unused)
Definition: evlist.c:996
Definition: sort.h:89
u64 start
Definition: map.h:28
static void prompt_percent(int *target, const char *msg)
Definition: builtin-top.c:339
struct target target
Definition: perf.h:38
u64 branch_stack
Definition: perf.h:70
struct perf_mmap * overwrite_mmap
Definition: evlist.h:46
u64 id
Definition: event.h:196
enum chain_mode mode
Definition: callchain.h:98
bool perf_evsel__fallback(struct perf_evsel *evsel, int err, char *msg, size_t msgsize)
Definition: evsel.c:2733
void * malloc(YYSIZE_T)
int target__strerror(struct target *target, int errnum, char *buf, size_t buflen)
Definition: target.c:116
bool show_nr_samples
Definition: symbol.h:93
const char top_callchain_help[]
Definition: builtin-top.c:1242
int record__parse_freq(const struct option *opt, const char *str, int unset)
Definition: record.c:306
static bool intlist__has_entry(struct intlist *ilist, int i)
Definition: intlist.h:30
void addr_location__put(struct addr_location *al)
Definition: event.c:1661
struct map * map
Definition: symbol.h:210
int perf_mmap__read_init(struct perf_mmap *map)
Definition: mmap.c:271
struct hists * hists
Definition: sort.h:135
u8 binding
Definition: symbol.h:61
Definition: thread.h:18
void setup_browser(bool fallback_to_pager)
Definition: setup.c:76
const char * name
const char * field_order
Definition: sort.c:28
const char * objdump_path
Definition: annotate.h:83
bool dump_symtab
Definition: top.h:34
bool system_wide
Definition: target.h:14
bool perf_guest
Definition: util.c:81
static struct perf_evsel * hists_to_evsel(struct hists *hists)
Definition: hist.h:211
int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
Definition: evlist.c:491
static void perf_top__mmap_read(struct perf_top *top)
Definition: builtin-top.c:880
Definition: tool.h:44
static struct perf_session * session
Definition: builtin-lock.c:34
u64 start
Definition: symbol.h:57
bool erange_warned
Definition: map.h:30
static void * display_thread_tui(void *arg)
Definition: builtin-top.c:576
static void winch_sig(int sig __maybe_unused)
Definition: builtin-top.c:89
enum term_type type
Definition: evsel.h:56
static void perf_top__prompt_symbol(struct perf_top *top, const char *msg)
Definition: builtin-top.c:348
int perf_env__lookup_objdump(struct perf_env *env, const char **path)
Definition: common.c:192
#define evlist__for_each_entry(evlist, evsel)
Definition: evlist.h:247
static void display_setup_sig(void)
Definition: builtin-top.c:621
void perf_top__reset_sample_counters(struct perf_top *top)
Definition: top.c:112
int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event, struct perf_sample *sample)
Definition: evlist.c:1561
void sort__setup_elide(FILE *output)
Definition: sort.c:2812
static void prompt_integer(int *target, const char *msg)
Definition: builtin-top.c:313
struct record_opts record_opts
Definition: top.h:19
struct dso * dso
Definition: map.h:45
static volatile int done
Definition: builtin-top.c:79
void perf_evlist__toggle_bkw_mmap(struct perf_evlist *evlist, enum bkw_mmap_state state)
Definition: evlist.c:1729
bool no_inherit
Definition: perf.h:42
void perf_set_multithreaded(void)
Definition: util.c:35
int perf_session__register_idle_thread(struct perf_session *session)
Definition: session.c:1537
int sym
Definition: hist.h:276
struct annotated_source * symbol__hists(struct symbol *sym, int nr_hists)
Definition: annotate.c:858
static struct perf_tool tool
Definition: builtin-diff.c:362
static void * display_thread(void *arg)
Definition: builtin-top.c:630
static void perf_top__print_sym_table(struct perf_top *top)
Definition: builtin-top.c:262
u32 pid
Definition: event.h:193
void pthread__unblock_sigwinch(void)
Definition: perf.c:414
bool kptr_restrict_warned
Definition: machine.h:44
struct perf_session * session
Definition: top.h:37
void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
Definition: annotate.c:2196
char name[0]
Definition: symbol.h:66
int symbol__annotation_init(void)
Definition: symbol.c:2097
bool overwrite
Definition: perf.h:62
int need_collapse
Definition: hist.h:274
int symbol__annotate_printf(struct symbol *sym, struct map *map, struct perf_evsel *evsel, struct annotation_options *opts)
Definition: annotate.c:1995
unsigned int mmap_pages
Definition: perf.h:67
struct perf_evsel * perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
Definition: evlist.c:589
struct symbol * sym
Definition: symbol.h:211
static struct annotation * symbol__annotation(struct symbol *sym)
Definition: annotate.h:293
static bool dso__is_kcore(struct dso *dso)
Definition: dso.h:365
#define event
static int perf_top_config(const char *var, const char *value, void *cb __maybe_unused)
Definition: builtin-top.c:1218
static int parse_percent_limit(const struct option *opt, const char *arg, int unset __maybe_unused)
Definition: builtin-top.c:1233
struct branch_stack * branch_stack
Definition: event.h:212
bool kptr_restrict
Definition: symbol.h:93
void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts, struct callchain_param *callchain)
Definition: record.c:135
struct list_head config_terms
Definition: evsel.h:139
int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target, int err, char *msg, size_t size)
Definition: evsel.c:2820
int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages)
Definition: evlist.c:1061
pthread_mutex_t lock
Definition: annotate.h:237
const char * disassembler_style
Definition: annotate.h:84
int hists__init(void)
Definition: hist.c:2629
static int perf_top_overwrite_fallback(struct perf_top *top, struct perf_evsel *evsel)
Definition: builtin-top.c:969
int nr_mmaps
Definition: evlist.h:32
bool map__has_symbols(const struct map *map)
Definition: map.c:262
u32 nr_unprocessable_samples
Definition: event.h:413
const char * dso_list_str
Definition: symbol.h:131
void get_term_dimensions(struct winsize *ws)
Definition: term.c:8
#define NSEC_PER_SEC
Definition: jvmti_agent.c:101
bool vmlinux_warned
Definition: top.h:33
int report_parse_ignore_callees_opt(const struct option *opt __maybe_unused, const char *arg, int unset __maybe_unused)
static void perf_top__show_details(struct perf_top *top)
Definition: builtin-top.c:224
const char * perf_evsel__name(struct perf_evsel *evsel)
Definition: evsel.c:577
int perf_evlist__apply_drv_configs(struct perf_evlist *evlist, struct perf_evsel **err_evsel, struct perf_evsel_config_term **err_term)
Definition: drv_configs.c:62
static int __cmd_top(struct perf_top *top)
Definition: builtin-top.c:1066
size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
Definition: top.c:24
void perf_mmap__read_done(struct perf_mmap *map)
Definition: mmap.c:329
struct perf_event_header header
Definition: event.h:624
static void perf_top__resize(struct perf_top *top)
Definition: builtin-top.c:94
int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus, struct thread_map *threads)
Definition: evsel.c:1704
struct intlist * intlist__new(const char *slist)
Definition: intlist.c:110
const struct hist_iter_ops hist_iter_normal
Definition: hist.c:1020
static void perf_top__record_precise_ip(struct perf_top *top, struct hist_entry *he, struct perf_sample *sample, struct perf_evsel *evsel, u64 ip)
Definition: builtin-top.c:182
struct perf_evsel * selected
Definition: evlist.h:49
u64 start
Definition: hists_common.c:25
void hist__account_cycles(struct branch_stack *bs, struct addr_location *al, struct perf_sample *sample, bool nonany_branch_mode)
Definition: hist.c:2406
struct perf_session * perf_session__new(struct perf_data *data, bool repipe, struct perf_tool *tool)
Definition: session.c:116
static struct perf_evsel * perf_evlist__first(struct perf_evlist *evlist)
Definition: evlist.h:215
struct winsize winsize
Definition: top.h:38
Definition: top.h:16
int parse_events_option(const struct option *opt, const char *str, int unset __maybe_unused)
union perf_event * perf_mmap__read_event(struct perf_mmap *map)
Definition: mmap.c:78
struct annotation_options annotation__default_options
Definition: annotate.c:47
const char * tid
Definition: target.h:10
u64 kernel_samples
Definition: top.h:26
static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
Definition: builtin-top.c:100
Definition: jevents.c:228
bool use_callchain
Definition: symbol.h:93
int perf_config(config_fn_t fn, void *data)
Definition: config.c:718
static int perf_top__overwrite_check(struct perf_top *top)
Definition: builtin-top.c:924
struct annotated_source * src
Definition: annotate.h:256
static int callchain_opt(const struct option *opt, const char *arg, int unset)
Definition: builtin-top.c:1192
enum chain_order order
Definition: callchain.h:103
static int sym(yyscan_t scanner, int type, int config)
bool __map__is_kernel(const struct map *map)
Definition: map.c:250
struct events_stats stats
Definition: evlist.h:50
static int parse_callchain_opt(const struct option *opt, const char *arg, int unset)
Definition: builtin-top.c:1199
static int perf_top__start_counters(struct perf_top *top)
Definition: builtin-top.c:990
bool hide_user_symbols
Definition: top.h:31
struct perf_evsel * evsel
Definition: hist.h:112
bool use_tui
Definition: top.h:32
bool ignore_vmlinux
Definition: symbol.h:93
bool raw_trace
Definition: symbol.h:93
struct perf_header header
Definition: session.h:23
enum dso_binary_type symtab_type
Definition: dso.h:156
int symbol__init(struct perf_env *env)
Definition: symbol.c:2112
const char * cpu_list
Definition: target.h:11
#define PERF_COLOR_RED
Definition: color.h:13
const struct hist_iter_ops hist_iter_cumulative
Definition: hist.c:1028
void free(void *)
void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
Definition: hist.c:338
static bool perf_top__handle_keypress(struct perf_top *top, int c)
Definition: builtin-top.c:446
static int hist_iter__top_callback(struct hist_entry_iter *iter, struct addr_location *al, bool single, void *arg)
Definition: builtin-top.c:679
const char * sym_list_str
Definition: symbol.h:131
int perf_env__read_cpu_topology_map(struct perf_env *env)
Definition: env.c:69
u32 nr_unknown_events
Definition: event.h:410
struct events_stats stats
Definition: hist.h:85
u64 exact_samples
Definition: top.h:27
u32 nr_events[PERF_RECORD_HEADER_MAX]
Definition: event.h:407
#define HEADER_LINE_NR
Definition: builtin-top.c:82
const char * pid
Definition: target.h:9
bool demangle_kernel
Definition: symbol.h:93
struct rb_root entries
Definition: hist.h:74
void hists__delete_entries(struct hists *hists)
Definition: hist.c:354
struct cpu_map * cpus
Definition: evlist.h:48
int cmd_top(int argc, const char **argv)
Definition: builtin-top.c:1245
void perf_evsel__output_resort(struct perf_evsel *evsel, struct ui_progress *prog)
Definition: hist.c:1756
bool use_stdio
Definition: top.h:32
int verbose
Definition: jevents.c:53
void annotation_config__init(void)
Definition: annotate.c:2788
Definition: symbol.h:55
const struct hist_iter_ops * ops
Definition: hist.h:118
static int perf_top__key_mapped(struct perf_top *top, int c)
Definition: builtin-top.c:422
int parse_filter_percentage(const struct option *opt __maybe_unused, const char *arg, int unset __maybe_unused)
Definition: hist.c:2539
static void __zero_source_counters(struct hist_entry *he)
Definition: builtin-top.c:149
#define isdigit(x)
Definition: sane_ctype.h:34
Definition: hist.h:71
int realtime_prio
Definition: top.h:39
const char * sort_order
Definition: sort.c:27
u64 guest_kernel_samples
Definition: top.h:28
size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows, int max_cols, float min_pcnt, FILE *fp, bool use_callchain)
Definition: hist.c:756
bool show_total_period
Definition: symbol.h:93
static int perf_evlist__add_default(struct perf_evlist *evlist)
Definition: evlist.h:74
struct perf_evlist * evlist
Definition: top.h:18
void sighandler_dump_stack(int sig)
Definition: debug.c:278
int callchain_register_param(struct callchain_param *param)
Definition: callchain.c:494
u8 cpumode
Definition: event.h:207
u64 end
Definition: map.h:29
void(* timer)(void *arg)
Definition: hist.h:423
struct machines machines
Definition: session.h:24
int sysctl__max_stack(void)
Definition: util.c:65
int symbol__annotate(struct symbol *sym, struct map *map, struct perf_evsel *evsel, size_t privsize, struct annotation_options *options, struct arch **parch)
Definition: annotate.c:1810
struct perf_evlist * perf_evlist__new(void)
Definition: evlist.c:54
struct perf_event_attr attr
Definition: evsel.h:93
bool report_hierarchy
Definition: symbol.h:93
Definition: target.h:8
int parse_callchain_top_opt(const char *arg)
Definition: callchain.c:238
int hist_entry_iter__add(struct hist_entry_iter *iter, struct addr_location *al, int max_stack_depth, void *arg)
Definition: hist.c:1036
static volatile int resize
Definition: builtin-top.c:80
int record_callchain_opt(const struct option *opt, const char *arg __maybe_unused, int unset __maybe_unused)
static void perf_top__sort_new_samples(void *arg)
Definition: builtin-top.c:550
int parse_branch_stack(const struct option *opt, const char *str, int unset)
static void display_sig(int sig __maybe_unused)
Definition: builtin-top.c:616