Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 6b118e92cc78ccef7b54a296158d4738fd377bcc

Authored by David Ahern
Committed by Arnaldo Carvalho de Melo
1 parent 70b40c4a43
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

perf kvm top: Limit guest kernel info message to once 

'perf kvm top' shows a continual flurry of:
    Can't find guest [5201]'s kernel information

if it can't find the guest info and with a lot of VMs running a user has no
chance of reading them all. Limit message to once per guest.

Signed-off-by: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1343709095-7089-5-git-send-email-dsahern@gmail.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

Showing 1 changed file with 11 additions and 2 deletions Inline Diff

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