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