186470930SIngo Molnar /* 286470930SIngo Molnar * builtin-top.c 386470930SIngo Molnar * 486470930SIngo Molnar * Builtin top command: Display a continuously updated profile of 586470930SIngo Molnar * any workload, CPU or specific PID. 686470930SIngo Molnar * 786470930SIngo Molnar * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 886470930SIngo Molnar * 986470930SIngo Molnar * Improvements and fixes by: 1086470930SIngo Molnar * 1186470930SIngo Molnar * Arjan van de Ven <arjan@linux.intel.com> 1286470930SIngo Molnar * Yanmin Zhang <yanmin.zhang@intel.com> 1386470930SIngo Molnar * Wu Fengguang <fengguang.wu@intel.com> 1486470930SIngo Molnar * Mike Galbraith <efault@gmx.de> 1586470930SIngo Molnar * Paul Mackerras <paulus@samba.org> 1686470930SIngo Molnar * 1786470930SIngo Molnar * Released under the GPL v2. (and only v2, not any later version) 1886470930SIngo Molnar */ 1986470930SIngo Molnar #include "builtin.h" 2086470930SIngo Molnar 2186470930SIngo Molnar #include "perf.h" 2286470930SIngo Molnar 2386470930SIngo Molnar #include "util/color.h" 24b3165f41SArnaldo Carvalho de Melo #include "util/session.h" 25b3165f41SArnaldo Carvalho de Melo #include "util/symbol.h" 26439d473bSArnaldo Carvalho de Melo #include "util/thread.h" 2786470930SIngo Molnar #include "util/util.h" 2843cbcd8aSArnaldo Carvalho de Melo #include <linux/rbtree.h> 2986470930SIngo Molnar #include "util/parse-options.h" 3086470930SIngo Molnar #include "util/parse-events.h" 31a12b51c4SPaul Mackerras #include "util/cpumap.h" 3286470930SIngo Molnar 338f28827aSFrederic Weisbecker #include "util/debug.h" 348f28827aSFrederic Weisbecker 3586470930SIngo Molnar #include <assert.h> 3686470930SIngo Molnar #include <fcntl.h> 3786470930SIngo Molnar 3886470930SIngo Molnar #include <stdio.h> 39923c42c1SMike Galbraith #include <termios.h> 40923c42c1SMike Galbraith #include <unistd.h> 4186470930SIngo Molnar 4286470930SIngo Molnar #include <errno.h> 4386470930SIngo Molnar #include <time.h> 4486470930SIngo Molnar #include <sched.h> 4586470930SIngo Molnar #include <pthread.h> 4686470930SIngo Molnar 4786470930SIngo Molnar #include <sys/syscall.h> 4886470930SIngo Molnar #include <sys/ioctl.h> 4986470930SIngo Molnar #include <sys/poll.h> 5086470930SIngo Molnar #include <sys/prctl.h> 5186470930SIngo Molnar #include <sys/wait.h> 5286470930SIngo Molnar #include <sys/uio.h> 5386470930SIngo Molnar #include <sys/mman.h> 5486470930SIngo Molnar 5586470930SIngo Molnar #include <linux/unistd.h> 5686470930SIngo Molnar #include <linux/types.h> 5786470930SIngo Molnar 58d6d901c2SZhang, Yanmin static int *fd[MAX_NR_CPUS][MAX_COUNTERS]; 5986470930SIngo Molnar 60c0555642SIan Munsie static bool system_wide = false; 6186470930SIngo Molnar 627e4ff9e3SMike Galbraith static int default_interval = 0; 6386470930SIngo Molnar 64923c42c1SMike Galbraith static int count_filter = 5; 653b6ed988SArnaldo Carvalho de Melo static int print_entries; 6686470930SIngo Molnar 6786470930SIngo Molnar static int target_pid = -1; 68d6d901c2SZhang, Yanmin static int target_tid = -1; 69d6d901c2SZhang, Yanmin static pid_t *all_tids = NULL; 70d6d901c2SZhang, Yanmin static int thread_num = 0; 71c0555642SIan Munsie static bool inherit = false; 7286470930SIngo Molnar static int profile_cpu = -1; 7386470930SIngo Molnar static int nr_cpus = 0; 741967936dSArnaldo Carvalho de Melo static int realtime_prio = 0; 75c0555642SIan Munsie static bool group = false; 7686470930SIngo Molnar static unsigned int page_size; 7786470930SIngo Molnar static unsigned int mmap_pages = 16; 7842e59d7dSIngo Molnar static int freq = 1000; /* 1 KHz */ 7986470930SIngo Molnar 8086470930SIngo Molnar static int delay_secs = 2; 81c0555642SIan Munsie static bool zero = false; 82c0555642SIan Munsie static bool dump_symtab = false; 8386470930SIngo Molnar 848ffcda17SArnaldo Carvalho de Melo static bool hide_kernel_symbols = false; 858ffcda17SArnaldo Carvalho de Melo static bool hide_user_symbols = false; 8613cc5079SArnaldo Carvalho de Melo static struct winsize winsize; 878ffcda17SArnaldo Carvalho de Melo 8886470930SIngo Molnar /* 89923c42c1SMike Galbraith * Source 90923c42c1SMike Galbraith */ 91923c42c1SMike Galbraith 92923c42c1SMike Galbraith struct source_line { 93923c42c1SMike Galbraith u64 eip; 94923c42c1SMike Galbraith unsigned long count[MAX_COUNTERS]; 95923c42c1SMike Galbraith char *line; 96923c42c1SMike Galbraith struct source_line *next; 97923c42c1SMike Galbraith }; 98923c42c1SMike Galbraith 99edb7c60eSArnaldo Carvalho de Melo static const char *sym_filter = NULL; 100923c42c1SMike Galbraith struct sym_entry *sym_filter_entry = NULL; 1016cff0e8dSKirill Smelkov struct sym_entry *sym_filter_entry_sched = NULL; 102923c42c1SMike Galbraith static int sym_pcnt_filter = 5; 103923c42c1SMike Galbraith static int sym_counter = 0; 10446ab9764SMike Galbraith static int display_weighted = -1; 105923c42c1SMike Galbraith 106923c42c1SMike Galbraith /* 10786470930SIngo Molnar * Symbols 10886470930SIngo Molnar */ 10986470930SIngo Molnar 110b269876cSArnaldo Carvalho de Melo struct sym_entry_source { 111b269876cSArnaldo Carvalho de Melo struct source_line *source; 112b269876cSArnaldo Carvalho de Melo struct source_line *lines; 113b269876cSArnaldo Carvalho de Melo struct source_line **lines_tail; 114b269876cSArnaldo Carvalho de Melo pthread_mutex_t lock; 115b269876cSArnaldo Carvalho de Melo }; 116b269876cSArnaldo Carvalho de Melo 11786470930SIngo Molnar struct sym_entry { 11886470930SIngo Molnar struct rb_node rb_node; 11986470930SIngo Molnar struct list_head node; 12086470930SIngo Molnar unsigned long snap_count; 12186470930SIngo Molnar double weight; 12286470930SIngo Molnar int skip; 12313cc5079SArnaldo Carvalho de Melo u16 name_len; 1248ffcda17SArnaldo Carvalho de Melo u8 origin; 125439d473bSArnaldo Carvalho de Melo struct map *map; 126b269876cSArnaldo Carvalho de Melo struct sym_entry_source *src; 1275a8e5a30SArnaldo Carvalho de Melo unsigned long count[0]; 12886470930SIngo Molnar }; 12986470930SIngo Molnar 130923c42c1SMike Galbraith /* 131923c42c1SMike Galbraith * Source functions 132923c42c1SMike Galbraith */ 133923c42c1SMike Galbraith 13451a472deSArnaldo Carvalho de Melo static inline struct symbol *sym_entry__symbol(struct sym_entry *self) 13551a472deSArnaldo Carvalho de Melo { 136b32d133aSArnaldo Carvalho de Melo return ((void *)self) + symbol_conf.priv_size; 13751a472deSArnaldo Carvalho de Melo } 13851a472deSArnaldo Carvalho de Melo 139895f0edcSArnaldo Carvalho de Melo void get_term_dimensions(struct winsize *ws) 1403b6ed988SArnaldo Carvalho de Melo { 14113cc5079SArnaldo Carvalho de Melo char *s = getenv("LINES"); 1423b6ed988SArnaldo Carvalho de Melo 14313cc5079SArnaldo Carvalho de Melo if (s != NULL) { 14413cc5079SArnaldo Carvalho de Melo ws->ws_row = atoi(s); 14513cc5079SArnaldo Carvalho de Melo s = getenv("COLUMNS"); 14613cc5079SArnaldo Carvalho de Melo if (s != NULL) { 14713cc5079SArnaldo Carvalho de Melo ws->ws_col = atoi(s); 14813cc5079SArnaldo Carvalho de Melo if (ws->ws_row && ws->ws_col) 14913cc5079SArnaldo Carvalho de Melo return; 15013cc5079SArnaldo Carvalho de Melo } 15113cc5079SArnaldo Carvalho de Melo } 1523b6ed988SArnaldo Carvalho de Melo #ifdef TIOCGWINSZ 15313cc5079SArnaldo Carvalho de Melo if (ioctl(1, TIOCGWINSZ, ws) == 0 && 15413cc5079SArnaldo Carvalho de Melo ws->ws_row && ws->ws_col) 15513cc5079SArnaldo Carvalho de Melo return; 1563b6ed988SArnaldo Carvalho de Melo #endif 15713cc5079SArnaldo Carvalho de Melo ws->ws_row = 25; 15813cc5079SArnaldo Carvalho de Melo ws->ws_col = 80; 1593b6ed988SArnaldo Carvalho de Melo } 1603b6ed988SArnaldo Carvalho de Melo 16113cc5079SArnaldo Carvalho de Melo static void update_print_entries(struct winsize *ws) 1623b6ed988SArnaldo Carvalho de Melo { 16313cc5079SArnaldo Carvalho de Melo print_entries = ws->ws_row; 16413cc5079SArnaldo Carvalho de Melo 1653b6ed988SArnaldo Carvalho de Melo if (print_entries > 9) 1663b6ed988SArnaldo Carvalho de Melo print_entries -= 9; 1673b6ed988SArnaldo Carvalho de Melo } 1683b6ed988SArnaldo Carvalho de Melo 1693b6ed988SArnaldo Carvalho de Melo static void sig_winch_handler(int sig __used) 1703b6ed988SArnaldo Carvalho de Melo { 17113cc5079SArnaldo Carvalho de Melo get_term_dimensions(&winsize); 17213cc5079SArnaldo Carvalho de Melo update_print_entries(&winsize); 1733b6ed988SArnaldo Carvalho de Melo } 1743b6ed988SArnaldo Carvalho de Melo 175b0a9ab62SArnaldo Carvalho de Melo static int parse_source(struct sym_entry *syme) 176923c42c1SMike Galbraith { 177923c42c1SMike Galbraith struct symbol *sym; 178b269876cSArnaldo Carvalho de Melo struct sym_entry_source *source; 179439d473bSArnaldo Carvalho de Melo struct map *map; 180923c42c1SMike Galbraith FILE *file; 18183a0944fSIngo Molnar char command[PATH_MAX*2]; 182439d473bSArnaldo Carvalho de Melo const char *path; 183439d473bSArnaldo Carvalho de Melo u64 len; 184923c42c1SMike Galbraith 185923c42c1SMike Galbraith if (!syme) 186b0a9ab62SArnaldo Carvalho de Melo return -1; 187b0a9ab62SArnaldo Carvalho de Melo 188b0a9ab62SArnaldo Carvalho de Melo sym = sym_entry__symbol(syme); 189b0a9ab62SArnaldo Carvalho de Melo map = syme->map; 190b0a9ab62SArnaldo Carvalho de Melo 191b0a9ab62SArnaldo Carvalho de Melo /* 192b0a9ab62SArnaldo Carvalho de Melo * We can't annotate with just /proc/kallsyms 193b0a9ab62SArnaldo Carvalho de Melo */ 194b0a9ab62SArnaldo Carvalho de Melo if (map->dso->origin == DSO__ORIG_KERNEL) 195b0a9ab62SArnaldo Carvalho de Melo return -1; 196923c42c1SMike Galbraith 197b269876cSArnaldo Carvalho de Melo if (syme->src == NULL) { 19836479484SArnaldo Carvalho de Melo syme->src = zalloc(sizeof(*source)); 199b269876cSArnaldo Carvalho de Melo if (syme->src == NULL) 200b0a9ab62SArnaldo Carvalho de Melo return -1; 201b269876cSArnaldo Carvalho de Melo pthread_mutex_init(&syme->src->lock, NULL); 202b269876cSArnaldo Carvalho de Melo } 203b269876cSArnaldo Carvalho de Melo 204b269876cSArnaldo Carvalho de Melo source = syme->src; 205b269876cSArnaldo Carvalho de Melo 206b269876cSArnaldo Carvalho de Melo if (source->lines) { 207b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&source->lock); 208923c42c1SMike Galbraith goto out_assign; 209923c42c1SMike Galbraith } 210439d473bSArnaldo Carvalho de Melo path = map->dso->long_name; 211923c42c1SMike Galbraith 212923c42c1SMike Galbraith len = sym->end - sym->start; 213923c42c1SMike Galbraith 214439d473bSArnaldo Carvalho de Melo sprintf(command, 2155f485364SArnaldo Carvalho de Melo "objdump --start-address=%#0*Lx --stop-address=%#0*Lx -dS %s", 2165f485364SArnaldo Carvalho de Melo BITS_PER_LONG / 4, map__rip_2objdump(map, sym->start), 2175f485364SArnaldo Carvalho de Melo BITS_PER_LONG / 4, map__rip_2objdump(map, sym->end), path); 218923c42c1SMike Galbraith 219923c42c1SMike Galbraith file = popen(command, "r"); 220923c42c1SMike Galbraith if (!file) 221b0a9ab62SArnaldo Carvalho de Melo return -1; 222923c42c1SMike Galbraith 223b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&source->lock); 224b269876cSArnaldo Carvalho de Melo source->lines_tail = &source->lines; 225923c42c1SMike Galbraith while (!feof(file)) { 226923c42c1SMike Galbraith struct source_line *src; 227923c42c1SMike Galbraith size_t dummy = 0; 228ee11b90bSKirill Smelkov char *c, *sep; 229923c42c1SMike Galbraith 230923c42c1SMike Galbraith src = malloc(sizeof(struct source_line)); 231923c42c1SMike Galbraith assert(src != NULL); 232923c42c1SMike Galbraith memset(src, 0, sizeof(struct source_line)); 233923c42c1SMike Galbraith 234923c42c1SMike Galbraith if (getline(&src->line, &dummy, file) < 0) 235923c42c1SMike Galbraith break; 236923c42c1SMike Galbraith if (!src->line) 237923c42c1SMike Galbraith break; 238923c42c1SMike Galbraith 239923c42c1SMike Galbraith c = strchr(src->line, '\n'); 240923c42c1SMike Galbraith if (c) 241923c42c1SMike Galbraith *c = 0; 242923c42c1SMike Galbraith 243923c42c1SMike Galbraith src->next = NULL; 244b269876cSArnaldo Carvalho de Melo *source->lines_tail = src; 245b269876cSArnaldo Carvalho de Melo source->lines_tail = &src->next; 246923c42c1SMike Galbraith 247ee11b90bSKirill Smelkov src->eip = strtoull(src->line, &sep, 16); 248ee11b90bSKirill Smelkov if (*sep == ':') 249ee11b90bSKirill Smelkov src->eip = map__objdump_2ip(map, src->eip); 250ee11b90bSKirill Smelkov else /* this line has no ip info (e.g. source line) */ 251ee11b90bSKirill Smelkov src->eip = 0; 252923c42c1SMike Galbraith } 253923c42c1SMike Galbraith pclose(file); 254923c42c1SMike Galbraith out_assign: 255923c42c1SMike Galbraith sym_filter_entry = syme; 256b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&source->lock); 257b0a9ab62SArnaldo Carvalho de Melo return 0; 258923c42c1SMike Galbraith } 259923c42c1SMike Galbraith 260923c42c1SMike Galbraith static void __zero_source_counters(struct sym_entry *syme) 261923c42c1SMike Galbraith { 262923c42c1SMike Galbraith int i; 263923c42c1SMike Galbraith struct source_line *line; 264923c42c1SMike Galbraith 265b269876cSArnaldo Carvalho de Melo line = syme->src->lines; 266923c42c1SMike Galbraith while (line) { 267923c42c1SMike Galbraith for (i = 0; i < nr_counters; i++) 268923c42c1SMike Galbraith line->count[i] = 0; 269923c42c1SMike Galbraith line = line->next; 270923c42c1SMike Galbraith } 271923c42c1SMike Galbraith } 272923c42c1SMike Galbraith 273923c42c1SMike Galbraith static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip) 274923c42c1SMike Galbraith { 275923c42c1SMike Galbraith struct source_line *line; 276923c42c1SMike Galbraith 277923c42c1SMike Galbraith if (syme != sym_filter_entry) 278923c42c1SMike Galbraith return; 279923c42c1SMike Galbraith 280b269876cSArnaldo Carvalho de Melo if (pthread_mutex_trylock(&syme->src->lock)) 281923c42c1SMike Galbraith return; 282923c42c1SMike Galbraith 283b269876cSArnaldo Carvalho de Melo if (syme->src == NULL || syme->src->source == NULL) 284923c42c1SMike Galbraith goto out_unlock; 285923c42c1SMike Galbraith 286b269876cSArnaldo Carvalho de Melo for (line = syme->src->lines; line; line = line->next) { 287ee11b90bSKirill Smelkov /* skip lines without IP info */ 288ee11b90bSKirill Smelkov if (line->eip == 0) 289ee11b90bSKirill Smelkov continue; 290923c42c1SMike Galbraith if (line->eip == ip) { 291923c42c1SMike Galbraith line->count[counter]++; 292923c42c1SMike Galbraith break; 293923c42c1SMike Galbraith } 294923c42c1SMike Galbraith if (line->eip > ip) 295923c42c1SMike Galbraith break; 296923c42c1SMike Galbraith } 297923c42c1SMike Galbraith out_unlock: 298b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 299923c42c1SMike Galbraith } 300923c42c1SMike Galbraith 301c7ad21afSArnaldo Carvalho de Melo #define PATTERN_LEN (BITS_PER_LONG / 4 + 2) 302c7ad21afSArnaldo Carvalho de Melo 303923c42c1SMike Galbraith static void lookup_sym_source(struct sym_entry *syme) 304923c42c1SMike Galbraith { 30551a472deSArnaldo Carvalho de Melo struct symbol *symbol = sym_entry__symbol(syme); 306923c42c1SMike Galbraith struct source_line *line; 307c7ad21afSArnaldo Carvalho de Melo char pattern[PATTERN_LEN + 1]; 308923c42c1SMike Galbraith 3095f485364SArnaldo Carvalho de Melo sprintf(pattern, "%0*Lx <", BITS_PER_LONG / 4, 3105f485364SArnaldo Carvalho de Melo map__rip_2objdump(syme->map, symbol->start)); 311923c42c1SMike Galbraith 312b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 313b269876cSArnaldo Carvalho de Melo for (line = syme->src->lines; line; line = line->next) { 314c7ad21afSArnaldo Carvalho de Melo if (memcmp(line->line, pattern, PATTERN_LEN) == 0) { 315b269876cSArnaldo Carvalho de Melo syme->src->source = line; 316923c42c1SMike Galbraith break; 317923c42c1SMike Galbraith } 318923c42c1SMike Galbraith } 319b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 320923c42c1SMike Galbraith } 321923c42c1SMike Galbraith 322923c42c1SMike Galbraith static void show_lines(struct source_line *queue, int count, int total) 323923c42c1SMike Galbraith { 324923c42c1SMike Galbraith int i; 325923c42c1SMike Galbraith struct source_line *line; 326923c42c1SMike Galbraith 327923c42c1SMike Galbraith line = queue; 328923c42c1SMike Galbraith for (i = 0; i < count; i++) { 329923c42c1SMike Galbraith float pcnt = 100.0*(float)line->count[sym_counter]/(float)total; 330923c42c1SMike Galbraith 331923c42c1SMike Galbraith printf("%8li %4.1f%%\t%s\n", line->count[sym_counter], pcnt, line->line); 332923c42c1SMike Galbraith line = line->next; 333923c42c1SMike Galbraith } 334923c42c1SMike Galbraith } 335923c42c1SMike Galbraith 336923c42c1SMike Galbraith #define TRACE_COUNT 3 337923c42c1SMike Galbraith 338923c42c1SMike Galbraith static void show_details(struct sym_entry *syme) 339923c42c1SMike Galbraith { 340923c42c1SMike Galbraith struct symbol *symbol; 341923c42c1SMike Galbraith struct source_line *line; 342923c42c1SMike Galbraith struct source_line *line_queue = NULL; 343923c42c1SMike Galbraith int displayed = 0; 344923c42c1SMike Galbraith int line_queue_count = 0, total = 0, more = 0; 345923c42c1SMike Galbraith 346923c42c1SMike Galbraith if (!syme) 347923c42c1SMike Galbraith return; 348923c42c1SMike Galbraith 349b269876cSArnaldo Carvalho de Melo if (!syme->src->source) 350923c42c1SMike Galbraith lookup_sym_source(syme); 351923c42c1SMike Galbraith 352b269876cSArnaldo Carvalho de Melo if (!syme->src->source) 353923c42c1SMike Galbraith return; 354923c42c1SMike Galbraith 35551a472deSArnaldo Carvalho de Melo symbol = sym_entry__symbol(syme); 356923c42c1SMike Galbraith printf("Showing %s for %s\n", event_name(sym_counter), symbol->name); 357923c42c1SMike Galbraith printf(" Events Pcnt (>=%d%%)\n", sym_pcnt_filter); 358923c42c1SMike Galbraith 359b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 360b269876cSArnaldo Carvalho de Melo line = syme->src->source; 361923c42c1SMike Galbraith while (line) { 362923c42c1SMike Galbraith total += line->count[sym_counter]; 363923c42c1SMike Galbraith line = line->next; 364923c42c1SMike Galbraith } 365923c42c1SMike Galbraith 366b269876cSArnaldo Carvalho de Melo line = syme->src->source; 367923c42c1SMike Galbraith while (line) { 368923c42c1SMike Galbraith float pcnt = 0.0; 369923c42c1SMike Galbraith 370923c42c1SMike Galbraith if (!line_queue_count) 371923c42c1SMike Galbraith line_queue = line; 372923c42c1SMike Galbraith line_queue_count++; 373923c42c1SMike Galbraith 374923c42c1SMike Galbraith if (line->count[sym_counter]) 375923c42c1SMike Galbraith pcnt = 100.0 * line->count[sym_counter] / (float)total; 376923c42c1SMike Galbraith if (pcnt >= (float)sym_pcnt_filter) { 377923c42c1SMike Galbraith if (displayed <= print_entries) 378923c42c1SMike Galbraith show_lines(line_queue, line_queue_count, total); 379923c42c1SMike Galbraith else more++; 380923c42c1SMike Galbraith displayed += line_queue_count; 381923c42c1SMike Galbraith line_queue_count = 0; 382923c42c1SMike Galbraith line_queue = NULL; 383923c42c1SMike Galbraith } else if (line_queue_count > TRACE_COUNT) { 384923c42c1SMike Galbraith line_queue = line_queue->next; 385923c42c1SMike Galbraith line_queue_count--; 386923c42c1SMike Galbraith } 387923c42c1SMike Galbraith 388923c42c1SMike Galbraith line->count[sym_counter] = zero ? 0 : line->count[sym_counter] * 7 / 8; 389923c42c1SMike Galbraith line = line->next; 390923c42c1SMike Galbraith } 391b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 392923c42c1SMike Galbraith if (more) 393923c42c1SMike Galbraith printf("%d lines not displayed, maybe increase display entries [e]\n", more); 394923c42c1SMike Galbraith } 39586470930SIngo Molnar 39686470930SIngo Molnar /* 3975b2bb75aSArnaldo Carvalho de Melo * Symbols will be added here in event__process_sample and will get out 39886470930SIngo Molnar * after decayed. 39986470930SIngo Molnar */ 40086470930SIngo Molnar static LIST_HEAD(active_symbols); 40186470930SIngo Molnar static pthread_mutex_t active_symbols_lock = PTHREAD_MUTEX_INITIALIZER; 40286470930SIngo Molnar 40386470930SIngo Molnar /* 40486470930SIngo Molnar * Ordering weight: count-1 * count-2 * ... / count-n 40586470930SIngo Molnar */ 40686470930SIngo Molnar static double sym_weight(const struct sym_entry *sym) 40786470930SIngo Molnar { 40886470930SIngo Molnar double weight = sym->snap_count; 40986470930SIngo Molnar int counter; 41086470930SIngo Molnar 41146ab9764SMike Galbraith if (!display_weighted) 41246ab9764SMike Galbraith return weight; 41346ab9764SMike Galbraith 41486470930SIngo Molnar for (counter = 1; counter < nr_counters-1; counter++) 41586470930SIngo Molnar weight *= sym->count[counter]; 41686470930SIngo Molnar 41786470930SIngo Molnar weight /= (sym->count[counter] + 1); 41886470930SIngo Molnar 41986470930SIngo Molnar return weight; 42086470930SIngo Molnar } 42186470930SIngo Molnar 42286470930SIngo Molnar static long samples; 423a1645ce1SZhang, Yanmin static long kernel_samples, us_samples; 4241676b8a0SPeter Zijlstra static long exact_samples; 425a1645ce1SZhang, Yanmin static long guest_us_samples, guest_kernel_samples; 42686470930SIngo Molnar static const char CONSOLE_CLEAR[] = "[H[2J"; 42786470930SIngo Molnar 42886470930SIngo Molnar static void __list_insert_active_sym(struct sym_entry *syme) 42986470930SIngo Molnar { 43086470930SIngo Molnar list_add(&syme->node, &active_symbols); 43186470930SIngo Molnar } 43286470930SIngo Molnar 43386470930SIngo Molnar static void list_remove_active_sym(struct sym_entry *syme) 43486470930SIngo Molnar { 43586470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 43686470930SIngo Molnar list_del_init(&syme->node); 43786470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 43886470930SIngo Molnar } 43986470930SIngo Molnar 44086470930SIngo Molnar static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se) 44186470930SIngo Molnar { 44286470930SIngo Molnar struct rb_node **p = &tree->rb_node; 44386470930SIngo Molnar struct rb_node *parent = NULL; 44486470930SIngo Molnar struct sym_entry *iter; 44586470930SIngo Molnar 44686470930SIngo Molnar while (*p != NULL) { 44786470930SIngo Molnar parent = *p; 44886470930SIngo Molnar iter = rb_entry(parent, struct sym_entry, rb_node); 44986470930SIngo Molnar 45086470930SIngo Molnar if (se->weight > iter->weight) 45186470930SIngo Molnar p = &(*p)->rb_left; 45286470930SIngo Molnar else 45386470930SIngo Molnar p = &(*p)->rb_right; 45486470930SIngo Molnar } 45586470930SIngo Molnar 45686470930SIngo Molnar rb_link_node(&se->rb_node, parent, p); 45786470930SIngo Molnar rb_insert_color(&se->rb_node, tree); 45886470930SIngo Molnar } 45986470930SIngo Molnar 46086470930SIngo Molnar static void print_sym_table(void) 46186470930SIngo Molnar { 46286470930SIngo Molnar int printed = 0, j; 46346ab9764SMike Galbraith int counter, snap = !display_weighted ? sym_counter : 0; 46486470930SIngo Molnar float samples_per_sec = samples/delay_secs; 465a1645ce1SZhang, Yanmin float ksamples_per_sec = kernel_samples/delay_secs; 466a1645ce1SZhang, Yanmin float us_samples_per_sec = (us_samples)/delay_secs; 467a1645ce1SZhang, Yanmin float guest_kernel_samples_per_sec = (guest_kernel_samples)/delay_secs; 468a1645ce1SZhang, Yanmin float guest_us_samples_per_sec = (guest_us_samples)/delay_secs; 4691676b8a0SPeter Zijlstra float esamples_percent = (100.0*exact_samples)/samples; 47086470930SIngo Molnar float sum_ksamples = 0.0; 47186470930SIngo Molnar struct sym_entry *syme, *n; 47286470930SIngo Molnar struct rb_root tmp = RB_ROOT; 47386470930SIngo Molnar struct rb_node *nd; 47400909e95SArnaldo Carvalho de Melo int sym_width = 0, dso_width = 0, dso_short_width = 0; 47513cc5079SArnaldo Carvalho de Melo const int win_width = winsize.ws_col - 1; 47686470930SIngo Molnar 477a1645ce1SZhang, Yanmin samples = us_samples = kernel_samples = exact_samples = 0; 478a1645ce1SZhang, Yanmin guest_kernel_samples = guest_us_samples = 0; 47986470930SIngo Molnar 48086470930SIngo Molnar /* Sort the active symbols */ 48186470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 48286470930SIngo Molnar syme = list_entry(active_symbols.next, struct sym_entry, node); 48386470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 48486470930SIngo Molnar 48586470930SIngo Molnar list_for_each_entry_safe_from(syme, n, &active_symbols, node) { 48646ab9764SMike Galbraith syme->snap_count = syme->count[snap]; 48786470930SIngo Molnar if (syme->snap_count != 0) { 48813cc5079SArnaldo Carvalho de Melo 4898ffcda17SArnaldo Carvalho de Melo if ((hide_user_symbols && 4908ffcda17SArnaldo Carvalho de Melo syme->origin == PERF_RECORD_MISC_USER) || 4918ffcda17SArnaldo Carvalho de Melo (hide_kernel_symbols && 4928ffcda17SArnaldo Carvalho de Melo syme->origin == PERF_RECORD_MISC_KERNEL)) { 4938ffcda17SArnaldo Carvalho de Melo list_remove_active_sym(syme); 4948ffcda17SArnaldo Carvalho de Melo continue; 4958ffcda17SArnaldo Carvalho de Melo } 49686470930SIngo Molnar syme->weight = sym_weight(syme); 49786470930SIngo Molnar rb_insert_active_sym(&tmp, syme); 49886470930SIngo Molnar sum_ksamples += syme->snap_count; 49986470930SIngo Molnar 50086470930SIngo Molnar for (j = 0; j < nr_counters; j++) 50186470930SIngo Molnar syme->count[j] = zero ? 0 : syme->count[j] * 7 / 8; 50286470930SIngo Molnar } else 50386470930SIngo Molnar list_remove_active_sym(syme); 50486470930SIngo Molnar } 50586470930SIngo Molnar 50686470930SIngo Molnar puts(CONSOLE_CLEAR); 50786470930SIngo Molnar 50813cc5079SArnaldo Carvalho de Melo printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 509a1645ce1SZhang, Yanmin if (!perf_guest) { 510a1645ce1SZhang, Yanmin printf(" PerfTop:%8.0f irqs/sec kernel:%4.1f%%" 511a1645ce1SZhang, Yanmin " exact: %4.1f%% [", 51286470930SIngo Molnar samples_per_sec, 513a1645ce1SZhang, Yanmin 100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) / 514a1645ce1SZhang, Yanmin samples_per_sec)), 5151676b8a0SPeter Zijlstra esamples_percent); 516a1645ce1SZhang, Yanmin } else { 517a1645ce1SZhang, Yanmin printf(" PerfTop:%8.0f irqs/sec kernel:%4.1f%% us:%4.1f%%" 518a1645ce1SZhang, Yanmin " guest kernel:%4.1f%% guest us:%4.1f%%" 519a1645ce1SZhang, Yanmin " exact: %4.1f%% [", 520a1645ce1SZhang, Yanmin samples_per_sec, 521a1645ce1SZhang, Yanmin 100.0 - (100.0 * ((samples_per_sec-ksamples_per_sec) / 522a1645ce1SZhang, Yanmin samples_per_sec)), 523a1645ce1SZhang, Yanmin 100.0 - (100.0 * ((samples_per_sec-us_samples_per_sec) / 524a1645ce1SZhang, Yanmin samples_per_sec)), 525a1645ce1SZhang, Yanmin 100.0 - (100.0 * ((samples_per_sec - 526a1645ce1SZhang, Yanmin guest_kernel_samples_per_sec) / 527a1645ce1SZhang, Yanmin samples_per_sec)), 528a1645ce1SZhang, Yanmin 100.0 - (100.0 * ((samples_per_sec - 529a1645ce1SZhang, Yanmin guest_us_samples_per_sec) / 530a1645ce1SZhang, Yanmin samples_per_sec)), 531a1645ce1SZhang, Yanmin esamples_percent); 532a1645ce1SZhang, Yanmin } 53386470930SIngo Molnar 53446ab9764SMike Galbraith if (nr_counters == 1 || !display_weighted) { 5359cffa8d5SPaul Mackerras printf("%Ld", (u64)attrs[0].sample_period); 53686470930SIngo Molnar if (freq) 53786470930SIngo Molnar printf("Hz "); 53886470930SIngo Molnar else 53986470930SIngo Molnar printf(" "); 54086470930SIngo Molnar } 54186470930SIngo Molnar 54246ab9764SMike Galbraith if (!display_weighted) 54346ab9764SMike Galbraith printf("%s", event_name(sym_counter)); 54446ab9764SMike Galbraith else for (counter = 0; counter < nr_counters; counter++) { 54586470930SIngo Molnar if (counter) 54686470930SIngo Molnar printf("/"); 54786470930SIngo Molnar 54886470930SIngo Molnar printf("%s", event_name(counter)); 54986470930SIngo Molnar } 55086470930SIngo Molnar 55186470930SIngo Molnar printf( "], "); 55286470930SIngo Molnar 55386470930SIngo Molnar if (target_pid != -1) 55486470930SIngo Molnar printf(" (target_pid: %d", target_pid); 555d6d901c2SZhang, Yanmin else if (target_tid != -1) 556d6d901c2SZhang, Yanmin printf(" (target_tid: %d", target_tid); 55786470930SIngo Molnar else 55886470930SIngo Molnar printf(" (all"); 55986470930SIngo Molnar 56086470930SIngo Molnar if (profile_cpu != -1) 56186470930SIngo Molnar printf(", cpu: %d)\n", profile_cpu); 56286470930SIngo Molnar else { 563d6d901c2SZhang, Yanmin if (target_tid != -1) 56486470930SIngo Molnar printf(")\n"); 56586470930SIngo Molnar else 56686470930SIngo Molnar printf(", %d CPUs)\n", nr_cpus); 56786470930SIngo Molnar } 56886470930SIngo Molnar 5691a105f74SArnaldo Carvalho de Melo printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 57086470930SIngo Molnar 571923c42c1SMike Galbraith if (sym_filter_entry) { 572923c42c1SMike Galbraith show_details(sym_filter_entry); 573923c42c1SMike Galbraith return; 574923c42c1SMike Galbraith } 575923c42c1SMike Galbraith 57613cc5079SArnaldo Carvalho de Melo /* 57713cc5079SArnaldo Carvalho de Melo * Find the longest symbol name that will be displayed 57813cc5079SArnaldo Carvalho de Melo */ 57913cc5079SArnaldo Carvalho de Melo for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) { 58013cc5079SArnaldo Carvalho de Melo syme = rb_entry(nd, struct sym_entry, rb_node); 58113cc5079SArnaldo Carvalho de Melo if (++printed > print_entries || 58213cc5079SArnaldo Carvalho de Melo (int)syme->snap_count < count_filter) 58313cc5079SArnaldo Carvalho de Melo continue; 58413cc5079SArnaldo Carvalho de Melo 5851a105f74SArnaldo Carvalho de Melo if (syme->map->dso->long_name_len > dso_width) 5861a105f74SArnaldo Carvalho de Melo dso_width = syme->map->dso->long_name_len; 5871a105f74SArnaldo Carvalho de Melo 588b63be8d7SArnaldo Carvalho de Melo if (syme->map->dso->short_name_len > dso_short_width) 589b63be8d7SArnaldo Carvalho de Melo dso_short_width = syme->map->dso->short_name_len; 590b63be8d7SArnaldo Carvalho de Melo 59113cc5079SArnaldo Carvalho de Melo if (syme->name_len > sym_width) 59213cc5079SArnaldo Carvalho de Melo sym_width = syme->name_len; 59313cc5079SArnaldo Carvalho de Melo } 59413cc5079SArnaldo Carvalho de Melo 59513cc5079SArnaldo Carvalho de Melo printed = 0; 59613cc5079SArnaldo Carvalho de Melo 597b63be8d7SArnaldo Carvalho de Melo if (sym_width + dso_width > winsize.ws_col - 29) { 598b63be8d7SArnaldo Carvalho de Melo dso_width = dso_short_width; 599b63be8d7SArnaldo Carvalho de Melo if (sym_width + dso_width > winsize.ws_col - 29) 600b63be8d7SArnaldo Carvalho de Melo sym_width = winsize.ws_col - dso_width - 29; 601b63be8d7SArnaldo Carvalho de Melo } 6021a105f74SArnaldo Carvalho de Melo putchar('\n'); 60386470930SIngo Molnar if (nr_counters == 1) 60486470930SIngo Molnar printf(" samples pcnt"); 60586470930SIngo Molnar else 60686470930SIngo Molnar printf(" weight samples pcnt"); 60786470930SIngo Molnar 6087ced156bSArnaldo Carvalho de Melo if (verbose) 6097ced156bSArnaldo Carvalho de Melo printf(" RIP "); 6107cc017edSArnaldo Carvalho de Melo printf(" %-*.*s DSO\n", sym_width, sym_width, "function"); 6117ced156bSArnaldo Carvalho de Melo printf(" %s _______ _____", 6127ced156bSArnaldo Carvalho de Melo nr_counters == 1 ? " " : "______"); 6137ced156bSArnaldo Carvalho de Melo if (verbose) 6147ced156bSArnaldo Carvalho de Melo printf(" ________________"); 6151a105f74SArnaldo Carvalho de Melo printf(" %-*.*s", sym_width, sym_width, graph_line); 6161a105f74SArnaldo Carvalho de Melo printf(" %-*.*s", dso_width, dso_width, graph_line); 6171a105f74SArnaldo Carvalho de Melo puts("\n"); 61886470930SIngo Molnar 61986470930SIngo Molnar for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) { 62083a0944fSIngo Molnar struct symbol *sym; 62186470930SIngo Molnar double pcnt; 62286470930SIngo Molnar 62383a0944fSIngo Molnar syme = rb_entry(nd, struct sym_entry, rb_node); 62451a472deSArnaldo Carvalho de Melo sym = sym_entry__symbol(syme); 625923c42c1SMike Galbraith if (++printed > print_entries || (int)syme->snap_count < count_filter) 62686470930SIngo Molnar continue; 62786470930SIngo Molnar 62886470930SIngo Molnar pcnt = 100.0 - (100.0 * ((sum_ksamples - syme->snap_count) / 62986470930SIngo Molnar sum_ksamples)); 63086470930SIngo Molnar 63146ab9764SMike Galbraith if (nr_counters == 1 || !display_weighted) 6325b2bb75aSArnaldo Carvalho de Melo printf("%20.2f ", syme->weight); 63386470930SIngo Molnar else 6345b2bb75aSArnaldo Carvalho de Melo printf("%9.1f %10ld ", syme->weight, syme->snap_count); 63586470930SIngo Molnar 6361e11fd82SFrederic Weisbecker percent_color_fprintf(stdout, "%4.1f%%", pcnt); 6377ced156bSArnaldo Carvalho de Melo if (verbose) 6385b2bb75aSArnaldo Carvalho de Melo printf(" %016llx", sym->start); 63913cc5079SArnaldo Carvalho de Melo printf(" %-*.*s", sym_width, sym_width, sym->name); 6407cc017edSArnaldo Carvalho de Melo printf(" %-*.*s\n", dso_width, dso_width, 64113cc5079SArnaldo Carvalho de Melo dso_width >= syme->map->dso->long_name_len ? 64213cc5079SArnaldo Carvalho de Melo syme->map->dso->long_name : 64313cc5079SArnaldo Carvalho de Melo syme->map->dso->short_name); 64486470930SIngo Molnar } 64586470930SIngo Molnar } 64686470930SIngo Molnar 647923c42c1SMike Galbraith static void prompt_integer(int *target, const char *msg) 648923c42c1SMike Galbraith { 649923c42c1SMike Galbraith char *buf = malloc(0), *p; 650923c42c1SMike Galbraith size_t dummy = 0; 651923c42c1SMike Galbraith int tmp; 652923c42c1SMike Galbraith 653923c42c1SMike Galbraith fprintf(stdout, "\n%s: ", msg); 654923c42c1SMike Galbraith if (getline(&buf, &dummy, stdin) < 0) 655923c42c1SMike Galbraith return; 656923c42c1SMike Galbraith 657923c42c1SMike Galbraith p = strchr(buf, '\n'); 658923c42c1SMike Galbraith if (p) 659923c42c1SMike Galbraith *p = 0; 660923c42c1SMike Galbraith 661923c42c1SMike Galbraith p = buf; 662923c42c1SMike Galbraith while(*p) { 663923c42c1SMike Galbraith if (!isdigit(*p)) 664923c42c1SMike Galbraith goto out_free; 665923c42c1SMike Galbraith p++; 666923c42c1SMike Galbraith } 667923c42c1SMike Galbraith tmp = strtoul(buf, NULL, 10); 668923c42c1SMike Galbraith *target = tmp; 669923c42c1SMike Galbraith out_free: 670923c42c1SMike Galbraith free(buf); 671923c42c1SMike Galbraith } 672923c42c1SMike Galbraith 673923c42c1SMike Galbraith static void prompt_percent(int *target, const char *msg) 674923c42c1SMike Galbraith { 675923c42c1SMike Galbraith int tmp = 0; 676923c42c1SMike Galbraith 677923c42c1SMike Galbraith prompt_integer(&tmp, msg); 678923c42c1SMike Galbraith if (tmp >= 0 && tmp <= 100) 679923c42c1SMike Galbraith *target = tmp; 680923c42c1SMike Galbraith } 681923c42c1SMike Galbraith 682923c42c1SMike Galbraith static void prompt_symbol(struct sym_entry **target, const char *msg) 683923c42c1SMike Galbraith { 684923c42c1SMike Galbraith char *buf = malloc(0), *p; 685923c42c1SMike Galbraith struct sym_entry *syme = *target, *n, *found = NULL; 686923c42c1SMike Galbraith size_t dummy = 0; 687923c42c1SMike Galbraith 688923c42c1SMike Galbraith /* zero counters of active symbol */ 689923c42c1SMike Galbraith if (syme) { 690b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 691923c42c1SMike Galbraith __zero_source_counters(syme); 692923c42c1SMike Galbraith *target = NULL; 693b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 694923c42c1SMike Galbraith } 695923c42c1SMike Galbraith 696923c42c1SMike Galbraith fprintf(stdout, "\n%s: ", msg); 697923c42c1SMike Galbraith if (getline(&buf, &dummy, stdin) < 0) 698923c42c1SMike Galbraith goto out_free; 699923c42c1SMike Galbraith 700923c42c1SMike Galbraith p = strchr(buf, '\n'); 701923c42c1SMike Galbraith if (p) 702923c42c1SMike Galbraith *p = 0; 703923c42c1SMike Galbraith 704923c42c1SMike Galbraith pthread_mutex_lock(&active_symbols_lock); 705923c42c1SMike Galbraith syme = list_entry(active_symbols.next, struct sym_entry, node); 706923c42c1SMike Galbraith pthread_mutex_unlock(&active_symbols_lock); 707923c42c1SMike Galbraith 708923c42c1SMike Galbraith list_for_each_entry_safe_from(syme, n, &active_symbols, node) { 70951a472deSArnaldo Carvalho de Melo struct symbol *sym = sym_entry__symbol(syme); 710923c42c1SMike Galbraith 711923c42c1SMike Galbraith if (!strcmp(buf, sym->name)) { 712923c42c1SMike Galbraith found = syme; 713923c42c1SMike Galbraith break; 714923c42c1SMike Galbraith } 715923c42c1SMike Galbraith } 716923c42c1SMike Galbraith 717923c42c1SMike Galbraith if (!found) { 71866aeb6d5SKirill Smelkov fprintf(stderr, "Sorry, %s is not active.\n", buf); 719923c42c1SMike Galbraith sleep(1); 720923c42c1SMike Galbraith return; 721923c42c1SMike Galbraith } else 722923c42c1SMike Galbraith parse_source(found); 723923c42c1SMike Galbraith 724923c42c1SMike Galbraith out_free: 725923c42c1SMike Galbraith free(buf); 726923c42c1SMike Galbraith } 727923c42c1SMike Galbraith 728091bd2e9SMike Galbraith static void print_mapped_keys(void) 729923c42c1SMike Galbraith { 730091bd2e9SMike Galbraith char *name = NULL; 731091bd2e9SMike Galbraith 732091bd2e9SMike Galbraith if (sym_filter_entry) { 73351a472deSArnaldo Carvalho de Melo struct symbol *sym = sym_entry__symbol(sym_filter_entry); 734091bd2e9SMike Galbraith name = sym->name; 735091bd2e9SMike Galbraith } 736091bd2e9SMike Galbraith 737091bd2e9SMike Galbraith fprintf(stdout, "\nMapped keys:\n"); 738091bd2e9SMike Galbraith fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", delay_secs); 739091bd2e9SMike Galbraith fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", print_entries); 740091bd2e9SMike Galbraith 741091bd2e9SMike Galbraith if (nr_counters > 1) 74246ab9764SMike Galbraith fprintf(stdout, "\t[E] active event counter. \t(%s)\n", event_name(sym_counter)); 743091bd2e9SMike Galbraith 744091bd2e9SMike Galbraith fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", count_filter); 745091bd2e9SMike Galbraith 746091bd2e9SMike Galbraith fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter); 747091bd2e9SMike Galbraith fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL"); 748091bd2e9SMike Galbraith fprintf(stdout, "\t[S] stop annotation.\n"); 749091bd2e9SMike Galbraith 750091bd2e9SMike Galbraith if (nr_counters > 1) 75146ab9764SMike Galbraith fprintf(stdout, "\t[w] toggle display weighted/count[E]r. \t(%d)\n", display_weighted ? 1 : 0); 752091bd2e9SMike Galbraith 7538ffcda17SArnaldo Carvalho de Melo fprintf(stdout, 7548ffcda17SArnaldo Carvalho de Melo "\t[K] hide kernel_symbols symbols. \t(%s)\n", 7558ffcda17SArnaldo Carvalho de Melo hide_kernel_symbols ? "yes" : "no"); 7568ffcda17SArnaldo Carvalho de Melo fprintf(stdout, 7578ffcda17SArnaldo Carvalho de Melo "\t[U] hide user symbols. \t(%s)\n", 7588ffcda17SArnaldo Carvalho de Melo hide_user_symbols ? "yes" : "no"); 75946ab9764SMike Galbraith fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", zero ? 1 : 0); 760091bd2e9SMike Galbraith fprintf(stdout, "\t[qQ] quit.\n"); 761091bd2e9SMike Galbraith } 762091bd2e9SMike Galbraith 763091bd2e9SMike Galbraith static int key_mapped(int c) 764091bd2e9SMike Galbraith { 765091bd2e9SMike Galbraith switch (c) { 766091bd2e9SMike Galbraith case 'd': 767091bd2e9SMike Galbraith case 'e': 768091bd2e9SMike Galbraith case 'f': 769091bd2e9SMike Galbraith case 'z': 770091bd2e9SMike Galbraith case 'q': 771091bd2e9SMike Galbraith case 'Q': 7728ffcda17SArnaldo Carvalho de Melo case 'K': 7738ffcda17SArnaldo Carvalho de Melo case 'U': 7746cff0e8dSKirill Smelkov case 'F': 7756cff0e8dSKirill Smelkov case 's': 7766cff0e8dSKirill Smelkov case 'S': 777091bd2e9SMike Galbraith return 1; 778091bd2e9SMike Galbraith case 'E': 779091bd2e9SMike Galbraith case 'w': 780091bd2e9SMike Galbraith return nr_counters > 1 ? 1 : 0; 78183a0944fSIngo Molnar default: 78283a0944fSIngo Molnar break; 783091bd2e9SMike Galbraith } 784091bd2e9SMike Galbraith 785091bd2e9SMike Galbraith return 0; 786923c42c1SMike Galbraith } 787923c42c1SMike Galbraith 788a1645ce1SZhang, Yanmin static void handle_keypress(struct perf_session *session, int c) 789923c42c1SMike Galbraith { 790091bd2e9SMike Galbraith if (!key_mapped(c)) { 791091bd2e9SMike Galbraith struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 792091bd2e9SMike Galbraith struct termios tc, save; 793091bd2e9SMike Galbraith 794091bd2e9SMike Galbraith print_mapped_keys(); 795091bd2e9SMike Galbraith fprintf(stdout, "\nEnter selection, or unmapped key to continue: "); 796091bd2e9SMike Galbraith fflush(stdout); 797091bd2e9SMike Galbraith 798091bd2e9SMike Galbraith tcgetattr(0, &save); 799091bd2e9SMike Galbraith tc = save; 800091bd2e9SMike Galbraith tc.c_lflag &= ~(ICANON | ECHO); 801091bd2e9SMike Galbraith tc.c_cc[VMIN] = 0; 802091bd2e9SMike Galbraith tc.c_cc[VTIME] = 0; 803091bd2e9SMike Galbraith tcsetattr(0, TCSANOW, &tc); 804091bd2e9SMike Galbraith 805091bd2e9SMike Galbraith poll(&stdin_poll, 1, -1); 806091bd2e9SMike Galbraith c = getc(stdin); 807091bd2e9SMike Galbraith 808091bd2e9SMike Galbraith tcsetattr(0, TCSAFLUSH, &save); 809091bd2e9SMike Galbraith if (!key_mapped(c)) 810091bd2e9SMike Galbraith return; 811091bd2e9SMike Galbraith } 812091bd2e9SMike Galbraith 813923c42c1SMike Galbraith switch (c) { 814923c42c1SMike Galbraith case 'd': 815923c42c1SMike Galbraith prompt_integer(&delay_secs, "Enter display delay"); 816dc79959aSTim Blechmann if (delay_secs < 1) 817dc79959aSTim Blechmann delay_secs = 1; 818923c42c1SMike Galbraith break; 819923c42c1SMike Galbraith case 'e': 820923c42c1SMike Galbraith prompt_integer(&print_entries, "Enter display entries (lines)"); 8213b6ed988SArnaldo Carvalho de Melo if (print_entries == 0) { 82213cc5079SArnaldo Carvalho de Melo sig_winch_handler(SIGWINCH); 8233b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, sig_winch_handler); 8243b6ed988SArnaldo Carvalho de Melo } else 8253b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, SIG_DFL); 826923c42c1SMike Galbraith break; 827923c42c1SMike Galbraith case 'E': 828923c42c1SMike Galbraith if (nr_counters > 1) { 829923c42c1SMike Galbraith int i; 830923c42c1SMike Galbraith 831923c42c1SMike Galbraith fprintf(stderr, "\nAvailable events:"); 832923c42c1SMike Galbraith for (i = 0; i < nr_counters; i++) 833923c42c1SMike Galbraith fprintf(stderr, "\n\t%d %s", i, event_name(i)); 834923c42c1SMike Galbraith 835923c42c1SMike Galbraith prompt_integer(&sym_counter, "Enter details event counter"); 836923c42c1SMike Galbraith 837923c42c1SMike Galbraith if (sym_counter >= nr_counters) { 838923c42c1SMike Galbraith fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(0)); 839923c42c1SMike Galbraith sym_counter = 0; 840923c42c1SMike Galbraith sleep(1); 841923c42c1SMike Galbraith } 842923c42c1SMike Galbraith } else sym_counter = 0; 843923c42c1SMike Galbraith break; 844923c42c1SMike Galbraith case 'f': 845923c42c1SMike Galbraith prompt_integer(&count_filter, "Enter display event count filter"); 846923c42c1SMike Galbraith break; 847923c42c1SMike Galbraith case 'F': 848923c42c1SMike Galbraith prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)"); 849923c42c1SMike Galbraith break; 8508ffcda17SArnaldo Carvalho de Melo case 'K': 8518ffcda17SArnaldo Carvalho de Melo hide_kernel_symbols = !hide_kernel_symbols; 8528ffcda17SArnaldo Carvalho de Melo break; 853923c42c1SMike Galbraith case 'q': 854923c42c1SMike Galbraith case 'Q': 855923c42c1SMike Galbraith printf("exiting.\n"); 856c338aee8SArnaldo Carvalho de Melo if (dump_symtab) 857cbf69680SArnaldo Carvalho de Melo perf_session__fprintf_dsos(session, stderr); 858923c42c1SMike Galbraith exit(0); 859923c42c1SMike Galbraith case 's': 860923c42c1SMike Galbraith prompt_symbol(&sym_filter_entry, "Enter details symbol"); 861923c42c1SMike Galbraith break; 862923c42c1SMike Galbraith case 'S': 863923c42c1SMike Galbraith if (!sym_filter_entry) 864923c42c1SMike Galbraith break; 865923c42c1SMike Galbraith else { 866923c42c1SMike Galbraith struct sym_entry *syme = sym_filter_entry; 867923c42c1SMike Galbraith 868b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 869923c42c1SMike Galbraith sym_filter_entry = NULL; 870923c42c1SMike Galbraith __zero_source_counters(syme); 871b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 872923c42c1SMike Galbraith } 873923c42c1SMike Galbraith break; 8748ffcda17SArnaldo Carvalho de Melo case 'U': 8758ffcda17SArnaldo Carvalho de Melo hide_user_symbols = !hide_user_symbols; 8768ffcda17SArnaldo Carvalho de Melo break; 87746ab9764SMike Galbraith case 'w': 87846ab9764SMike Galbraith display_weighted = ~display_weighted; 87946ab9764SMike Galbraith break; 880923c42c1SMike Galbraith case 'z': 881c0555642SIan Munsie zero = !zero; 882923c42c1SMike Galbraith break; 88383a0944fSIngo Molnar default: 88483a0944fSIngo Molnar break; 885923c42c1SMike Galbraith } 886923c42c1SMike Galbraith } 887923c42c1SMike Galbraith 888f37a291cSIngo Molnar static void *display_thread(void *arg __used) 88986470930SIngo Molnar { 89086470930SIngo Molnar struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 891923c42c1SMike Galbraith struct termios tc, save; 892923c42c1SMike Galbraith int delay_msecs, c; 893a1645ce1SZhang, Yanmin struct perf_session *session = (struct perf_session *) arg; 89486470930SIngo Molnar 895923c42c1SMike Galbraith tcgetattr(0, &save); 896923c42c1SMike Galbraith tc = save; 897923c42c1SMike Galbraith tc.c_lflag &= ~(ICANON | ECHO); 898923c42c1SMike Galbraith tc.c_cc[VMIN] = 0; 899923c42c1SMike Galbraith tc.c_cc[VTIME] = 0; 900091bd2e9SMike Galbraith 901923c42c1SMike Galbraith repeat: 902923c42c1SMike Galbraith delay_msecs = delay_secs * 1000; 903923c42c1SMike Galbraith tcsetattr(0, TCSANOW, &tc); 904923c42c1SMike Galbraith /* trash return*/ 905923c42c1SMike Galbraith getc(stdin); 90686470930SIngo Molnar 90786470930SIngo Molnar do { 90886470930SIngo Molnar print_sym_table(); 90986470930SIngo Molnar } while (!poll(&stdin_poll, 1, delay_msecs) == 1); 91086470930SIngo Molnar 911923c42c1SMike Galbraith c = getc(stdin); 912923c42c1SMike Galbraith tcsetattr(0, TCSAFLUSH, &save); 913923c42c1SMike Galbraith 914a1645ce1SZhang, Yanmin handle_keypress(session, c); 915923c42c1SMike Galbraith goto repeat; 91686470930SIngo Molnar 91786470930SIngo Molnar return NULL; 91886470930SIngo Molnar } 91986470930SIngo Molnar 9202ab52083SAnton Blanchard /* Tag samples to be skipped. */ 921f37a291cSIngo Molnar static const char *skip_symbols[] = { 9222ab52083SAnton Blanchard "default_idle", 9232ab52083SAnton Blanchard "cpu_idle", 9242ab52083SAnton Blanchard "enter_idle", 9252ab52083SAnton Blanchard "exit_idle", 9262ab52083SAnton Blanchard "mwait_idle", 92759b90056SArnaldo Carvalho de Melo "mwait_idle_with_hints", 9288357275bSArnaldo Carvalho de Melo "poll_idle", 9293a3393efSAnton Blanchard "ppc64_runlatch_off", 9303a3393efSAnton Blanchard "pseries_dedicated_idle_sleep", 9312ab52083SAnton Blanchard NULL 9322ab52083SAnton Blanchard }; 9332ab52083SAnton Blanchard 934439d473bSArnaldo Carvalho de Melo static int symbol_filter(struct map *map, struct symbol *sym) 93586470930SIngo Molnar { 93686470930SIngo Molnar struct sym_entry *syme; 93786470930SIngo Molnar const char *name = sym->name; 9382ab52083SAnton Blanchard int i; 93986470930SIngo Molnar 9403a3393efSAnton Blanchard /* 9413a3393efSAnton Blanchard * ppc64 uses function descriptors and appends a '.' to the 9423a3393efSAnton Blanchard * start of every instruction address. Remove it. 9433a3393efSAnton Blanchard */ 9443a3393efSAnton Blanchard if (name[0] == '.') 9453a3393efSAnton Blanchard name++; 9463a3393efSAnton Blanchard 94786470930SIngo Molnar if (!strcmp(name, "_text") || 94886470930SIngo Molnar !strcmp(name, "_etext") || 94986470930SIngo Molnar !strcmp(name, "_sinittext") || 95086470930SIngo Molnar !strncmp("init_module", name, 11) || 95186470930SIngo Molnar !strncmp("cleanup_module", name, 14) || 95286470930SIngo Molnar strstr(name, "_text_start") || 95386470930SIngo Molnar strstr(name, "_text_end")) 95486470930SIngo Molnar return 1; 95586470930SIngo Molnar 95600a192b3SArnaldo Carvalho de Melo syme = symbol__priv(sym); 957439d473bSArnaldo Carvalho de Melo syme->map = map; 958b269876cSArnaldo Carvalho de Melo syme->src = NULL; 9596cff0e8dSKirill Smelkov 9606cff0e8dSKirill Smelkov if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) { 9616cff0e8dSKirill Smelkov /* schedule initial sym_filter_entry setup */ 9626cff0e8dSKirill Smelkov sym_filter_entry_sched = syme; 9636cff0e8dSKirill Smelkov sym_filter = NULL; 9646cff0e8dSKirill Smelkov } 965923c42c1SMike Galbraith 9662ab52083SAnton Blanchard for (i = 0; skip_symbols[i]; i++) { 9672ab52083SAnton Blanchard if (!strcmp(skip_symbols[i], name)) { 96886470930SIngo Molnar syme->skip = 1; 9692ab52083SAnton Blanchard break; 9702ab52083SAnton Blanchard } 9712ab52083SAnton Blanchard } 97286470930SIngo Molnar 97313cc5079SArnaldo Carvalho de Melo if (!syme->skip) 97413cc5079SArnaldo Carvalho de Melo syme->name_len = strlen(sym->name); 97513cc5079SArnaldo Carvalho de Melo 97686470930SIngo Molnar return 0; 97786470930SIngo Molnar } 97886470930SIngo Molnar 979b3165f41SArnaldo Carvalho de Melo static void event__process_sample(const event_t *self, 980b3165f41SArnaldo Carvalho de Melo struct perf_session *session, int counter) 98186470930SIngo Molnar { 9825b2bb75aSArnaldo Carvalho de Melo u64 ip = self->ip.ip; 9835b2bb75aSArnaldo Carvalho de Melo struct sym_entry *syme; 9841ed091c4SArnaldo Carvalho de Melo struct addr_location al; 98523346f21SArnaldo Carvalho de Melo struct machine *machine; 9868ffcda17SArnaldo Carvalho de Melo u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 98786470930SIngo Molnar 98824bfef0fSArnaldo Carvalho de Melo ++samples; 98924bfef0fSArnaldo Carvalho de Melo 9908ffcda17SArnaldo Carvalho de Melo switch (origin) { 9911ed091c4SArnaldo Carvalho de Melo case PERF_RECORD_MISC_USER: 992a1645ce1SZhang, Yanmin ++us_samples; 9938ffcda17SArnaldo Carvalho de Melo if (hide_user_symbols) 9948ffcda17SArnaldo Carvalho de Melo return; 99523346f21SArnaldo Carvalho de Melo machine = perf_session__find_host_machine(session); 9965b2bb75aSArnaldo Carvalho de Melo break; 9975b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_MISC_KERNEL: 998a1645ce1SZhang, Yanmin ++kernel_samples; 9998ffcda17SArnaldo Carvalho de Melo if (hide_kernel_symbols) 10008ffcda17SArnaldo Carvalho de Melo return; 100123346f21SArnaldo Carvalho de Melo machine = perf_session__find_host_machine(session); 10025b2bb75aSArnaldo Carvalho de Melo break; 1003a1645ce1SZhang, Yanmin case PERF_RECORD_MISC_GUEST_KERNEL: 1004a1645ce1SZhang, Yanmin ++guest_kernel_samples; 100523346f21SArnaldo Carvalho de Melo machine = perf_session__find_machine(session, self->ip.pid); 1006a1645ce1SZhang, Yanmin break; 1007a1645ce1SZhang, Yanmin case PERF_RECORD_MISC_GUEST_USER: 1008a1645ce1SZhang, Yanmin ++guest_us_samples; 1009a1645ce1SZhang, Yanmin /* 1010a1645ce1SZhang, Yanmin * TODO: we don't process guest user from host side 1011a1645ce1SZhang, Yanmin * except simple counting. 1012a1645ce1SZhang, Yanmin */ 1013a1645ce1SZhang, Yanmin return; 10145b2bb75aSArnaldo Carvalho de Melo default: 10155b2bb75aSArnaldo Carvalho de Melo return; 10165b2bb75aSArnaldo Carvalho de Melo } 10175b2bb75aSArnaldo Carvalho de Melo 101823346f21SArnaldo Carvalho de Melo if (!machine && perf_guest) { 1019a1645ce1SZhang, Yanmin pr_err("Can't find guest [%d]'s kernel information\n", 1020a1645ce1SZhang, Yanmin self->ip.pid); 1021a1645ce1SZhang, Yanmin return; 1022a1645ce1SZhang, Yanmin } 1023a1645ce1SZhang, Yanmin 1024ab608344SPeter Zijlstra if (self->header.misc & PERF_RECORD_MISC_EXACT_IP) 10251676b8a0SPeter Zijlstra exact_samples++; 10261676b8a0SPeter Zijlstra 1027b3165f41SArnaldo Carvalho de Melo if (event__preprocess_sample(self, session, &al, symbol_filter) < 0 || 102872b8fa17SArnaldo Carvalho de Melo al.filtered) 10291ed091c4SArnaldo Carvalho de Melo return; 103086470930SIngo Molnar 103172b8fa17SArnaldo Carvalho de Melo if (al.sym == NULL) { 103272b8fa17SArnaldo Carvalho de Melo /* 103372b8fa17SArnaldo Carvalho de Melo * As we do lazy loading of symtabs we only will know if the 103472b8fa17SArnaldo Carvalho de Melo * specified vmlinux file is invalid when we actually have a 103572b8fa17SArnaldo Carvalho de Melo * hit in kernel space and then try to load it. So if we get 103672b8fa17SArnaldo Carvalho de Melo * here and there are _no_ symbols in the DSO backing the 103772b8fa17SArnaldo Carvalho de Melo * kernel map, bail out. 103872b8fa17SArnaldo Carvalho de Melo * 103972b8fa17SArnaldo Carvalho de Melo * We may never get here, for instance, if we use -K/ 104072b8fa17SArnaldo Carvalho de Melo * --hide-kernel-symbols, even if the user specifies an 104172b8fa17SArnaldo Carvalho de Melo * invalid --vmlinux ;-) 104272b8fa17SArnaldo Carvalho de Melo */ 104323346f21SArnaldo Carvalho de Melo if (al.map == machine->vmlinux_maps[MAP__FUNCTION] && 104472b8fa17SArnaldo Carvalho de Melo RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 104572b8fa17SArnaldo Carvalho de Melo pr_err("The %s file can't be used\n", 104672b8fa17SArnaldo Carvalho de Melo symbol_conf.vmlinux_name); 104772b8fa17SArnaldo Carvalho de Melo exit(1); 104872b8fa17SArnaldo Carvalho de Melo } 104972b8fa17SArnaldo Carvalho de Melo 105072b8fa17SArnaldo Carvalho de Melo return; 105172b8fa17SArnaldo Carvalho de Melo } 105272b8fa17SArnaldo Carvalho de Melo 10536cff0e8dSKirill Smelkov /* let's see, whether we need to install initial sym_filter_entry */ 10546cff0e8dSKirill Smelkov if (sym_filter_entry_sched) { 10556cff0e8dSKirill Smelkov sym_filter_entry = sym_filter_entry_sched; 10566cff0e8dSKirill Smelkov sym_filter_entry_sched = NULL; 1057b0a9ab62SArnaldo Carvalho de Melo if (parse_source(sym_filter_entry) < 0) { 1058b0a9ab62SArnaldo Carvalho de Melo struct symbol *sym = sym_entry__symbol(sym_filter_entry); 1059b0a9ab62SArnaldo Carvalho de Melo 1060b0a9ab62SArnaldo Carvalho de Melo pr_err("Can't annotate %s", sym->name); 1061b0a9ab62SArnaldo Carvalho de Melo if (sym_filter_entry->map->dso->origin == DSO__ORIG_KERNEL) { 1062b0a9ab62SArnaldo Carvalho de Melo pr_err(": No vmlinux file was found in the path:\n"); 1063b0a9ab62SArnaldo Carvalho de Melo vmlinux_path__fprintf(stderr); 1064b0a9ab62SArnaldo Carvalho de Melo } else 1065b0a9ab62SArnaldo Carvalho de Melo pr_err(".\n"); 1066b0a9ab62SArnaldo Carvalho de Melo exit(1); 1067b0a9ab62SArnaldo Carvalho de Melo } 10686cff0e8dSKirill Smelkov } 10696cff0e8dSKirill Smelkov 10701ed091c4SArnaldo Carvalho de Melo syme = symbol__priv(al.sym); 107186470930SIngo Molnar if (!syme->skip) { 107286470930SIngo Molnar syme->count[counter]++; 10738ffcda17SArnaldo Carvalho de Melo syme->origin = origin; 1074923c42c1SMike Galbraith record_precise_ip(syme, counter, ip); 107586470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 107686470930SIngo Molnar if (list_empty(&syme->node) || !syme->node.next) 107786470930SIngo Molnar __list_insert_active_sym(syme); 107886470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 107986470930SIngo Molnar } 108086470930SIngo Molnar } 108186470930SIngo Molnar 1082d8f66248SArnaldo Carvalho de Melo static int event__process(event_t *event, struct perf_session *session) 10835b2bb75aSArnaldo Carvalho de Melo { 10845b2bb75aSArnaldo Carvalho de Melo switch (event->header.type) { 10855b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_COMM: 1086d8f66248SArnaldo Carvalho de Melo event__process_comm(event, session); 10875b2bb75aSArnaldo Carvalho de Melo break; 10885b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_MMAP: 1089d8f66248SArnaldo Carvalho de Melo event__process_mmap(event, session); 10905b2bb75aSArnaldo Carvalho de Melo break; 10910f35cd4cSArnaldo Carvalho de Melo case PERF_RECORD_FORK: 10920f35cd4cSArnaldo Carvalho de Melo case PERF_RECORD_EXIT: 10930f35cd4cSArnaldo Carvalho de Melo event__process_task(event, session); 10940f35cd4cSArnaldo Carvalho de Melo break; 10955b2bb75aSArnaldo Carvalho de Melo default: 10965b2bb75aSArnaldo Carvalho de Melo break; 10975b2bb75aSArnaldo Carvalho de Melo } 10985b2bb75aSArnaldo Carvalho de Melo 10995b2bb75aSArnaldo Carvalho de Melo return 0; 110086470930SIngo Molnar } 110186470930SIngo Molnar 110286470930SIngo Molnar struct mmap_data { 110386470930SIngo Molnar int counter; 110486470930SIngo Molnar void *base; 1105f37a291cSIngo Molnar int mask; 110686470930SIngo Molnar unsigned int prev; 110786470930SIngo Molnar }; 110886470930SIngo Molnar 110986470930SIngo Molnar static unsigned int mmap_read_head(struct mmap_data *md) 111086470930SIngo Molnar { 1111cdd6c482SIngo Molnar struct perf_event_mmap_page *pc = md->base; 111286470930SIngo Molnar int head; 111386470930SIngo Molnar 111486470930SIngo Molnar head = pc->data_head; 111586470930SIngo Molnar rmb(); 111686470930SIngo Molnar 111786470930SIngo Molnar return head; 111886470930SIngo Molnar } 111986470930SIngo Molnar 1120d8f66248SArnaldo Carvalho de Melo static void perf_session__mmap_read_counter(struct perf_session *self, 1121d8f66248SArnaldo Carvalho de Melo struct mmap_data *md) 112286470930SIngo Molnar { 112386470930SIngo Molnar unsigned int head = mmap_read_head(md); 112486470930SIngo Molnar unsigned int old = md->prev; 112586470930SIngo Molnar unsigned char *data = md->base + page_size; 112686470930SIngo Molnar int diff; 112786470930SIngo Molnar 112886470930SIngo Molnar /* 112986470930SIngo Molnar * If we're further behind than half the buffer, there's a chance 113086470930SIngo Molnar * the writer will bite our tail and mess up the samples under us. 113186470930SIngo Molnar * 113286470930SIngo Molnar * If we somehow ended up ahead of the head, we got messed up. 113386470930SIngo Molnar * 113486470930SIngo Molnar * In either case, truncate and restart at head. 113586470930SIngo Molnar */ 113686470930SIngo Molnar diff = head - old; 113786470930SIngo Molnar if (diff > md->mask / 2 || diff < 0) { 1138f4f0b418SMike Galbraith fprintf(stderr, "WARNING: failed to keep up with mmap data.\n"); 113986470930SIngo Molnar 114086470930SIngo Molnar /* 114186470930SIngo Molnar * head points to a known good entry, start there. 114286470930SIngo Molnar */ 114386470930SIngo Molnar old = head; 114486470930SIngo Molnar } 114586470930SIngo Molnar 114686470930SIngo Molnar for (; old != head;) { 114786470930SIngo Molnar event_t *event = (event_t *)&data[old & md->mask]; 114886470930SIngo Molnar 114986470930SIngo Molnar event_t event_copy; 115086470930SIngo Molnar 115186470930SIngo Molnar size_t size = event->header.size; 115286470930SIngo Molnar 115386470930SIngo Molnar /* 115486470930SIngo Molnar * Event straddles the mmap boundary -- header should always 115586470930SIngo Molnar * be inside due to u64 alignment of output. 115686470930SIngo Molnar */ 115786470930SIngo Molnar if ((old & md->mask) + size != ((old + size) & md->mask)) { 115886470930SIngo Molnar unsigned int offset = old; 115986470930SIngo Molnar unsigned int len = min(sizeof(*event), size), cpy; 116086470930SIngo Molnar void *dst = &event_copy; 116186470930SIngo Molnar 116286470930SIngo Molnar do { 116386470930SIngo Molnar cpy = min(md->mask + 1 - (offset & md->mask), len); 116486470930SIngo Molnar memcpy(dst, &data[offset & md->mask], cpy); 116586470930SIngo Molnar offset += cpy; 116686470930SIngo Molnar dst += cpy; 116786470930SIngo Molnar len -= cpy; 116886470930SIngo Molnar } while (len); 116986470930SIngo Molnar 117086470930SIngo Molnar event = &event_copy; 117186470930SIngo Molnar } 117286470930SIngo Molnar 11735b2bb75aSArnaldo Carvalho de Melo if (event->header.type == PERF_RECORD_SAMPLE) 1174b3165f41SArnaldo Carvalho de Melo event__process_sample(event, self, md->counter); 11755b2bb75aSArnaldo Carvalho de Melo else 1176d8f66248SArnaldo Carvalho de Melo event__process(event, self); 117786470930SIngo Molnar old += size; 117886470930SIngo Molnar } 117986470930SIngo Molnar 118086470930SIngo Molnar md->prev = old; 118186470930SIngo Molnar } 118286470930SIngo Molnar 1183d6d901c2SZhang, Yanmin static struct pollfd *event_array; 1184d6d901c2SZhang, Yanmin static struct mmap_data *mmap_array[MAX_NR_CPUS][MAX_COUNTERS]; 118586470930SIngo Molnar 1186d8f66248SArnaldo Carvalho de Melo static void perf_session__mmap_read(struct perf_session *self) 11872f01190aSFrederic Weisbecker { 1188d6d901c2SZhang, Yanmin int i, counter, thread_index; 11892f01190aSFrederic Weisbecker 11902f01190aSFrederic Weisbecker for (i = 0; i < nr_cpus; i++) { 11912f01190aSFrederic Weisbecker for (counter = 0; counter < nr_counters; counter++) 1192d6d901c2SZhang, Yanmin for (thread_index = 0; 1193d6d901c2SZhang, Yanmin thread_index < thread_num; 1194d6d901c2SZhang, Yanmin thread_index++) { 1195d6d901c2SZhang, Yanmin perf_session__mmap_read_counter(self, 1196d6d901c2SZhang, Yanmin &mmap_array[i][counter][thread_index]); 1197d6d901c2SZhang, Yanmin } 11982f01190aSFrederic Weisbecker } 11992f01190aSFrederic Weisbecker } 12002f01190aSFrederic Weisbecker 1201716c69feSIngo Molnar int nr_poll; 1202716c69feSIngo Molnar int group_fd; 1203716c69feSIngo Molnar 1204716c69feSIngo Molnar static void start_counter(int i, int counter) 120586470930SIngo Molnar { 1206cdd6c482SIngo Molnar struct perf_event_attr *attr; 12070fdc7e67SMike Galbraith int cpu; 1208d6d901c2SZhang, Yanmin int thread_index; 120986470930SIngo Molnar 121086470930SIngo Molnar cpu = profile_cpu; 1211d6d901c2SZhang, Yanmin if (target_tid == -1 && profile_cpu == -1) 1212a12b51c4SPaul Mackerras cpu = cpumap[i]; 121386470930SIngo Molnar 121486470930SIngo Molnar attr = attrs + counter; 121586470930SIngo Molnar 121686470930SIngo Molnar attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID; 12177e4ff9e3SMike Galbraith 12187e4ff9e3SMike Galbraith if (freq) { 12197e4ff9e3SMike Galbraith attr->sample_type |= PERF_SAMPLE_PERIOD; 12207e4ff9e3SMike Galbraith attr->freq = 1; 12217e4ff9e3SMike Galbraith attr->sample_freq = freq; 12227e4ff9e3SMike Galbraith } 12237e4ff9e3SMike Galbraith 12240fdc7e67SMike Galbraith attr->inherit = (cpu < 0) && inherit; 12255b2bb75aSArnaldo Carvalho de Melo attr->mmap = 1; 122686470930SIngo Molnar 1227d6d901c2SZhang, Yanmin for (thread_index = 0; thread_index < thread_num; thread_index++) { 1228716c69feSIngo Molnar try_again: 1229d6d901c2SZhang, Yanmin fd[i][counter][thread_index] = sys_perf_event_open(attr, 1230d6d901c2SZhang, Yanmin all_tids[thread_index], cpu, group_fd, 0); 1231716c69feSIngo Molnar 1232d6d901c2SZhang, Yanmin if (fd[i][counter][thread_index] < 0) { 123386470930SIngo Molnar int err = errno; 123486470930SIngo Molnar 1235c10edee2SPekka Enberg if (err == EPERM || err == EACCES) 1236716c69feSIngo Molnar die("No permission - are you root?\n"); 1237716c69feSIngo Molnar /* 1238716c69feSIngo Molnar * If it's cycles then fall back to hrtimer 1239716c69feSIngo Molnar * based cpu-clock-tick sw counter, which 1240716c69feSIngo Molnar * is always available even if no PMU support: 1241716c69feSIngo Molnar */ 1242716c69feSIngo Molnar if (attr->type == PERF_TYPE_HARDWARE 1243f4dbfa8fSPeter Zijlstra && attr->config == PERF_COUNT_HW_CPU_CYCLES) { 1244716c69feSIngo Molnar 12453da297a6SIngo Molnar if (verbose) 1246716c69feSIngo Molnar warning(" ... trying to fall back to cpu-clock-ticks\n"); 12473da297a6SIngo Molnar 1248716c69feSIngo Molnar attr->type = PERF_TYPE_SOFTWARE; 1249f4dbfa8fSPeter Zijlstra attr->config = PERF_COUNT_SW_CPU_CLOCK; 1250716c69feSIngo Molnar goto try_again; 1251716c69feSIngo Molnar } 125230c806a0SIngo Molnar printf("\n"); 125330c806a0SIngo Molnar error("perfcounter syscall returned with %d (%s)\n", 1254d6d901c2SZhang, Yanmin fd[i][counter][thread_index], strerror(err)); 1255cdd6c482SIngo Molnar die("No CONFIG_PERF_EVENTS=y kernel support configured?\n"); 125686470930SIngo Molnar exit(-1); 125786470930SIngo Molnar } 1258d6d901c2SZhang, Yanmin assert(fd[i][counter][thread_index] >= 0); 1259d6d901c2SZhang, Yanmin fcntl(fd[i][counter][thread_index], F_SETFL, O_NONBLOCK); 126086470930SIngo Molnar 126186470930SIngo Molnar /* 126286470930SIngo Molnar * First counter acts as the group leader: 126386470930SIngo Molnar */ 126486470930SIngo Molnar if (group && group_fd == -1) 1265d6d901c2SZhang, Yanmin group_fd = fd[i][counter][thread_index]; 126686470930SIngo Molnar 1267d6d901c2SZhang, Yanmin event_array[nr_poll].fd = fd[i][counter][thread_index]; 126886470930SIngo Molnar event_array[nr_poll].events = POLLIN; 126986470930SIngo Molnar nr_poll++; 127086470930SIngo Molnar 1271d6d901c2SZhang, Yanmin mmap_array[i][counter][thread_index].counter = counter; 1272d6d901c2SZhang, Yanmin mmap_array[i][counter][thread_index].prev = 0; 1273d6d901c2SZhang, Yanmin mmap_array[i][counter][thread_index].mask = mmap_pages*page_size - 1; 1274d6d901c2SZhang, Yanmin mmap_array[i][counter][thread_index].base = mmap(NULL, (mmap_pages+1)*page_size, 1275d6d901c2SZhang, Yanmin PROT_READ, MAP_SHARED, fd[i][counter][thread_index], 0); 1276d6d901c2SZhang, Yanmin if (mmap_array[i][counter][thread_index].base == MAP_FAILED) 127786470930SIngo Molnar die("failed to mmap with %d (%s)\n", errno, strerror(errno)); 127886470930SIngo Molnar } 1279d6d901c2SZhang, Yanmin } 1280716c69feSIngo Molnar 1281716c69feSIngo Molnar static int __cmd_top(void) 1282716c69feSIngo Molnar { 1283716c69feSIngo Molnar pthread_t thread; 1284716c69feSIngo Molnar int i, counter; 1285716c69feSIngo Molnar int ret; 1286d8f66248SArnaldo Carvalho de Melo /* 1287b3165f41SArnaldo Carvalho de Melo * FIXME: perf_session__new should allow passing a O_MMAP, so that all this 1288b3165f41SArnaldo Carvalho de Melo * mmap reading, etc is encapsulated in it. Use O_WRONLY for now. 1289d8f66248SArnaldo Carvalho de Melo */ 1290454c407eSTom Zanussi struct perf_session *session = perf_session__new(NULL, O_WRONLY, false, false); 1291b3165f41SArnaldo Carvalho de Melo if (session == NULL) 1292b3165f41SArnaldo Carvalho de Melo return -ENOMEM; 1293716c69feSIngo Molnar 1294d6d901c2SZhang, Yanmin if (target_tid != -1) 1295d6d901c2SZhang, Yanmin event__synthesize_thread(target_tid, event__process, session); 12965b2bb75aSArnaldo Carvalho de Melo else 1297d8f66248SArnaldo Carvalho de Melo event__synthesize_threads(event__process, session); 12985b2bb75aSArnaldo Carvalho de Melo 1299716c69feSIngo Molnar for (i = 0; i < nr_cpus; i++) { 1300716c69feSIngo Molnar group_fd = -1; 1301716c69feSIngo Molnar for (counter = 0; counter < nr_counters; counter++) 1302716c69feSIngo Molnar start_counter(i, counter); 130386470930SIngo Molnar } 130486470930SIngo Molnar 13052f01190aSFrederic Weisbecker /* Wait for a minimal set of events before starting the snapshot */ 1306d6d901c2SZhang, Yanmin poll(&event_array[0], nr_poll, 100); 13072f01190aSFrederic Weisbecker 1308d8f66248SArnaldo Carvalho de Melo perf_session__mmap_read(session); 13092f01190aSFrederic Weisbecker 1310a1645ce1SZhang, Yanmin if (pthread_create(&thread, NULL, display_thread, session)) { 131186470930SIngo Molnar printf("Could not create display thread.\n"); 131286470930SIngo Molnar exit(-1); 131386470930SIngo Molnar } 131486470930SIngo Molnar 131586470930SIngo Molnar if (realtime_prio) { 131686470930SIngo Molnar struct sched_param param; 131786470930SIngo Molnar 131886470930SIngo Molnar param.sched_priority = realtime_prio; 131986470930SIngo Molnar if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 132086470930SIngo Molnar printf("Could not set realtime priority.\n"); 132186470930SIngo Molnar exit(-1); 132286470930SIngo Molnar } 132386470930SIngo Molnar } 132486470930SIngo Molnar 132586470930SIngo Molnar while (1) { 132686470930SIngo Molnar int hits = samples; 132786470930SIngo Molnar 1328d8f66248SArnaldo Carvalho de Melo perf_session__mmap_read(session); 132986470930SIngo Molnar 133086470930SIngo Molnar if (hits == samples) 133186470930SIngo Molnar ret = poll(event_array, nr_poll, 100); 133286470930SIngo Molnar } 133386470930SIngo Molnar 133486470930SIngo Molnar return 0; 133586470930SIngo Molnar } 133686470930SIngo Molnar 133786470930SIngo Molnar static const char * const top_usage[] = { 133886470930SIngo Molnar "perf top [<options>]", 133986470930SIngo Molnar NULL 134086470930SIngo Molnar }; 134186470930SIngo Molnar 134286470930SIngo Molnar static const struct option options[] = { 134386470930SIngo Molnar OPT_CALLBACK('e', "event", NULL, "event", 134486470930SIngo Molnar "event selector. use 'perf list' to list available events", 134586470930SIngo Molnar parse_events), 134686470930SIngo Molnar OPT_INTEGER('c', "count", &default_interval, 134786470930SIngo Molnar "event period to sample"), 134886470930SIngo Molnar OPT_INTEGER('p', "pid", &target_pid, 1349d6d901c2SZhang, Yanmin "profile events on existing process id"), 1350d6d901c2SZhang, Yanmin OPT_INTEGER('t', "tid", &target_tid, 1351d6d901c2SZhang, Yanmin "profile events on existing thread id"), 135286470930SIngo Molnar OPT_BOOLEAN('a', "all-cpus", &system_wide, 135386470930SIngo Molnar "system-wide collection from all CPUs"), 135486470930SIngo Molnar OPT_INTEGER('C', "CPU", &profile_cpu, 135586470930SIngo Molnar "CPU to profile on"), 1356b32d133aSArnaldo Carvalho de Melo OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 1357b32d133aSArnaldo Carvalho de Melo "file", "vmlinux pathname"), 13588ffcda17SArnaldo Carvalho de Melo OPT_BOOLEAN('K', "hide_kernel_symbols", &hide_kernel_symbols, 13598ffcda17SArnaldo Carvalho de Melo "hide kernel symbols"), 13601967936dSArnaldo Carvalho de Melo OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"), 136186470930SIngo Molnar OPT_INTEGER('r', "realtime", &realtime_prio, 136286470930SIngo Molnar "collect data with this RT SCHED_FIFO priority"), 136386470930SIngo Molnar OPT_INTEGER('d', "delay", &delay_secs, 136486470930SIngo Molnar "number of seconds to delay between refreshes"), 136586470930SIngo Molnar OPT_BOOLEAN('D', "dump-symtab", &dump_symtab, 136686470930SIngo Molnar "dump the symbol table used for profiling"), 136786470930SIngo Molnar OPT_INTEGER('f', "count-filter", &count_filter, 136886470930SIngo Molnar "only display functions with more events than this"), 136986470930SIngo Molnar OPT_BOOLEAN('g', "group", &group, 137086470930SIngo Molnar "put the counters into a counter group"), 13710fdc7e67SMike Galbraith OPT_BOOLEAN('i', "inherit", &inherit, 13720fdc7e67SMike Galbraith "child tasks inherit counters"), 1373923c42c1SMike Galbraith OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name", 13746cff0e8dSKirill Smelkov "symbol to annotate"), 13751f208ea6SAnton Blanchard OPT_BOOLEAN('z', "zero", &zero, 137686470930SIngo Molnar "zero history across updates"), 137786470930SIngo Molnar OPT_INTEGER('F', "freq", &freq, 137886470930SIngo Molnar "profile at this frequency"), 137986470930SIngo Molnar OPT_INTEGER('E', "entries", &print_entries, 138086470930SIngo Molnar "display this many functions"), 13818ffcda17SArnaldo Carvalho de Melo OPT_BOOLEAN('U', "hide_user_symbols", &hide_user_symbols, 13828ffcda17SArnaldo Carvalho de Melo "hide user symbols"), 1383c0555642SIan Munsie OPT_INCR('v', "verbose", &verbose, 13843da297a6SIngo Molnar "be more verbose (show counter open errors, etc)"), 138586470930SIngo Molnar OPT_END() 138686470930SIngo Molnar }; 138786470930SIngo Molnar 1388f37a291cSIngo Molnar int cmd_top(int argc, const char **argv, const char *prefix __used) 138986470930SIngo Molnar { 1390b32d133aSArnaldo Carvalho de Melo int counter; 1391d6d901c2SZhang, Yanmin int i,j; 139286470930SIngo Molnar 139386470930SIngo Molnar page_size = sysconf(_SC_PAGE_SIZE); 139486470930SIngo Molnar 139586470930SIngo Molnar argc = parse_options(argc, argv, options, top_usage, 0); 139686470930SIngo Molnar if (argc) 139786470930SIngo Molnar usage_with_options(top_usage, options); 139886470930SIngo Molnar 1399d6d901c2SZhang, Yanmin if (target_pid != -1) { 1400d6d901c2SZhang, Yanmin target_tid = target_pid; 1401d6d901c2SZhang, Yanmin thread_num = find_all_tid(target_pid, &all_tids); 1402d6d901c2SZhang, Yanmin if (thread_num <= 0) { 1403d6d901c2SZhang, Yanmin fprintf(stderr, "Can't find all threads of pid %d\n", 1404d6d901c2SZhang, Yanmin target_pid); 1405d6d901c2SZhang, Yanmin usage_with_options(top_usage, options); 1406d6d901c2SZhang, Yanmin } 1407d6d901c2SZhang, Yanmin } else { 1408d6d901c2SZhang, Yanmin all_tids=malloc(sizeof(pid_t)); 1409d6d901c2SZhang, Yanmin if (!all_tids) 1410d6d901c2SZhang, Yanmin return -ENOMEM; 1411d6d901c2SZhang, Yanmin 1412d6d901c2SZhang, Yanmin all_tids[0] = target_tid; 1413d6d901c2SZhang, Yanmin thread_num = 1; 1414d6d901c2SZhang, Yanmin } 1415d6d901c2SZhang, Yanmin 1416d6d901c2SZhang, Yanmin for (i = 0; i < MAX_NR_CPUS; i++) { 1417d6d901c2SZhang, Yanmin for (j = 0; j < MAX_COUNTERS; j++) { 1418d6d901c2SZhang, Yanmin fd[i][j] = malloc(sizeof(int)*thread_num); 14195a103174SZhang, Yanmin mmap_array[i][j] = zalloc( 1420d6d901c2SZhang, Yanmin sizeof(struct mmap_data)*thread_num); 1421d6d901c2SZhang, Yanmin if (!fd[i][j] || !mmap_array[i][j]) 1422d6d901c2SZhang, Yanmin return -ENOMEM; 1423d6d901c2SZhang, Yanmin } 1424d6d901c2SZhang, Yanmin } 1425d6d901c2SZhang, Yanmin event_array = malloc( 1426d6d901c2SZhang, Yanmin sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num); 1427d6d901c2SZhang, Yanmin if (!event_array) 1428d6d901c2SZhang, Yanmin return -ENOMEM; 1429d6d901c2SZhang, Yanmin 143086470930SIngo Molnar /* CPU and PID are mutually exclusive */ 1431d6d901c2SZhang, Yanmin if (target_tid > 0 && profile_cpu != -1) { 143286470930SIngo Molnar printf("WARNING: PID switch overriding CPU\n"); 143386470930SIngo Molnar sleep(1); 143486470930SIngo Molnar profile_cpu = -1; 143586470930SIngo Molnar } 143686470930SIngo Molnar 143786470930SIngo Molnar if (!nr_counters) 143886470930SIngo Molnar nr_counters = 1; 143986470930SIngo Molnar 1440b32d133aSArnaldo Carvalho de Melo symbol_conf.priv_size = (sizeof(struct sym_entry) + 14415a8e5a30SArnaldo Carvalho de Melo (nr_counters + 1) * sizeof(unsigned long)); 14426cff0e8dSKirill Smelkov 14436cff0e8dSKirill Smelkov symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 144475be6cf4SArnaldo Carvalho de Melo if (symbol__init() < 0) 1445b32d133aSArnaldo Carvalho de Melo return -1; 14465a8e5a30SArnaldo Carvalho de Melo 144786470930SIngo Molnar if (delay_secs < 1) 144886470930SIngo Molnar delay_secs = 1; 144986470930SIngo Molnar 14507e4ff9e3SMike Galbraith /* 14517e4ff9e3SMike Galbraith * User specified count overrides default frequency. 14527e4ff9e3SMike Galbraith */ 14537e4ff9e3SMike Galbraith if (default_interval) 14547e4ff9e3SMike Galbraith freq = 0; 14557e4ff9e3SMike Galbraith else if (freq) { 14567e4ff9e3SMike Galbraith default_interval = freq; 14577e4ff9e3SMike Galbraith } else { 14587e4ff9e3SMike Galbraith fprintf(stderr, "frequency and count are zero, aborting\n"); 14597e4ff9e3SMike Galbraith exit(EXIT_FAILURE); 14607e4ff9e3SMike Galbraith } 14617e4ff9e3SMike Galbraith 146286470930SIngo Molnar /* 146386470930SIngo Molnar * Fill in the ones not specifically initialized via -c: 146486470930SIngo Molnar */ 146586470930SIngo Molnar for (counter = 0; counter < nr_counters; counter++) { 146686470930SIngo Molnar if (attrs[counter].sample_period) 146786470930SIngo Molnar continue; 146886470930SIngo Molnar 146986470930SIngo Molnar attrs[counter].sample_period = default_interval; 147086470930SIngo Molnar } 147186470930SIngo Molnar 1472d6d901c2SZhang, Yanmin if (target_tid != -1 || profile_cpu != -1) 147386470930SIngo Molnar nr_cpus = 1; 1474a12b51c4SPaul Mackerras else 1475a12b51c4SPaul Mackerras nr_cpus = read_cpu_map(); 147686470930SIngo Molnar 147713cc5079SArnaldo Carvalho de Melo get_term_dimensions(&winsize); 14783b6ed988SArnaldo Carvalho de Melo if (print_entries == 0) { 147913cc5079SArnaldo Carvalho de Melo update_print_entries(&winsize); 14803b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, sig_winch_handler); 14813b6ed988SArnaldo Carvalho de Melo } 14823b6ed988SArnaldo Carvalho de Melo 148386470930SIngo Molnar return __cmd_top(); 148486470930SIngo Molnar } 1485