builtin-top.c 39.8 KB
Newer Older
1
/*
2 3 4 5 6 7
 * builtin-top.c
 *
 * Builtin top command: Display a continuously updated profile of
 * any workload, CPU or specific PID.
 *
 * 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 11 12 13 14 15 16 17 18
 *
 * Improvements and fixes by:
 *
 *   Arjan van de Ven <arjan@linux.intel.com>
 *   Yanmin Zhang <yanmin.zhang@intel.com>
 *   Wu Fengguang <fengguang.wu@intel.com>
 *   Mike Galbraith <efault@gmx.de>
 *   Paul Mackerras <paulus@samba.org>
 *
 * 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 33
#include "util/session.h"
#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"
45
#include "util/parse-branch-options.h"
46
#include "arch/common.h"
47

48 49
#include "util/debug.h"

50
#include <assert.h>
51
#include <elf.h>
52
#include <fcntl.h>
53

54
#include <stdio.h>
55 56
#include <termios.h>
#include <unistd.h>
57
#include <inttypes.h>
58

59 60 61
#include <errno.h>
#include <time.h>
#include <sched.h>
62
#include <signal.h>
63 64 65

#include <sys/syscall.h>
#include <sys/ioctl.h>
66
#include <poll.h>
67 68 69
#include <sys/prctl.h>
#include <sys/wait.h>
#include <sys/uio.h>
70
#include <sys/utsname.h>
71 72
#include <sys/mman.h>

73
#include <linux/stringify.h>
74
#include <linux/time64.h>
75 76
#include <linux/types.h>

77 78
#include "sane_ctype.h"

79
static volatile int done;
80
static volatile int resize;
81

82 83
#define HEADER_LINE_NR  5

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 92
	resize = 1;
}
93

94 95
static void perf_top__resize(struct perf_top *top)
{
96 97
	get_term_dimensions(&top->winsize);
	perf_top__update_print_entries(top);
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 110
		return -1;

111 112
	sym = he->ms.sym;
	map = he->ms.map;
113 114 115 116

	/*
	 * We can't annotate with just /proc/kallsyms
	 */
117 118
	if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
	    !dso__is_kcore(map->dso)) {
119 120 121
		pr_err("Can't annotate %s: No vmlinux file was found in the "
		       "path\n", sym->name);
		sleep(1);
122
		return -1;
123 124
	}

125 126
	notes = symbol__annotation(sym);
	pthread_mutex_lock(&notes->lock);
127

128
	if (!symbol__hists(sym, top->evlist->nr_entries)) {
129
		pthread_mutex_unlock(&notes->lock);
130 131
		pr_err("Not enough memory for annotating '%s' symbol!\n",
		       sym->name);
132
		sleep(1);
133
		return err;
134
	}
135

136
	err = symbol__annotate(sym, map, evsel, 0, NULL);
137
	if (err == 0) {
138
		top->sym_filter_entry = he;
139 140 141 142
	} else {
		char msg[BUFSIZ];
		symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
		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;
152
	symbol__annotate_zero_histograms(sym);
153 154
}

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip)
{
	struct utsname uts;
	int err = uname(&uts);

	ui__warning("Out of bounds address found:\n\n"
		    "Addr:   %" PRIx64 "\n"
		    "DSO:    %s %c\n"
		    "Map:    %" PRIx64 "-%" PRIx64 "\n"
		    "Symbol: %" PRIx64 "-%" PRIx64 " %c %s\n"
		    "Arch:   %s\n"
		    "Kernel: %s\n"
		    "Tools:  %s\n\n"
		    "Not all samples will be on the annotation output.\n\n"
		    "Please report to linux-kernel@vger.kernel.org\n",
		    ip, map->dso->long_name, dso__symtab_origin(map->dso),
		    map->start, map->end, sym->start, sym->end,
		    sym->binding == STB_GLOBAL ? 'g' :
		    sym->binding == STB_LOCAL  ? 'l' : 'w', sym->name,
		    err ? "[unknown]" : uts.machine,
		    err ? "[unknown]" : uts.release, perf_version_string);
	if (use_browser <= 0)
		sleep(5);
178

179 180 181
	map->erange_warned = true;
}

182 183
static void perf_top__record_precise_ip(struct perf_top *top,
					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 192 193
	if (sym == NULL || (use_browser == 0 &&
			    (top->sym_filter_entry == NULL ||
			     top->sym_filter_entry->ms.sym != sym)))
194 195
		return;

196 197 198
	notes = symbol__annotation(sym);

	if (pthread_mutex_trylock(&notes->lock))
199 200
		return;

201
	err = hist_entry__inc_addr_samples(he, sample, evsel, ip);
202

203
	pthread_mutex_unlock(&notes->lock);
204

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
	if (unlikely(err)) {
		/*
		 * This function is now called with he->hists->lock held.
		 * Release it before going to sleep.
		 */
		pthread_mutex_unlock(&he->hists->lock);

		if (err == -ERANGE && !he->ms.map->erange_warned)
			ui__warn_map_erange(he->ms.map, sym, ip);
		else if (err == -ENOMEM) {
			pr_err("Not enough memory for annotating '%s' symbol!\n",
			       sym->name);
			sleep(1);
		}

		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 234
		return;

235
	symbol = he->ms.sym;
236 237 238 239
	notes = symbol__annotation(symbol);

	pthread_mutex_lock(&notes->lock);

240 241
	symbol__calc_percent(symbol, evsel);

242 243
	if (notes->src == NULL)
		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->sym_pcnt_filter);
247

248
	more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel,
249
				       0, top->sym_pcnt_filter, top->print_entries, 4);
250 251 252 253 254 255 256

	if (top->evlist->enabled) {
		if (top->zero)
			symbol__annotate_zero_histogram(symbol, top->sym_evsel->idx);
		else
			symbol__annotate_decay_histogram(symbol, top->sym_evsel->idx);
	}
257
	if (more != 0)
258
		printf("%d lines not displayed, maybe increase display entries [e]\n", more);
259 260
out_unlock:
	pthread_mutex_unlock(&notes->lock);
261
}
262

263
static void perf_top__print_sym_table(struct perf_top *top)
264
{
265 266
	char bf[160];
	int printed = 0;
267
	const int win_width = top->winsize.ws_col - 1;
268 269
	struct perf_evsel *evsel = top->sym_evsel;
	struct hists *hists = evsel__hists(evsel);
270

271
	puts(CONSOLE_CLEAR);
272

273
	perf_top__header_snprintf(top, bf, sizeof(bf));
274
	printf("%s\n", bf);
275

276
	perf_top__reset_sample_counters(top);
277

278
	printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
279

280 281 282
	if (!top->record_opts.overwrite &&
	    (hists->stats.nr_lost_warned !=
	    hists->stats.nr_events[PERF_RECORD_LOST])) {
283 284
		hists->stats.nr_lost_warned =
			      hists->stats.nr_events[PERF_RECORD_LOST];
285 286
		color_fprintf(stdout, PERF_COLOR_RED,
			      "WARNING: LOST %d chunks, Check IO/CPU overload",
287
			      hists->stats.nr_lost_warned);
288
		++printed;
289 290
	}

291 292
	if (top->sym_filter_entry) {
		perf_top__show_details(top);
293 294 295
		return;
	}

296 297 298 299 300 301 302
	if (top->evlist->enabled) {
		if (top->zero) {
			hists__delete_entries(hists);
		} else {
			hists__decay_entries(hists, top->hide_user_symbols,
					     top->hide_kernel_symbols);
		}
303 304
	}

305
	hists__collapse_resort(hists, NULL);
306
	perf_evsel__output_resort(evsel, NULL);
307

308
	hists__output_recalc_col_len(hists, top->print_entries - printed);
309
	putchar('\n');
310
	hists__fprintf(hists, false, top->print_entries - printed, win_width,
311
		       top->min_percent, stdout, symbol_conf.use_callchain);
312 313
}

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
static void prompt_integer(int *target, const char *msg)
{
	char *buf = malloc(0), *p;
	size_t dummy = 0;
	int tmp;

	fprintf(stdout, "\n%s: ", msg);
	if (getline(&buf, &dummy, stdin) < 0)
		return;

	p = strchr(buf, '\n');
	if (p)
		*p = 0;

	p = buf;
	while(*p) {
		if (!isdigit(*p))
			goto out_free;
		p++;
	}
	tmp = strtoul(buf, NULL, 10);
	*target = tmp;
out_free:
	free(buf);
}

static void prompt_percent(int *target, const char *msg)
{
	int tmp = 0;

	prompt_integer(&tmp, msg);
	if (tmp >= 0 && tmp <= 100)
		*target = tmp;
}

349
static void perf_top__prompt_symbol(struct perf_top *top, const char *msg)
350 351
{
	char *buf = malloc(0), *p;
352
	struct hist_entry *syme = top->sym_filter_entry, *n, *found = NULL;
353
	struct hists *hists = evsel__hists(top->sym_evsel);
354
	struct rb_node *next;
355 356 357 358 359
	size_t dummy = 0;

	/* zero counters of active symbol */
	if (syme) {
		__zero_source_counters(syme);
360
		top->sym_filter_entry = NULL;
361 362 363 364 365 366 367 368 369 370
	}

	fprintf(stdout, "\n%s: ", msg);
	if (getline(&buf, &dummy, stdin) < 0)
		goto out_free;

	p = strchr(buf, '\n');
	if (p)
		*p = 0;

371
	next = rb_first(&hists->entries);
372 373 374 375
	while (next) {
		n = rb_entry(next, struct hist_entry, rb_node);
		if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) {
			found = n;
376 377
			break;
		}
378
		next = rb_next(&n->rb_node);
379 380 381
	}

	if (!found) {
382
		fprintf(stderr, "Sorry, %s is not active.\n", buf);
383 384
		sleep(1);
	} else
385
		perf_top__parse_source(top, found);
386 387 388 389 390

out_free:
	free(buf);
}

391
static void perf_top__print_mapped_keys(struct perf_top *top)
392
{
393 394
	char *name = NULL;

395 396
	if (top->sym_filter_entry) {
		struct symbol *sym = top->sym_filter_entry->ms.sym;
397 398 399 400
		name = sym->name;
	}

	fprintf(stdout, "\nMapped keys:\n");
401 402
	fprintf(stdout, "\t[d]     display refresh delay.             \t(%d)\n", top->delay_secs);
	fprintf(stdout, "\t[e]     display entries (lines).           \t(%d)\n", top->print_entries);
403

404
	if (top->evlist->nr_entries > 1)
405
		fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", perf_evsel__name(top->sym_evsel));
406

407
	fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", top->count_filter);
408

409
	fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", top->sym_pcnt_filter);
410 411
	fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
	fprintf(stdout, "\t[S]     stop annotation.\n");
412

413
	fprintf(stdout,
414
		"\t[K]     hide kernel symbols.             \t(%s)\n",
415
		top->hide_kernel_symbols ? "yes" : "no");
416 417
	fprintf(stdout,
		"\t[U]     hide user symbols.               \t(%s)\n",
418 419
		top->hide_user_symbols ? "yes" : "no");
	fprintf(stdout, "\t[z]     toggle sample zeroing.             \t(%d)\n", top->zero ? 1 : 0);
420 421 422
	fprintf(stdout, "\t[qQ]    quit.\n");
}

423
static int perf_top__key_mapped(struct perf_top *top, int c)
424 425 426 427 428 429 430 431
{
	switch (c) {
		case 'd':
		case 'e':
		case 'f':
		case 'z':
		case 'q':
		case 'Q':
432 433
		case 'K':
		case 'U':
434 435 436
		case 'F':
		case 's':
		case 'S':
437 438
			return 1;
		case 'E':
439
			return top->evlist->nr_entries > 1 ? 1 : 0;
440 441
		default:
			break;
442 443 444
	}

	return 0;
445 446
}

447
static bool perf_top__handle_keypress(struct perf_top *top, int c)
448
{
449 450
	bool ret = true;

451
	if (!perf_top__key_mapped(top, c)) {
452
		struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
453
		struct termios save;
454

455
		perf_top__print_mapped_keys(top);
456 457 458
		fprintf(stdout, "\nEnter selection, or unmapped key to continue: ");
		fflush(stdout);

459
		set_term_quiet_input(&save);
460 461 462 463 464

		poll(&stdin_poll, 1, -1);
		c = getc(stdin);

		tcsetattr(0, TCSAFLUSH, &save);
465
		if (!perf_top__key_mapped(top, c))
466
			return ret;
467 468
	}

469 470
	switch (c) {
		case 'd':
471 472 473
			prompt_integer(&top->delay_secs, "Enter display delay");
			if (top->delay_secs < 1)
				top->delay_secs = 1;
474 475
			break;
		case 'e':
476 477
			prompt_integer(&top->print_entries, "Enter display entries (lines)");
			if (top->print_entries == 0) {
478
				perf_top__resize(top);
479
				signal(SIGWINCH, winch_sig);
480
			} else {
481
				signal(SIGWINCH, SIG_DFL);
482
			}
483 484
			break;
		case 'E':
485
			if (top->evlist->nr_entries > 1) {
486 487 488
				/* Select 0 as the default event: */
				int counter = 0;

489
				fprintf(stderr, "\nAvailable events:");
490

491
				evlist__for_each_entry(top->evlist, top->sym_evsel)
492
					fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel));
493

494
				prompt_integer(&counter, "Enter details event counter");
495

496
				if (counter >= top->evlist->nr_entries) {
497
					top->sym_evsel = perf_evlist__first(top->evlist);
498
					fprintf(stderr, "Sorry, no such event, using %s.\n", perf_evsel__name(top->sym_evsel));
499
					sleep(1);
500
					break;
501
				}
502
				evlist__for_each_entry(top->evlist, top->sym_evsel)
503
					if (top->sym_evsel->idx == counter)
504
						break;
505
			} else
506
				top->sym_evsel = perf_evlist__first(top->evlist);
507 508
			break;
		case 'f':
509
			prompt_integer(&top->count_filter, "Enter display event count filter");
510 511
			break;
		case 'F':
512 513
			prompt_percent(&top->sym_pcnt_filter,
				       "Enter details display event filter (percent)");
514
			break;
515
		case 'K':
516
			top->hide_kernel_symbols = !top->hide_kernel_symbols;
517
			break;
518 519 520
		case 'q':
		case 'Q':
			printf("exiting.\n");
521 522
			if (top->dump_symtab)
				perf_session__fprintf_dsos(top->session, stderr);
523 524
			ret = false;
			break;
525
		case 's':
526
			perf_top__prompt_symbol(top, "Enter details symbol");
527 528
			break;
		case 'S':
529
			if (!top->sym_filter_entry)
530 531
				break;
			else {
532
				struct hist_entry *syme = top->sym_filter_entry;
533

534
				top->sym_filter_entry = NULL;
535 536 537
				__zero_source_counters(syme);
			}
			break;
538
		case 'U':
539
			top->hide_user_symbols = !top->hide_user_symbols;
540
			break;
541
		case 'z':
542
			top->zero = !top->zero;
543
			break;
544 545
		default:
			break;
546
	}
547 548

	return ret;
549 550
}

551 552 553
static void perf_top__sort_new_samples(void *arg)
{
	struct perf_top *t = arg;
554
	struct perf_evsel *evsel = t->sym_evsel;
555 556
	struct hists *hists;

557 558 559 560 561
	perf_top__reset_sample_counters(t);

	if (t->evlist->selected != NULL)
		t->sym_evsel = t->evlist->selected;

562
	hists = evsel__hists(evsel);
563

564 565 566 567 568 569 570
	if (t->evlist->enabled) {
		if (t->zero) {
			hists__delete_entries(hists);
		} else {
			hists__decay_entries(hists, t->hide_user_symbols,
					     t->hide_kernel_symbols);
		}
571 572
	}

573
	hists__collapse_resort(hists, NULL);
574
	perf_evsel__output_resort(evsel, NULL);
575 576
}

577
static void *display_thread_tui(void *arg)
578
{
579
	struct perf_evsel *pos;
580
	struct perf_top *top = arg;
581
	const char *help = "For a higher level overview, try: perf top --sort comm,dso";
582 583 584 585 586
	struct hist_browser_timer hbt = {
		.timer		= perf_top__sort_new_samples,
		.arg		= top,
		.refresh	= top->delay_secs,
	};
587

588 589 590 591 592 593 594
	/* In order to read symbols from other namespaces perf to  needs to call
	 * setns(2).  This isn't permitted if the struct_fs has multiple users.
	 * unshare(2) the fs so that we may continue to setns into namespaces
	 * that we're observing.
	 */
	unshare(CLONE_FS);

595
	perf_top__sort_new_samples(top);
596 597 598 599 600 601

	/*
	 * Initialize the uid_filter_str, in the future the TUI will allow
	 * Zooming in/out UIDs. For now juse use whatever the user passed
	 * via --uid.
	 */
602
	evlist__for_each_entry(top->evlist, pos) {
603 604 605
		struct hists *hists = evsel__hists(pos);
		hists->uid_filter_str = top->record_opts.target.uid_str;
	}
606

607 608
	perf_evlist__tui_browse_hists(top->evlist, help, &hbt,
				      top->min_percent,
609 610
				      &top->session->header.env,
				      !top->record_opts.overwrite);
611

612
	done = 1;
613 614 615
	return NULL;
}

616 617 618 619 620 621 622
static void display_sig(int sig __maybe_unused)
{
	done = 1;
}

static void display_setup_sig(void)
{
623 624
	signal(SIGSEGV, sighandler_dump_stack);
	signal(SIGFPE, sighandler_dump_stack);
625 626 627 628 629
	signal(SIGINT,  display_sig);
	signal(SIGQUIT, display_sig);
	signal(SIGTERM, display_sig);
}

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 636
	int delay_msecs, c;

637 638 639 640 641 642 643
	/* In order to read symbols from other namespaces perf to  needs to call
	 * setns(2).  This isn't permitted if the struct_fs has multiple users.
	 * unshare(2) the fs so that we may continue to setns into namespaces
	 * that we're observing.
	 */
	unshare(CLONE_FS);

644
	display_setup_sig();
645
	pthread__unblock_sigwinch();
646
repeat:
647
	delay_msecs = top->delay_secs * MSEC_PER_SEC;
648
	set_term_quiet_input(&save);
649 650
	/* trash return*/
	getc(stdin);
651

652
	while (!done) {
653
		perf_top__print_sym_table(top);
654 655 656 657 658 659 660 661 662 663
		/*
		 * Either timeout expired or we got an EINTR due to SIGWINCH,
		 * refresh screen in both cases.
		 */
		switch (poll(&stdin_poll, 1, delay_msecs)) {
		case 0:
			continue;
		case -1:
			if (errno == EINTR)
				continue;
664
			__fallthrough;
665
		default:
666 667 668 669 670 671
			c = getc(stdin);
			tcsetattr(0, TCSAFLUSH, &save);

			if (perf_top__handle_keypress(top, c))
				goto repeat;
			done = 1;
672 673
		}
	}
674

675
	tcsetattr(0, TCSAFLUSH, &save);
676 677 678
	return NULL;
}

679 680 681 682 683 684 685 686
static int hist_iter__top_callback(struct hist_entry_iter *iter,
				   struct addr_location *al, bool single,
				   void *arg)
{
	struct perf_top *top = arg;
	struct hist_entry *he = iter->he;
	struct perf_evsel *evsel = iter->evsel;

687
	if (perf_hpp_list.sym && single)
688
		perf_top__record_precise_ip(top, he, iter->sample, evsel, al->addr);
689

690 691
	hist__account_cycles(iter->sample->branch_stack, al, iter->sample,
		     !(top->record_opts.branch_stack & PERF_SAMPLE_BRANCH_ANY));
692 693 694
	return 0;
}

695 696
static void perf_event__process_sample(struct perf_tool *tool,
				       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 707 708
		static struct intlist *seen;

		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 714
				sample->pid);
			intlist__add(seen, sample->pid);
715
		}
716 717 718
		return;
	}

719
	if (!machine) {
720
		pr_err("%u unprocessable samples recorded.\r",
721
		       top->session->evlist->stats.nr_unprocessable_samples++);
722 723 724
		return;
	}

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 &&
732 733
	    symbol_conf.kptr_restrict &&
	    al.cpumode == PERF_RECORD_MISC_KERNEL) {
734 735
		if (!perf_evlist__exclude_kernel(top->session->evlist)) {
			ui__warning(
736 737 738
"Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
"Check /proc/sys/kernel/kptr_restrict.\n\n"
"Kernel%s samples will not be resolved.\n",
739
			  al.map && map__has_symbols(al.map) ?
740
			  " modules" : "");
741 742 743
			if (use_browser <= 0)
				sleep(5);
		}
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 751 752 753 754 755 756 757 758 759
		/*
		 * As we do lazy loading of symtabs we only will know if the
		 * specified vmlinux file is invalid when we actually have a
		 * hit in kernel space and then try to load it. So if we get
		 * here and there are _no_ symbols in the DSO backing the
		 * kernel map, bail out.
		 *
		 * We may never get here, for instance, if we use -K/
		 * --hide-kernel-symbols, even if the user specifies an
		 * invalid --vmlinux ;-)
		 */
760
		if (!machine->kptr_restrict_warned && !top->vmlinux_warned &&
761
		    __map__is_kernel(al.map) && map__has_symbols(al.map)) {
762
			if (symbol_conf.vmlinux_name) {
763 764 765 766
				char serr[256];
				dso__strerror_load(al.map->dso, serr, sizeof(serr));
				ui__warning("The %s file can't be used: %s\n%s",
					    symbol_conf.vmlinux_name, serr, msg);
767 768 769 770 771 772 773
			} else {
				ui__warning("A vmlinux file was not found.\n%s",
					    msg);
			}

			if (use_browser <= 0)
				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 782 783
			.evsel		= evsel,
			.sample 	= sample,
			.add_entry_cb 	= hist_iter__top_callback,
784
		};
785

786 787 788 789
		if (symbol_conf.cumulate_callchain)
			iter.ops = &hist_iter_cumulative;
		else
			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 795
		if (err < 0)
			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 806
	struct record_opts *opts = &top->record_opts;
	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 818
		return;

819
	while ((event = perf_mmap__read_event(md)) != NULL) {
820
		ret = perf_evlist__parse_sample(evlist, event, &sample);
821 822
		if (ret) {
			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 828
		assert(evsel != NULL);

829
		if (event->header.type == PERF_RECORD_SAMPLE)
830
			++top->samples;
831

832
		switch (sample.cpumode) {
833
		case PERF_RECORD_MISC_USER:
834 835
			++top->us_samples;
			if (top->hide_user_symbols)
836
				goto next_event;
837
			machine = &session->machines.host;
838 839
			break;
		case PERF_RECORD_MISC_KERNEL:
840 841
			++top->kernel_samples;
			if (top->hide_kernel_symbols)
842
				goto next_event;
843
			machine = &session->machines.host;
844 845
			break;
		case PERF_RECORD_MISC_GUEST_KERNEL:
846
			++top->guest_kernel_samples;
847 848
			machine = perf_session__find_machine(session,
							     sample.pid);
849 850
			break;
		case PERF_RECORD_MISC_GUEST_USER:
851
			++top->guest_us_samples;
852 853 854 855
			/*
			 * TODO: we don't process guest user from host side
			 * except simple counting.
			 */
856
			goto next_event;
857 858 859 860 861
		default:
			if (event->header.type == PERF_RECORD_SAMPLE)
				goto next_event;
			machine = &session->machines.host;
			break;
862 863 864
		}


865 866 867 868
		if (event->header.type == PERF_RECORD_SAMPLE) {
			perf_event__process_sample(&top->tool, event, evsel,
						   &sample, machine);
		} 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 877

	perf_mmap__read_done(md);
878 879
}

880
static void perf_top__mmap_read(struct perf_top *top)
881
{
882 883
	bool overwrite = top->record_opts.overwrite;
	struct perf_evlist *evlist = top->evlist;
884
	unsigned long long start, end;
885 886
	int i;

887
	start = rdclock();
888 889 890
	if (overwrite)
		perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_DATA_PENDING);

891 892
	for (i = 0; i < top->evlist->nr_mmaps; i++)
		perf_top__mmap_read_idx(top, i);
893 894 895 896 897

	if (overwrite) {
		perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
		perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_RUNNING);
	}
898 899 900 901 902 903 904
	end = rdclock();

	if ((end - start) > (unsigned long long)top->delay_secs * NSEC_PER_SEC)
		ui__warning("Too slow to read ring buffer.\n"
			    "Please try increasing the period (-c) or\n"
			    "decreasing the freq (-F) or\n"
			    "limiting the number of CPUs (-C)\n");
905 906
}

907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
/*
 * Check per-event overwrite term.
 * perf top should support consistent term for all events.
 * - All events don't have per-event term
 *   E.g. "cpu/cpu-cycles/,cpu/instructions/"
 *   Nothing change, return 0.
 * - All events have same per-event term
 *   E.g. "cpu/cpu-cycles,no-overwrite/,cpu/instructions,no-overwrite/
 *   Using the per-event setting to replace the opts->overwrite if
 *   they are different, then return 0.
 * - Events have different per-event term
 *   E.g. "cpu/cpu-cycles,overwrite/,cpu/instructions,no-overwrite/"
 *   Return -1
 * - Some of the event set per-event term, but some not.
 *   E.g. "cpu/cpu-cycles/,cpu/instructions,no-overwrite/"
 *   Return -1
 */
static int perf_top__overwrite_check(struct perf_top *top)
{
	struct record_opts *opts = &top->record_opts;
	struct perf_evlist *evlist = top->evlist;
	struct perf_evsel_config_term *term;
	struct list_head *config_terms;
	struct perf_evsel *evsel;
	int set, overwrite = -1;

	evlist__for_each_entry(evlist, evsel) {
		set = -1;
		config_terms = &evsel->config_terms;
		list_for_each_entry(term, config_terms, list) {
			if (term->type == PERF_EVSEL__CONFIG_TERM_OVERWRITE)
				set = term->val.overwrite ? 1 : 0;
		}

		/* no term for current and previous event (likely) */
		if ((overwrite < 0) && (set < 0))
			continue;

		/* has term for both current and previous event, compare */
		if ((overwrite >= 0) && (set >= 0) && (overwrite != set))
			return -1;

		/* no term for current event but has term for previous one */
		if ((overwrite >= 0) && (set < 0))
			return -1;

		/* has term for current event */
		if ((overwrite < 0) && (set >= 0)) {
			/* if it's first event, set overwrite */
			if (evsel == perf_evlist__first(evlist))
				overwrite = set;
			else
				return -1;
		}
	}

	if ((overwrite >= 0) && (opts->overwrite != overwrite))
		opts->overwrite = overwrite;

	return 0;
}

969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
static int perf_top_overwrite_fallback(struct perf_top *top,
				       struct perf_evsel *evsel)
{
	struct record_opts *opts = &top->record_opts;
	struct perf_evlist *evlist = top->evlist;
	struct perf_evsel *counter;

	if (!opts->overwrite)
		return 0;

	/* only fall back when first event fails */
	if (evsel != perf_evlist__first(evlist))
		return 0;

	evlist__for_each_entry(evlist, counter)
		counter->attr.write_backward = false;
	opts->overwrite = false;
986
	pr_debug2("fall back to non-overwrite mode\n");
987 988 989
	return 1;
}

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 998 999 1000 1001 1002
	if (perf_top__overwrite_check(top)) {
		ui__error("perf top only support consistent per-event "
			  "overwrite setting for all events\n");
		goto out_err;
	}

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 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023

			/*
			 * Specially handle overwrite fall back.
			 * Because perf top is the only tool which has
			 * overwrite mode by default, support
			 * both overwrite and non-overwrite mode, and
			 * require consistent mode for all events.
			 *
			 * May move it to generic code with more tools
			 * have similar attribute.
			 */
			if (perf_missing_features.write_backward &&
			    perf_top_overwrite_fallback(top, counter))
				goto try_again;

1024
			if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
1025
				if (verbose > 0)
1026
					ui__warning("%s\n", msg);
1027 1028
				goto try_again;
			}
1029

1030 1031 1032
			perf_evsel__open_strerror(counter, &opts->target,
						  errno, msg, sizeof(msg));
			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 1041 1042
		goto out_err;
	}

1043
	return 0;
1044 1045

out_err:
1046
	return -1;
1047 1048
}

1049
static int callchain_param__setup_sample_type(struct callchain_param *callchain)
1050
{
1051
	if (!perf_hpp_list.sym) {
1052
		if (callchain->enabled) {
1053
			ui__error("Selected -g but \"sym\" not present in --sort/-s.");
1054 1055
			return -EINVAL;
		}
1056 1057
	} else if (callchain->mode != CHAIN_NONE) {
		if (callchain_register_param(callchain) < 0) {
1058
			ui__error("Can't register callchain params.\n");
1059 1060 1061 1062 1063 1064 1065
			return -EINVAL;
		}
	}

	return 0;
}

1066
static int __cmd_top(struct perf_top *top)
1067
{
1068 1069 1070 1071
	char msg[512];
	struct perf_evsel *pos;
	struct perf_evsel_config_term *err_term;
	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 (!objdump_path) {
1081
		ret = perf_env__lookup_objdump(&top->session->header.env);
1082 1083 1084 1085
		if (ret)
			goto out_delete;
	}

1086
	ret = callchain_param__setup_sample_type(&callchain_param);
1087 1088 1089
	if (ret)
		goto out_delete;

1090
	if (perf_session__register_idle_thread(top->session) < 0)
1091 1092
		goto out_delete;

1093 1094
	if (top->nr_threads_synthesize > 1)
		perf_set_multithreaded();
1095

1096
	machine__synthesize_threads(&top->session->machines.host, &opts->target,
1097 1098
				    top->evlist->threads, false,
				    opts->proc_map_timeout,
1099
				    top->nr_threads_synthesize);
1100

1101 1102
	if (top->nr_threads_synthesize > 1)
		perf_set_singlethreaded();
1103

1104
	if (perf_hpp_list.socket) {
1105 1106 1107 1108 1109
		ret = perf_env__read_cpu_topology_map(&perf_env);
		if (ret < 0)
			goto out_err_cpu_topo;
	}

1110 1111 1112 1113
	ret = perf_top__start_counters(top);
	if (ret)
		goto out_delete;

1114 1115
	ret = perf_evlist__apply_drv_configs(evlist, &pos, &err_term);
	if (ret) {
1116
		pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
1117 1118 1119 1120 1121
			err_term->val.drv_cfg, perf_evsel__name(pos), errno,
			str_error_r(errno, msg, sizeof(msg)));
		goto out_delete;
	}

1122
	top->session->evlist = top->evlist;
1123
	perf_session__set_id_hdr_size(top->session);
1124

1125 1126 1127 1128 1129 1130 1131 1132
	/*
	 * When perf is starting the traced process, all the events (apart from
	 * group members) have enable_on_exec=1 set, so don't spoil it by
	 * prematurely enabling them.
	 *
	 * XXX 'top' still doesn't start workloads like record, trace, but should,
	 * so leave the check here.
	 */
1133
        if (!target__none(&opts->target))
1134 1135
                perf_evlist__enable(top->evlist);

1136
	/* Wait for a minimal set of events before starting the snapshot */
1137
	perf_evlist__poll(top->evlist, 100);
1138

1139
	perf_top__mmap_read(top);
1140

1141
	ret = -1;
1142
	if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
1143
							    display_thread), top)) {
1144
		ui__error("Could not create display thread.\n");
1145
		goto out_delete;
1146 1147
	}

1148
	if (top->realtime_prio) {
1149 1150
		struct sched_param param;

1151
		param.sched_priority = top->realtime_prio;
1152
		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
1153
			ui__error("Could not set realtime priority.\n");
1154
			goto out_join;
1155 1156 1157
		}
	}

1158
	while (!done) {
1159
		u64 hits = top->samples;
1160

1161
		perf_top__mmap_read(top);
1162

1163
		if (opts->overwrite || (hits == top->samples))
1164
			ret = perf_evlist__poll(top->evlist, 100);
1165 1166 1167 1168 1169

		if (resize) {
			perf_top__resize(top);
			resize = 0;
		}
1170 1171
	}

1172
	ret = 0;
1173 1174
out_join:
	pthread_join(thread, NULL);
1175
out_delete:
1176 1177
	perf_session__delete(top->session);
	top->session = NULL;
1178

1179
	return ret;
1180 1181 1182

out_err_cpu_topo: {
	char errbuf[BUFSIZ];
1183
	const char *err = str_error_r(-ret, errbuf, sizeof(errbuf));
1184 1185 1186 1187

	ui__error("Could not read the CPU topology map: %s\n", err);
	goto out_delete;
}
1188 1189 1190
}

static int
1191
callchain_opt(const struct option *opt, const char *arg, int unset)
1192 1193
{
	symbol_conf.use_callchain = true;
1194 1195
	return record_callchain_opt(opt, arg, unset);
}
1196

1197 1198 1199
static int
parse_callchain_opt(const struct option *opt, const char *arg, int unset)
{
1200
	struct callchain_param *callchain = opt->value;
1201

1202 1203
	callchain->enabled = !unset;
	callchain->record_mode = CALLCHAIN_FP;
1204 1205 1206 1207 1208 1209

	/*
	 * --no-call-graph
	 */
	if (unset) {
		symbol_conf.use_callchain = false;
1210
		callchain->record_mode = CALLCHAIN_NONE;
1211 1212 1213 1214
		return 0;
	}

	return parse_callchain_top_opt(arg);
1215
}
1216

1217
static int perf_top_config(const char *var, const char *value, void *cb __maybe_unused)
1218
{
1219 1220 1221 1222
	if (!strcmp(var, "top.call-graph")) {
		var = "call-graph.record-mode";
		return perf_default_config(var, value, cb);
	}
1223 1224 1225 1226
	if (!strcmp(var, "top.children")) {
		symbol_conf.cumulate_callchain = perf_config_bool(var, value);
		return 0;
	}
1227

1228
	return 0;
1229 1230
}

1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
static int
parse_percent_limit(const struct option *opt, const char *arg,
		    int unset __maybe_unused)
{
	struct perf_top *top = opt->value;

	top->min_percent = strtof(arg, NULL);
	return 0;
}

1241 1242
const char top_callchain_help[] = CALLCHAIN_RECORD_HELP CALLCHAIN_REPORT_HELP
	"\n\t\t\t\tDefault: fp,graph,0.5,caller,function";
1243

1244
int cmd_top(int argc, const char **argv)
1245
{
1246
	char errbuf[BUFSIZ];
1247 1248 1249
	struct perf_top top = {
		.count_filter	     = 5,
		.delay_secs	     = 2,
1250 1251 1252 1253 1254
		.record_opts = {
			.mmap_pages	= UINT_MAX,
			.user_freq	= UINT_MAX,
			.user_interval	= ULLONG_MAX,
			.freq		= 4000, /* 4 KHz */
1255
			.target		= {
1256 1257
				.uses_mmap   = true,
			},
1258
			.proc_map_timeout    = 500,
1259
			.overwrite	= 1,
1260
		},
1261
		.max_stack	     = sysctl__max_stack(),
1262
		.sym_pcnt_filter     = 5,
1263
		.nr_threads_synthesize = UINT_MAX,
1264
	};
1265
	struct record_opts *opts = &top.record_opts;
1266
	struct target *target = &opts->target;
1267
	const struct option options[] = {
1268
	OPT_CALLBACK('e', "event", &top.evlist, "event",
1269
		     "event selector. use 'perf list' to list available events",
1270
		     parse_events_option),
1271 1272
	OPT_U64('c', "count", &opts->user_interval, "event period to sample"),
	OPT_STRING('p', "pid", &target->pid, "pid",
1273
		    "profile events on existing process id"),
1274
	OPT_STRING('t', "tid", &target->tid, "tid",
1275
		    "profile events on existing thread id"),
1276
	OPT_BOOLEAN('a', "all-cpus", &target->system_wide,
1277
			    "system-wide collection from all CPUs"),
1278
	OPT_STRING('C', "cpu", &target->cpu_list, "cpu",
1279
		    "list of cpus to monitor"),
1280 1281
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
1282 1283
	OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
		    "don't load vmlinux even if found"),
1284
	OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols,
1285
		    "hide kernel symbols"),
1286 1287 1288
	OPT_CALLBACK('m', "mmap-pages", &opts->mmap_pages, "pages",
		     "number of mmap data pages",
		     perf_evlist__parse_mmap_pages),
1289
	OPT_INTEGER('r', "realtime", &top.realtime_prio,
1290
		    "collect data with this RT SCHED_FIFO priority"),
1291
	OPT_INTEGER('d', "delay", &top.delay_secs,
1292
		    "number of seconds to delay between refreshes"),
1293
	OPT_BOOLEAN('D', "dump-symtab", &top.dump_symtab,
1294
			    "dump the symbol table used for profiling"),
1295
	OPT_INTEGER('f', "count-filter", &top.count_filter,
1296
		    "only display functions with more events than this"),
1297
	OPT_BOOLEAN(0, "group", &opts->group,
1298
			    "put the counters into a counter group"),
1299 1300
	OPT_BOOLEAN('i', "no-inherit", &opts->no_inherit,
		    "child tasks do not inherit counters"),
1301
	OPT_STRING(0, "sym-annotate", &top.sym_filter, "symbol name",
1302
		    "symbol to annotate"),
1303
	OPT_BOOLEAN('z', "zero", &top.zero, "zero history across updates"),
1304 1305 1306
	OPT_CALLBACK('F', "freq", &top.record_opts, "freq or 'max'",
		     "profile at this frequency",
		      record__parse_freq),
1307
	OPT_INTEGER('E', "entries", &top.print_entries,
1308
		    "display this many functions"),
1309
	OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols,
1310
		    "hide user symbols"),
1311 1312
	OPT_BOOLEAN(0, "tui", &top.use_tui, "Use the TUI interface"),
	OPT_BOOLEAN(0, "stdio", &top.use_stdio, "Use the stdio interface"),
1313
	OPT_INCR('v', "verbose", &verbose,
1314
		    "be more verbose (show counter open errors, etc)"),
1315
	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1316 1317
		   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
		   " Please refer the man page for the complete list."),
1318 1319
	OPT_STRING(0, "fields", &field_order, "key[,keys...]",
		   "output field(s): overhead, period, sample plus all of sort keys"),
1320 1321
	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
		    "Show a column with the number of samples"),
1322
	OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
1323
			   NULL, "enables call-graph recording and display",
1324
			   &callchain_opt),
1325
	OPT_CALLBACK(0, "call-graph", &callchain_param,
1326
		     "record_mode[,record_size],print_type,threshold[,print_limit],order,sort_key[,branch]",
1327
		     top_callchain_help, &parse_callchain_opt),
1328 1329
	OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
		    "Accumulate callchains of children and show total overhead as well"),
1330 1331
	OPT_INTEGER(0, "max-stack", &top.max_stack,
		    "Set the maximum stack depth when parsing the callchain. "
1332
		    "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
1333 1334 1335
	OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
		   "ignore callees of these functions in call graphs",
		   report_parse_ignore_callees_opt),
1336 1337 1338 1339 1340 1341 1342 1343
	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
		    "Show a column with the sum of periods"),
	OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
		   "only consider symbols in these dsos"),
	OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
		   "only consider symbols in these comms"),
	OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
		   "only consider these symbols"),
1344 1345 1346 1347
	OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
		    "Interleave source code with assembly code (default)"),
	OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
		    "Display raw encoding of assembly instructions (default)"),
1348 1349
	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
		    "Enable kernel symbol demangling"),
1350 1351
	OPT_STRING(0, "objdump", &objdump_path, "path",
		    "objdump binary to use for disassembly and annotations"),
1352 1353
	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
1354
	OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
1355 1356
	OPT_CALLBACK(0, "percent-limit", &top, "percent",
		     "Don't show entries under that percent", parse_percent_limit),
1357 1358
	OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
		     "How to display percentage of filtered entries", parse_filter_percentage),
1359 1360 1361
	OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
		   "width[,width...]",
		   "don't try to adjust column width, use these fixed values"),
1362 1363
	OPT_UINTEGER(0, "proc-map-timeout", &opts->proc_map_timeout,
			"per thread proc mmap processing timeout in ms"),
1364 1365 1366 1367 1368 1369
	OPT_CALLBACK_NOOPT('b', "branch-any", &opts->branch_stack,
		     "branch any", "sample any taken branches",
		     parse_branch_stack),
	OPT_CALLBACK('j', "branch-filter", &opts->branch_stack,
		     "branch filter mask", "branch stack filter modes",
		     parse_branch_stack),
1370 1371
	OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,
		    "Show raw trace event output (do not use print fmt or plugins)"),
1372 1373
	OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
		    "Show entries in a hierarchy"),
1374
	OPT_BOOLEAN(0, "force", &symbol_conf.force, "don't complain, do it"),
1375 1376
	OPT_UINTEGER(0, "num-thread-synthesize", &top.nr_threads_synthesize,
			"number of thread to run event synthesize"),
1377
	OPT_END()
1378
	};
1379 1380 1381 1382
	const char * const top_usage[] = {
		"perf top [<options>]",
		NULL
	};
1383 1384 1385 1386
	int status = hists__init();

	if (status < 0)
		return status;
1387

1388
	top.evlist = perf_evlist__new();
1389
	if (top.evlist == NULL)
1390 1391
		return -ENOMEM;

1392 1393 1394
	status = perf_config(perf_top_config, &top);
	if (status)
		return status;
1395

1396 1397 1398 1399
	argc = parse_options(argc, argv, options, top_usage, 0);
	if (argc)
		usage_with_options(top_usage, options);

1400 1401 1402 1403 1404 1405
	if (!top.evlist->nr_entries &&
	    perf_evlist__add_default(top.evlist) < 0) {
		pr_err("Not enough memory for event selector list\n");
		goto out_delete_evlist;
	}

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	if (symbol_conf.report_hierarchy) {
		/* disable incompatible options */
		symbol_conf.event_group = false;
		symbol_conf.cumulate_callchain = false;

		if (field_order) {
			pr_err("Error: --hierarchy and --fields options cannot be used together\n");
			parse_options_usage(top_usage, options, "fields", 0);
			parse_options_usage(NULL, options, "hierarchy", 0);
			goto out_delete_evlist;
		}
	}

1419
	sort__mode = SORT_MODE__TOP;
1420
	/* display thread wants entries to be collapsed in a different tree */
1421
	perf_hpp_list.need_collapse = 1;
1422

1423 1424 1425 1426 1427 1428 1429
	if (top.use_stdio)
		use_browser = 0;
	else if (top.use_tui)
		use_browser = 1;

	setup_browser(false);

1430
	if (setup_sorting(top.evlist) < 0) {
1431 1432 1433 1434 1435
		if (sort_order)
			parse_options_usage(top_usage, options, "s", 1);
		if (field_order)
			parse_options_usage(sort_order ? NULL : top_usage,
					    options, "fields", 0);
1436 1437
		goto out_delete_evlist;
	}
1438

1439
	status = target__validate(target);
1440
	if (status) {
1441
		target__strerror(target, status, errbuf, BUFSIZ);
1442
		ui__warning("%s\n", errbuf);
1443 1444
	}

1445
	status = target__parse_uid(target);
1446 1447
	if (status) {
		int saved_errno = errno;
1448

1449
		target__strerror(target, status, errbuf, BUFSIZ);
1450
		ui__error("%s\n", errbuf);
1451 1452

		status = -saved_errno;
1453
		goto out_delete_evlist;
1454
	}
1455

1456
	if (target__none(target))
1457
		target->system_wide = true;
1458

1459 1460
	if (perf_evlist__create_maps(top.evlist, target) < 0) {
		ui__error("Couldn't create thread/CPU maps: %s\n",
1461
			  errno == ENOENT ? "No such process" : str_error_r(errno, errbuf, sizeof(errbuf)));
1462
		goto out_delete_evlist;
1463
	}
1464

1465 1466
	if (top.delay_secs < 1)
		top.delay_secs = 1;
1467

1468
	if (record_opts__config(opts)) {
1469
		status = -EINVAL;
1470
		goto out_delete_evlist;
1471 1472
	}

1473
	top.sym_evsel = perf_evlist__first(top.evlist);
1474

1475
	if (!callchain_param.enabled) {
1476 1477 1478 1479
		symbol_conf.cumulate_callchain = false;
		perf_hpp__cancel_cumulate();
	}

1480 1481 1482
	if (symbol_conf.cumulate_callchain && !callchain_param.order_set)
		callchain_param.order = ORDER_CALLER;

1483 1484 1485
	status = symbol__annotation_init();
	if (status < 0)
		goto out_delete_evlist;
1486

1487 1488
	annotation_config__init();

1489
	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
1490
	if (symbol__init(NULL) < 0)
1491 1492
		return -1;

1493
	sort__setup_elide(stdout);
1494

1495
	get_term_dimensions(&top.winsize);
1496
	if (top.print_entries == 0) {
1497
		perf_top__update_print_entries(&top);
1498
		signal(SIGWINCH, winch_sig);
1499 1500
	}

1501
	status = __cmd_top(&top);
1502

1503
out_delete_evlist:
1504
	perf_evlist__delete(top.evlist);
1505 1506

	return status;
1507
}
新手
引导
客服 返回
顶部