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