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 5886470930SIngo Molnar static int fd[MAX_NR_CPUS][MAX_COUNTERS]; 5986470930SIngo Molnar 6086470930SIngo Molnar static int system_wide = 0; 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; 680fdc7e67SMike Galbraith static int inherit = 0; 6986470930SIngo Molnar static int profile_cpu = -1; 7086470930SIngo Molnar static int nr_cpus = 0; 7186470930SIngo Molnar static unsigned int realtime_prio = 0; 7286470930SIngo Molnar static int group = 0; 7386470930SIngo Molnar static unsigned int page_size; 7486470930SIngo Molnar static unsigned int mmap_pages = 16; 7542e59d7dSIngo Molnar static int freq = 1000; /* 1 KHz */ 7686470930SIngo Molnar 7786470930SIngo Molnar static int delay_secs = 2; 7842e59d7dSIngo Molnar static int zero = 0; 7942e59d7dSIngo Molnar static int dump_symtab = 0; 8086470930SIngo Molnar 818ffcda17SArnaldo Carvalho de Melo static bool hide_kernel_symbols = false; 828ffcda17SArnaldo Carvalho de Melo static bool hide_user_symbols = false; 8313cc5079SArnaldo Carvalho de Melo static struct winsize winsize; 848ffcda17SArnaldo Carvalho de Melo 8586470930SIngo Molnar /* 86923c42c1SMike Galbraith * Source 87923c42c1SMike Galbraith */ 88923c42c1SMike Galbraith 89923c42c1SMike Galbraith struct source_line { 90923c42c1SMike Galbraith u64 eip; 91923c42c1SMike Galbraith unsigned long count[MAX_COUNTERS]; 92923c42c1SMike Galbraith char *line; 93923c42c1SMike Galbraith struct source_line *next; 94923c42c1SMike Galbraith }; 95923c42c1SMike Galbraith 96923c42c1SMike Galbraith static char *sym_filter = NULL; 97923c42c1SMike Galbraith struct sym_entry *sym_filter_entry = NULL; 986cff0e8dSKirill Smelkov struct sym_entry *sym_filter_entry_sched = NULL; 99923c42c1SMike Galbraith static int sym_pcnt_filter = 5; 100923c42c1SMike Galbraith static int sym_counter = 0; 10146ab9764SMike Galbraith static int display_weighted = -1; 102923c42c1SMike Galbraith 103923c42c1SMike Galbraith /* 10486470930SIngo Molnar * Symbols 10586470930SIngo Molnar */ 10686470930SIngo Molnar 107b269876cSArnaldo Carvalho de Melo struct sym_entry_source { 108b269876cSArnaldo Carvalho de Melo struct source_line *source; 109b269876cSArnaldo Carvalho de Melo struct source_line *lines; 110b269876cSArnaldo Carvalho de Melo struct source_line **lines_tail; 111b269876cSArnaldo Carvalho de Melo pthread_mutex_t lock; 112b269876cSArnaldo Carvalho de Melo }; 113b269876cSArnaldo Carvalho de Melo 11486470930SIngo Molnar struct sym_entry { 11586470930SIngo Molnar struct rb_node rb_node; 11686470930SIngo Molnar struct list_head node; 11786470930SIngo Molnar unsigned long snap_count; 11886470930SIngo Molnar double weight; 11986470930SIngo Molnar int skip; 12013cc5079SArnaldo Carvalho de Melo u16 name_len; 1218ffcda17SArnaldo Carvalho de Melo u8 origin; 122439d473bSArnaldo Carvalho de Melo struct map *map; 123b269876cSArnaldo Carvalho de Melo struct sym_entry_source *src; 1245a8e5a30SArnaldo Carvalho de Melo unsigned long count[0]; 12586470930SIngo Molnar }; 12686470930SIngo Molnar 127923c42c1SMike Galbraith /* 128923c42c1SMike Galbraith * Source functions 129923c42c1SMike Galbraith */ 130923c42c1SMike Galbraith 13151a472deSArnaldo Carvalho de Melo static inline struct symbol *sym_entry__symbol(struct sym_entry *self) 13251a472deSArnaldo Carvalho de Melo { 133b32d133aSArnaldo Carvalho de Melo return ((void *)self) + symbol_conf.priv_size; 13451a472deSArnaldo Carvalho de Melo } 13551a472deSArnaldo Carvalho de Melo 13613cc5079SArnaldo Carvalho de Melo static void get_term_dimensions(struct winsize *ws) 1373b6ed988SArnaldo Carvalho de Melo { 13813cc5079SArnaldo Carvalho de Melo char *s = getenv("LINES"); 1393b6ed988SArnaldo Carvalho de Melo 14013cc5079SArnaldo Carvalho de Melo if (s != NULL) { 14113cc5079SArnaldo Carvalho de Melo ws->ws_row = atoi(s); 14213cc5079SArnaldo Carvalho de Melo s = getenv("COLUMNS"); 14313cc5079SArnaldo Carvalho de Melo if (s != NULL) { 14413cc5079SArnaldo Carvalho de Melo ws->ws_col = atoi(s); 14513cc5079SArnaldo Carvalho de Melo if (ws->ws_row && ws->ws_col) 14613cc5079SArnaldo Carvalho de Melo return; 14713cc5079SArnaldo Carvalho de Melo } 14813cc5079SArnaldo Carvalho de Melo } 1493b6ed988SArnaldo Carvalho de Melo #ifdef TIOCGWINSZ 15013cc5079SArnaldo Carvalho de Melo if (ioctl(1, TIOCGWINSZ, ws) == 0 && 15113cc5079SArnaldo Carvalho de Melo ws->ws_row && ws->ws_col) 15213cc5079SArnaldo Carvalho de Melo return; 1533b6ed988SArnaldo Carvalho de Melo #endif 15413cc5079SArnaldo Carvalho de Melo ws->ws_row = 25; 15513cc5079SArnaldo Carvalho de Melo ws->ws_col = 80; 1563b6ed988SArnaldo Carvalho de Melo } 1573b6ed988SArnaldo Carvalho de Melo 15813cc5079SArnaldo Carvalho de Melo static void update_print_entries(struct winsize *ws) 1593b6ed988SArnaldo Carvalho de Melo { 16013cc5079SArnaldo Carvalho de Melo print_entries = ws->ws_row; 16113cc5079SArnaldo Carvalho de Melo 1623b6ed988SArnaldo Carvalho de Melo if (print_entries > 9) 1633b6ed988SArnaldo Carvalho de Melo print_entries -= 9; 1643b6ed988SArnaldo Carvalho de Melo } 1653b6ed988SArnaldo Carvalho de Melo 1663b6ed988SArnaldo Carvalho de Melo static void sig_winch_handler(int sig __used) 1673b6ed988SArnaldo Carvalho de Melo { 16813cc5079SArnaldo Carvalho de Melo get_term_dimensions(&winsize); 16913cc5079SArnaldo Carvalho de Melo update_print_entries(&winsize); 1703b6ed988SArnaldo Carvalho de Melo } 1713b6ed988SArnaldo Carvalho de Melo 172923c42c1SMike Galbraith static void parse_source(struct sym_entry *syme) 173923c42c1SMike Galbraith { 174923c42c1SMike Galbraith struct symbol *sym; 175b269876cSArnaldo Carvalho de Melo struct sym_entry_source *source; 176439d473bSArnaldo Carvalho de Melo struct map *map; 177923c42c1SMike Galbraith FILE *file; 17883a0944fSIngo Molnar char command[PATH_MAX*2]; 179439d473bSArnaldo Carvalho de Melo const char *path; 180439d473bSArnaldo Carvalho de Melo u64 len; 181923c42c1SMike Galbraith 182923c42c1SMike Galbraith if (!syme) 183923c42c1SMike Galbraith return; 184923c42c1SMike Galbraith 185b269876cSArnaldo Carvalho de Melo if (syme->src == NULL) { 18636479484SArnaldo Carvalho de Melo syme->src = zalloc(sizeof(*source)); 187b269876cSArnaldo Carvalho de Melo if (syme->src == NULL) 188b269876cSArnaldo Carvalho de Melo return; 189b269876cSArnaldo Carvalho de Melo pthread_mutex_init(&syme->src->lock, NULL); 190b269876cSArnaldo Carvalho de Melo } 191b269876cSArnaldo Carvalho de Melo 192b269876cSArnaldo Carvalho de Melo source = syme->src; 193b269876cSArnaldo Carvalho de Melo 194b269876cSArnaldo Carvalho de Melo if (source->lines) { 195b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&source->lock); 196923c42c1SMike Galbraith goto out_assign; 197923c42c1SMike Galbraith } 198923c42c1SMike Galbraith 19951a472deSArnaldo Carvalho de Melo sym = sym_entry__symbol(syme); 200439d473bSArnaldo Carvalho de Melo map = syme->map; 201439d473bSArnaldo Carvalho de Melo path = map->dso->long_name; 202923c42c1SMike Galbraith 203923c42c1SMike Galbraith len = sym->end - sym->start; 204923c42c1SMike Galbraith 205439d473bSArnaldo Carvalho de Melo sprintf(command, 2065f485364SArnaldo Carvalho de Melo "objdump --start-address=%#0*Lx --stop-address=%#0*Lx -dS %s", 2075f485364SArnaldo Carvalho de Melo BITS_PER_LONG / 4, map__rip_2objdump(map, sym->start), 2085f485364SArnaldo Carvalho de Melo BITS_PER_LONG / 4, map__rip_2objdump(map, sym->end), path); 209923c42c1SMike Galbraith 210923c42c1SMike Galbraith file = popen(command, "r"); 211923c42c1SMike Galbraith if (!file) 212923c42c1SMike Galbraith return; 213923c42c1SMike Galbraith 214b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&source->lock); 215b269876cSArnaldo Carvalho de Melo source->lines_tail = &source->lines; 216923c42c1SMike Galbraith while (!feof(file)) { 217923c42c1SMike Galbraith struct source_line *src; 218923c42c1SMike Galbraith size_t dummy = 0; 219ee11b90bSKirill Smelkov char *c, *sep; 220923c42c1SMike Galbraith 221923c42c1SMike Galbraith src = malloc(sizeof(struct source_line)); 222923c42c1SMike Galbraith assert(src != NULL); 223923c42c1SMike Galbraith memset(src, 0, sizeof(struct source_line)); 224923c42c1SMike Galbraith 225923c42c1SMike Galbraith if (getline(&src->line, &dummy, file) < 0) 226923c42c1SMike Galbraith break; 227923c42c1SMike Galbraith if (!src->line) 228923c42c1SMike Galbraith break; 229923c42c1SMike Galbraith 230923c42c1SMike Galbraith c = strchr(src->line, '\n'); 231923c42c1SMike Galbraith if (c) 232923c42c1SMike Galbraith *c = 0; 233923c42c1SMike Galbraith 234923c42c1SMike Galbraith src->next = NULL; 235b269876cSArnaldo Carvalho de Melo *source->lines_tail = src; 236b269876cSArnaldo Carvalho de Melo source->lines_tail = &src->next; 237923c42c1SMike Galbraith 238ee11b90bSKirill Smelkov src->eip = strtoull(src->line, &sep, 16); 239ee11b90bSKirill Smelkov if (*sep == ':') 240ee11b90bSKirill Smelkov src->eip = map__objdump_2ip(map, src->eip); 241ee11b90bSKirill Smelkov else /* this line has no ip info (e.g. source line) */ 242ee11b90bSKirill Smelkov src->eip = 0; 243923c42c1SMike Galbraith } 244923c42c1SMike Galbraith pclose(file); 245923c42c1SMike Galbraith out_assign: 246923c42c1SMike Galbraith sym_filter_entry = syme; 247b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&source->lock); 248923c42c1SMike Galbraith } 249923c42c1SMike Galbraith 250923c42c1SMike Galbraith static void __zero_source_counters(struct sym_entry *syme) 251923c42c1SMike Galbraith { 252923c42c1SMike Galbraith int i; 253923c42c1SMike Galbraith struct source_line *line; 254923c42c1SMike Galbraith 255b269876cSArnaldo Carvalho de Melo line = syme->src->lines; 256923c42c1SMike Galbraith while (line) { 257923c42c1SMike Galbraith for (i = 0; i < nr_counters; i++) 258923c42c1SMike Galbraith line->count[i] = 0; 259923c42c1SMike Galbraith line = line->next; 260923c42c1SMike Galbraith } 261923c42c1SMike Galbraith } 262923c42c1SMike Galbraith 263923c42c1SMike Galbraith static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip) 264923c42c1SMike Galbraith { 265923c42c1SMike Galbraith struct source_line *line; 266923c42c1SMike Galbraith 267923c42c1SMike Galbraith if (syme != sym_filter_entry) 268923c42c1SMike Galbraith return; 269923c42c1SMike Galbraith 270b269876cSArnaldo Carvalho de Melo if (pthread_mutex_trylock(&syme->src->lock)) 271923c42c1SMike Galbraith return; 272923c42c1SMike Galbraith 273b269876cSArnaldo Carvalho de Melo if (syme->src == NULL || syme->src->source == NULL) 274923c42c1SMike Galbraith goto out_unlock; 275923c42c1SMike Galbraith 276b269876cSArnaldo Carvalho de Melo for (line = syme->src->lines; line; line = line->next) { 277ee11b90bSKirill Smelkov /* skip lines without IP info */ 278ee11b90bSKirill Smelkov if (line->eip == 0) 279ee11b90bSKirill Smelkov continue; 280923c42c1SMike Galbraith if (line->eip == ip) { 281923c42c1SMike Galbraith line->count[counter]++; 282923c42c1SMike Galbraith break; 283923c42c1SMike Galbraith } 284923c42c1SMike Galbraith if (line->eip > ip) 285923c42c1SMike Galbraith break; 286923c42c1SMike Galbraith } 287923c42c1SMike Galbraith out_unlock: 288b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 289923c42c1SMike Galbraith } 290923c42c1SMike Galbraith 291c7ad21afSArnaldo Carvalho de Melo #define PATTERN_LEN (BITS_PER_LONG / 4 + 2) 292c7ad21afSArnaldo Carvalho de Melo 293923c42c1SMike Galbraith static void lookup_sym_source(struct sym_entry *syme) 294923c42c1SMike Galbraith { 29551a472deSArnaldo Carvalho de Melo struct symbol *symbol = sym_entry__symbol(syme); 296923c42c1SMike Galbraith struct source_line *line; 297c7ad21afSArnaldo Carvalho de Melo char pattern[PATTERN_LEN + 1]; 298923c42c1SMike Galbraith 2995f485364SArnaldo Carvalho de Melo sprintf(pattern, "%0*Lx <", BITS_PER_LONG / 4, 3005f485364SArnaldo Carvalho de Melo map__rip_2objdump(syme->map, symbol->start)); 301923c42c1SMike Galbraith 302b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 303b269876cSArnaldo Carvalho de Melo for (line = syme->src->lines; line; line = line->next) { 304c7ad21afSArnaldo Carvalho de Melo if (memcmp(line->line, pattern, PATTERN_LEN) == 0) { 305b269876cSArnaldo Carvalho de Melo syme->src->source = line; 306923c42c1SMike Galbraith break; 307923c42c1SMike Galbraith } 308923c42c1SMike Galbraith } 309b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 310923c42c1SMike Galbraith } 311923c42c1SMike Galbraith 312923c42c1SMike Galbraith static void show_lines(struct source_line *queue, int count, int total) 313923c42c1SMike Galbraith { 314923c42c1SMike Galbraith int i; 315923c42c1SMike Galbraith struct source_line *line; 316923c42c1SMike Galbraith 317923c42c1SMike Galbraith line = queue; 318923c42c1SMike Galbraith for (i = 0; i < count; i++) { 319923c42c1SMike Galbraith float pcnt = 100.0*(float)line->count[sym_counter]/(float)total; 320923c42c1SMike Galbraith 321923c42c1SMike Galbraith printf("%8li %4.1f%%\t%s\n", line->count[sym_counter], pcnt, line->line); 322923c42c1SMike Galbraith line = line->next; 323923c42c1SMike Galbraith } 324923c42c1SMike Galbraith } 325923c42c1SMike Galbraith 326923c42c1SMike Galbraith #define TRACE_COUNT 3 327923c42c1SMike Galbraith 328923c42c1SMike Galbraith static void show_details(struct sym_entry *syme) 329923c42c1SMike Galbraith { 330923c42c1SMike Galbraith struct symbol *symbol; 331923c42c1SMike Galbraith struct source_line *line; 332923c42c1SMike Galbraith struct source_line *line_queue = NULL; 333923c42c1SMike Galbraith int displayed = 0; 334923c42c1SMike Galbraith int line_queue_count = 0, total = 0, more = 0; 335923c42c1SMike Galbraith 336923c42c1SMike Galbraith if (!syme) 337923c42c1SMike Galbraith return; 338923c42c1SMike Galbraith 339b269876cSArnaldo Carvalho de Melo if (!syme->src->source) 340923c42c1SMike Galbraith lookup_sym_source(syme); 341923c42c1SMike Galbraith 342b269876cSArnaldo Carvalho de Melo if (!syme->src->source) 343923c42c1SMike Galbraith return; 344923c42c1SMike Galbraith 34551a472deSArnaldo Carvalho de Melo symbol = sym_entry__symbol(syme); 346923c42c1SMike Galbraith printf("Showing %s for %s\n", event_name(sym_counter), symbol->name); 347923c42c1SMike Galbraith printf(" Events Pcnt (>=%d%%)\n", sym_pcnt_filter); 348923c42c1SMike Galbraith 349b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 350b269876cSArnaldo Carvalho de Melo line = syme->src->source; 351923c42c1SMike Galbraith while (line) { 352923c42c1SMike Galbraith total += line->count[sym_counter]; 353923c42c1SMike Galbraith line = line->next; 354923c42c1SMike Galbraith } 355923c42c1SMike Galbraith 356b269876cSArnaldo Carvalho de Melo line = syme->src->source; 357923c42c1SMike Galbraith while (line) { 358923c42c1SMike Galbraith float pcnt = 0.0; 359923c42c1SMike Galbraith 360923c42c1SMike Galbraith if (!line_queue_count) 361923c42c1SMike Galbraith line_queue = line; 362923c42c1SMike Galbraith line_queue_count++; 363923c42c1SMike Galbraith 364923c42c1SMike Galbraith if (line->count[sym_counter]) 365923c42c1SMike Galbraith pcnt = 100.0 * line->count[sym_counter] / (float)total; 366923c42c1SMike Galbraith if (pcnt >= (float)sym_pcnt_filter) { 367923c42c1SMike Galbraith if (displayed <= print_entries) 368923c42c1SMike Galbraith show_lines(line_queue, line_queue_count, total); 369923c42c1SMike Galbraith else more++; 370923c42c1SMike Galbraith displayed += line_queue_count; 371923c42c1SMike Galbraith line_queue_count = 0; 372923c42c1SMike Galbraith line_queue = NULL; 373923c42c1SMike Galbraith } else if (line_queue_count > TRACE_COUNT) { 374923c42c1SMike Galbraith line_queue = line_queue->next; 375923c42c1SMike Galbraith line_queue_count--; 376923c42c1SMike Galbraith } 377923c42c1SMike Galbraith 378923c42c1SMike Galbraith line->count[sym_counter] = zero ? 0 : line->count[sym_counter] * 7 / 8; 379923c42c1SMike Galbraith line = line->next; 380923c42c1SMike Galbraith } 381b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 382923c42c1SMike Galbraith if (more) 383923c42c1SMike Galbraith printf("%d lines not displayed, maybe increase display entries [e]\n", more); 384923c42c1SMike Galbraith } 38586470930SIngo Molnar 38686470930SIngo Molnar /* 3875b2bb75aSArnaldo Carvalho de Melo * Symbols will be added here in event__process_sample and will get out 38886470930SIngo Molnar * after decayed. 38986470930SIngo Molnar */ 39086470930SIngo Molnar static LIST_HEAD(active_symbols); 39186470930SIngo Molnar static pthread_mutex_t active_symbols_lock = PTHREAD_MUTEX_INITIALIZER; 39286470930SIngo Molnar 39386470930SIngo Molnar /* 39486470930SIngo Molnar * Ordering weight: count-1 * count-2 * ... / count-n 39586470930SIngo Molnar */ 39686470930SIngo Molnar static double sym_weight(const struct sym_entry *sym) 39786470930SIngo Molnar { 39886470930SIngo Molnar double weight = sym->snap_count; 39986470930SIngo Molnar int counter; 40086470930SIngo Molnar 40146ab9764SMike Galbraith if (!display_weighted) 40246ab9764SMike Galbraith return weight; 40346ab9764SMike Galbraith 40486470930SIngo Molnar for (counter = 1; counter < nr_counters-1; counter++) 40586470930SIngo Molnar weight *= sym->count[counter]; 40686470930SIngo Molnar 40786470930SIngo Molnar weight /= (sym->count[counter] + 1); 40886470930SIngo Molnar 40986470930SIngo Molnar return weight; 41086470930SIngo Molnar } 41186470930SIngo Molnar 41286470930SIngo Molnar static long samples; 41386470930SIngo Molnar static long userspace_samples; 41486470930SIngo Molnar static const char CONSOLE_CLEAR[] = "[H[2J"; 41586470930SIngo Molnar 41686470930SIngo Molnar static void __list_insert_active_sym(struct sym_entry *syme) 41786470930SIngo Molnar { 41886470930SIngo Molnar list_add(&syme->node, &active_symbols); 41986470930SIngo Molnar } 42086470930SIngo Molnar 42186470930SIngo Molnar static void list_remove_active_sym(struct sym_entry *syme) 42286470930SIngo Molnar { 42386470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 42486470930SIngo Molnar list_del_init(&syme->node); 42586470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 42686470930SIngo Molnar } 42786470930SIngo Molnar 42886470930SIngo Molnar static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se) 42986470930SIngo Molnar { 43086470930SIngo Molnar struct rb_node **p = &tree->rb_node; 43186470930SIngo Molnar struct rb_node *parent = NULL; 43286470930SIngo Molnar struct sym_entry *iter; 43386470930SIngo Molnar 43486470930SIngo Molnar while (*p != NULL) { 43586470930SIngo Molnar parent = *p; 43686470930SIngo Molnar iter = rb_entry(parent, struct sym_entry, rb_node); 43786470930SIngo Molnar 43886470930SIngo Molnar if (se->weight > iter->weight) 43986470930SIngo Molnar p = &(*p)->rb_left; 44086470930SIngo Molnar else 44186470930SIngo Molnar p = &(*p)->rb_right; 44286470930SIngo Molnar } 44386470930SIngo Molnar 44486470930SIngo Molnar rb_link_node(&se->rb_node, parent, p); 44586470930SIngo Molnar rb_insert_color(&se->rb_node, tree); 44686470930SIngo Molnar } 44786470930SIngo Molnar 44886470930SIngo Molnar static void print_sym_table(void) 44986470930SIngo Molnar { 45086470930SIngo Molnar int printed = 0, j; 45146ab9764SMike Galbraith int counter, snap = !display_weighted ? sym_counter : 0; 45286470930SIngo Molnar float samples_per_sec = samples/delay_secs; 45386470930SIngo Molnar float ksamples_per_sec = (samples-userspace_samples)/delay_secs; 45486470930SIngo Molnar float sum_ksamples = 0.0; 45586470930SIngo Molnar struct sym_entry *syme, *n; 45686470930SIngo Molnar struct rb_root tmp = RB_ROOT; 45786470930SIngo Molnar struct rb_node *nd; 458b63be8d7SArnaldo Carvalho de Melo int sym_width = 0, dso_width = 0, dso_short_width; 45913cc5079SArnaldo Carvalho de Melo const int win_width = winsize.ws_col - 1; 46086470930SIngo Molnar 46186470930SIngo Molnar samples = userspace_samples = 0; 46286470930SIngo Molnar 46386470930SIngo Molnar /* Sort the active symbols */ 46486470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 46586470930SIngo Molnar syme = list_entry(active_symbols.next, struct sym_entry, node); 46686470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 46786470930SIngo Molnar 46886470930SIngo Molnar list_for_each_entry_safe_from(syme, n, &active_symbols, node) { 46946ab9764SMike Galbraith syme->snap_count = syme->count[snap]; 47086470930SIngo Molnar if (syme->snap_count != 0) { 47113cc5079SArnaldo Carvalho de Melo 4728ffcda17SArnaldo Carvalho de Melo if ((hide_user_symbols && 4738ffcda17SArnaldo Carvalho de Melo syme->origin == PERF_RECORD_MISC_USER) || 4748ffcda17SArnaldo Carvalho de Melo (hide_kernel_symbols && 4758ffcda17SArnaldo Carvalho de Melo syme->origin == PERF_RECORD_MISC_KERNEL)) { 4768ffcda17SArnaldo Carvalho de Melo list_remove_active_sym(syme); 4778ffcda17SArnaldo Carvalho de Melo continue; 4788ffcda17SArnaldo Carvalho de Melo } 47986470930SIngo Molnar syme->weight = sym_weight(syme); 48086470930SIngo Molnar rb_insert_active_sym(&tmp, syme); 48186470930SIngo Molnar sum_ksamples += syme->snap_count; 48286470930SIngo Molnar 48386470930SIngo Molnar for (j = 0; j < nr_counters; j++) 48486470930SIngo Molnar syme->count[j] = zero ? 0 : syme->count[j] * 7 / 8; 48586470930SIngo Molnar } else 48686470930SIngo Molnar list_remove_active_sym(syme); 48786470930SIngo Molnar } 48886470930SIngo Molnar 48986470930SIngo Molnar puts(CONSOLE_CLEAR); 49086470930SIngo Molnar 49113cc5079SArnaldo Carvalho de Melo printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 49286470930SIngo Molnar printf( " PerfTop:%8.0f irqs/sec kernel:%4.1f%% [", 49386470930SIngo Molnar samples_per_sec, 49486470930SIngo Molnar 100.0 - (100.0*((samples_per_sec-ksamples_per_sec)/samples_per_sec))); 49586470930SIngo Molnar 49646ab9764SMike Galbraith if (nr_counters == 1 || !display_weighted) { 4979cffa8d5SPaul Mackerras printf("%Ld", (u64)attrs[0].sample_period); 49886470930SIngo Molnar if (freq) 49986470930SIngo Molnar printf("Hz "); 50086470930SIngo Molnar else 50186470930SIngo Molnar printf(" "); 50286470930SIngo Molnar } 50386470930SIngo Molnar 50446ab9764SMike Galbraith if (!display_weighted) 50546ab9764SMike Galbraith printf("%s", event_name(sym_counter)); 50646ab9764SMike Galbraith else for (counter = 0; counter < nr_counters; counter++) { 50786470930SIngo Molnar if (counter) 50886470930SIngo Molnar printf("/"); 50986470930SIngo Molnar 51086470930SIngo Molnar printf("%s", event_name(counter)); 51186470930SIngo Molnar } 51286470930SIngo Molnar 51386470930SIngo Molnar printf( "], "); 51486470930SIngo Molnar 51586470930SIngo Molnar if (target_pid != -1) 51686470930SIngo Molnar printf(" (target_pid: %d", target_pid); 51786470930SIngo Molnar else 51886470930SIngo Molnar printf(" (all"); 51986470930SIngo Molnar 52086470930SIngo Molnar if (profile_cpu != -1) 52186470930SIngo Molnar printf(", cpu: %d)\n", profile_cpu); 52286470930SIngo Molnar else { 52386470930SIngo Molnar if (target_pid != -1) 52486470930SIngo Molnar printf(")\n"); 52586470930SIngo Molnar else 52686470930SIngo Molnar printf(", %d CPUs)\n", nr_cpus); 52786470930SIngo Molnar } 52886470930SIngo Molnar 5291a105f74SArnaldo Carvalho de Melo printf("%-*.*s\n", win_width, win_width, graph_dotted_line); 53086470930SIngo Molnar 531923c42c1SMike Galbraith if (sym_filter_entry) { 532923c42c1SMike Galbraith show_details(sym_filter_entry); 533923c42c1SMike Galbraith return; 534923c42c1SMike Galbraith } 535923c42c1SMike Galbraith 53613cc5079SArnaldo Carvalho de Melo /* 53713cc5079SArnaldo Carvalho de Melo * Find the longest symbol name that will be displayed 53813cc5079SArnaldo Carvalho de Melo */ 53913cc5079SArnaldo Carvalho de Melo for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) { 54013cc5079SArnaldo Carvalho de Melo syme = rb_entry(nd, struct sym_entry, rb_node); 54113cc5079SArnaldo Carvalho de Melo if (++printed > print_entries || 54213cc5079SArnaldo Carvalho de Melo (int)syme->snap_count < count_filter) 54313cc5079SArnaldo Carvalho de Melo continue; 54413cc5079SArnaldo Carvalho de Melo 5451a105f74SArnaldo Carvalho de Melo if (syme->map->dso->long_name_len > dso_width) 5461a105f74SArnaldo Carvalho de Melo dso_width = syme->map->dso->long_name_len; 5471a105f74SArnaldo Carvalho de Melo 548b63be8d7SArnaldo Carvalho de Melo if (syme->map->dso->short_name_len > dso_short_width) 549b63be8d7SArnaldo Carvalho de Melo dso_short_width = syme->map->dso->short_name_len; 550b63be8d7SArnaldo Carvalho de Melo 55113cc5079SArnaldo Carvalho de Melo if (syme->name_len > sym_width) 55213cc5079SArnaldo Carvalho de Melo sym_width = syme->name_len; 55313cc5079SArnaldo Carvalho de Melo } 55413cc5079SArnaldo Carvalho de Melo 55513cc5079SArnaldo Carvalho de Melo printed = 0; 55613cc5079SArnaldo Carvalho de Melo 557b63be8d7SArnaldo Carvalho de Melo if (sym_width + dso_width > winsize.ws_col - 29) { 558b63be8d7SArnaldo Carvalho de Melo dso_width = dso_short_width; 559b63be8d7SArnaldo Carvalho de Melo if (sym_width + dso_width > winsize.ws_col - 29) 560b63be8d7SArnaldo Carvalho de Melo sym_width = winsize.ws_col - dso_width - 29; 561b63be8d7SArnaldo Carvalho de Melo } 5621a105f74SArnaldo Carvalho de Melo putchar('\n'); 56386470930SIngo Molnar if (nr_counters == 1) 56486470930SIngo Molnar printf(" samples pcnt"); 56586470930SIngo Molnar else 56686470930SIngo Molnar printf(" weight samples pcnt"); 56786470930SIngo Molnar 5687ced156bSArnaldo Carvalho de Melo if (verbose) 5697ced156bSArnaldo Carvalho de Melo printf(" RIP "); 5707cc017edSArnaldo Carvalho de Melo printf(" %-*.*s DSO\n", sym_width, sym_width, "function"); 5717ced156bSArnaldo Carvalho de Melo printf(" %s _______ _____", 5727ced156bSArnaldo Carvalho de Melo nr_counters == 1 ? " " : "______"); 5737ced156bSArnaldo Carvalho de Melo if (verbose) 5747ced156bSArnaldo Carvalho de Melo printf(" ________________"); 5751a105f74SArnaldo Carvalho de Melo printf(" %-*.*s", sym_width, sym_width, graph_line); 5761a105f74SArnaldo Carvalho de Melo printf(" %-*.*s", dso_width, dso_width, graph_line); 5771a105f74SArnaldo Carvalho de Melo puts("\n"); 57886470930SIngo Molnar 57986470930SIngo Molnar for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) { 58083a0944fSIngo Molnar struct symbol *sym; 58186470930SIngo Molnar double pcnt; 58286470930SIngo Molnar 58383a0944fSIngo Molnar syme = rb_entry(nd, struct sym_entry, rb_node); 58451a472deSArnaldo Carvalho de Melo sym = sym_entry__symbol(syme); 58583a0944fSIngo Molnar 586923c42c1SMike Galbraith if (++printed > print_entries || (int)syme->snap_count < count_filter) 58786470930SIngo Molnar continue; 58886470930SIngo Molnar 58986470930SIngo Molnar pcnt = 100.0 - (100.0 * ((sum_ksamples - syme->snap_count) / 59086470930SIngo Molnar sum_ksamples)); 59186470930SIngo Molnar 59246ab9764SMike Galbraith if (nr_counters == 1 || !display_weighted) 5935b2bb75aSArnaldo Carvalho de Melo printf("%20.2f ", syme->weight); 59486470930SIngo Molnar else 5955b2bb75aSArnaldo Carvalho de Melo printf("%9.1f %10ld ", syme->weight, syme->snap_count); 59686470930SIngo Molnar 5971e11fd82SFrederic Weisbecker percent_color_fprintf(stdout, "%4.1f%%", pcnt); 5987ced156bSArnaldo Carvalho de Melo if (verbose) 5995b2bb75aSArnaldo Carvalho de Melo printf(" %016llx", sym->start); 60013cc5079SArnaldo Carvalho de Melo printf(" %-*.*s", sym_width, sym_width, sym->name); 6017cc017edSArnaldo Carvalho de Melo printf(" %-*.*s\n", dso_width, dso_width, 60213cc5079SArnaldo Carvalho de Melo dso_width >= syme->map->dso->long_name_len ? 60313cc5079SArnaldo Carvalho de Melo syme->map->dso->long_name : 60413cc5079SArnaldo Carvalho de Melo syme->map->dso->short_name); 60586470930SIngo Molnar } 60686470930SIngo Molnar } 60786470930SIngo Molnar 608923c42c1SMike Galbraith static void prompt_integer(int *target, const char *msg) 609923c42c1SMike Galbraith { 610923c42c1SMike Galbraith char *buf = malloc(0), *p; 611923c42c1SMike Galbraith size_t dummy = 0; 612923c42c1SMike Galbraith int tmp; 613923c42c1SMike Galbraith 614923c42c1SMike Galbraith fprintf(stdout, "\n%s: ", msg); 615923c42c1SMike Galbraith if (getline(&buf, &dummy, stdin) < 0) 616923c42c1SMike Galbraith return; 617923c42c1SMike Galbraith 618923c42c1SMike Galbraith p = strchr(buf, '\n'); 619923c42c1SMike Galbraith if (p) 620923c42c1SMike Galbraith *p = 0; 621923c42c1SMike Galbraith 622923c42c1SMike Galbraith p = buf; 623923c42c1SMike Galbraith while(*p) { 624923c42c1SMike Galbraith if (!isdigit(*p)) 625923c42c1SMike Galbraith goto out_free; 626923c42c1SMike Galbraith p++; 627923c42c1SMike Galbraith } 628923c42c1SMike Galbraith tmp = strtoul(buf, NULL, 10); 629923c42c1SMike Galbraith *target = tmp; 630923c42c1SMike Galbraith out_free: 631923c42c1SMike Galbraith free(buf); 632923c42c1SMike Galbraith } 633923c42c1SMike Galbraith 634923c42c1SMike Galbraith static void prompt_percent(int *target, const char *msg) 635923c42c1SMike Galbraith { 636923c42c1SMike Galbraith int tmp = 0; 637923c42c1SMike Galbraith 638923c42c1SMike Galbraith prompt_integer(&tmp, msg); 639923c42c1SMike Galbraith if (tmp >= 0 && tmp <= 100) 640923c42c1SMike Galbraith *target = tmp; 641923c42c1SMike Galbraith } 642923c42c1SMike Galbraith 643923c42c1SMike Galbraith static void prompt_symbol(struct sym_entry **target, const char *msg) 644923c42c1SMike Galbraith { 645923c42c1SMike Galbraith char *buf = malloc(0), *p; 646923c42c1SMike Galbraith struct sym_entry *syme = *target, *n, *found = NULL; 647923c42c1SMike Galbraith size_t dummy = 0; 648923c42c1SMike Galbraith 649923c42c1SMike Galbraith /* zero counters of active symbol */ 650923c42c1SMike Galbraith if (syme) { 651b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 652923c42c1SMike Galbraith __zero_source_counters(syme); 653923c42c1SMike Galbraith *target = NULL; 654b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 655923c42c1SMike Galbraith } 656923c42c1SMike Galbraith 657923c42c1SMike Galbraith fprintf(stdout, "\n%s: ", msg); 658923c42c1SMike Galbraith if (getline(&buf, &dummy, stdin) < 0) 659923c42c1SMike Galbraith goto out_free; 660923c42c1SMike Galbraith 661923c42c1SMike Galbraith p = strchr(buf, '\n'); 662923c42c1SMike Galbraith if (p) 663923c42c1SMike Galbraith *p = 0; 664923c42c1SMike Galbraith 665923c42c1SMike Galbraith pthread_mutex_lock(&active_symbols_lock); 666923c42c1SMike Galbraith syme = list_entry(active_symbols.next, struct sym_entry, node); 667923c42c1SMike Galbraith pthread_mutex_unlock(&active_symbols_lock); 668923c42c1SMike Galbraith 669923c42c1SMike Galbraith list_for_each_entry_safe_from(syme, n, &active_symbols, node) { 67051a472deSArnaldo Carvalho de Melo struct symbol *sym = sym_entry__symbol(syme); 671923c42c1SMike Galbraith 672923c42c1SMike Galbraith if (!strcmp(buf, sym->name)) { 673923c42c1SMike Galbraith found = syme; 674923c42c1SMike Galbraith break; 675923c42c1SMike Galbraith } 676923c42c1SMike Galbraith } 677923c42c1SMike Galbraith 678923c42c1SMike Galbraith if (!found) { 67966aeb6d5SKirill Smelkov fprintf(stderr, "Sorry, %s is not active.\n", buf); 680923c42c1SMike Galbraith sleep(1); 681923c42c1SMike Galbraith return; 682923c42c1SMike Galbraith } else 683923c42c1SMike Galbraith parse_source(found); 684923c42c1SMike Galbraith 685923c42c1SMike Galbraith out_free: 686923c42c1SMike Galbraith free(buf); 687923c42c1SMike Galbraith } 688923c42c1SMike Galbraith 689091bd2e9SMike Galbraith static void print_mapped_keys(void) 690923c42c1SMike Galbraith { 691091bd2e9SMike Galbraith char *name = NULL; 692091bd2e9SMike Galbraith 693091bd2e9SMike Galbraith if (sym_filter_entry) { 69451a472deSArnaldo Carvalho de Melo struct symbol *sym = sym_entry__symbol(sym_filter_entry); 695091bd2e9SMike Galbraith name = sym->name; 696091bd2e9SMike Galbraith } 697091bd2e9SMike Galbraith 698091bd2e9SMike Galbraith fprintf(stdout, "\nMapped keys:\n"); 699091bd2e9SMike Galbraith fprintf(stdout, "\t[d] display refresh delay. \t(%d)\n", delay_secs); 700091bd2e9SMike Galbraith fprintf(stdout, "\t[e] display entries (lines). \t(%d)\n", print_entries); 701091bd2e9SMike Galbraith 702091bd2e9SMike Galbraith if (nr_counters > 1) 70346ab9764SMike Galbraith fprintf(stdout, "\t[E] active event counter. \t(%s)\n", event_name(sym_counter)); 704091bd2e9SMike Galbraith 705091bd2e9SMike Galbraith fprintf(stdout, "\t[f] profile display filter (count). \t(%d)\n", count_filter); 706091bd2e9SMike Galbraith 707091bd2e9SMike Galbraith fprintf(stdout, "\t[F] annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter); 708091bd2e9SMike Galbraith fprintf(stdout, "\t[s] annotate symbol. \t(%s)\n", name?: "NULL"); 709091bd2e9SMike Galbraith fprintf(stdout, "\t[S] stop annotation.\n"); 710091bd2e9SMike Galbraith 711091bd2e9SMike Galbraith if (nr_counters > 1) 71246ab9764SMike Galbraith fprintf(stdout, "\t[w] toggle display weighted/count[E]r. \t(%d)\n", display_weighted ? 1 : 0); 713091bd2e9SMike Galbraith 7148ffcda17SArnaldo Carvalho de Melo fprintf(stdout, 7158ffcda17SArnaldo Carvalho de Melo "\t[K] hide kernel_symbols symbols. \t(%s)\n", 7168ffcda17SArnaldo Carvalho de Melo hide_kernel_symbols ? "yes" : "no"); 7178ffcda17SArnaldo Carvalho de Melo fprintf(stdout, 7188ffcda17SArnaldo Carvalho de Melo "\t[U] hide user symbols. \t(%s)\n", 7198ffcda17SArnaldo Carvalho de Melo hide_user_symbols ? "yes" : "no"); 72046ab9764SMike Galbraith fprintf(stdout, "\t[z] toggle sample zeroing. \t(%d)\n", zero ? 1 : 0); 721091bd2e9SMike Galbraith fprintf(stdout, "\t[qQ] quit.\n"); 722091bd2e9SMike Galbraith } 723091bd2e9SMike Galbraith 724091bd2e9SMike Galbraith static int key_mapped(int c) 725091bd2e9SMike Galbraith { 726091bd2e9SMike Galbraith switch (c) { 727091bd2e9SMike Galbraith case 'd': 728091bd2e9SMike Galbraith case 'e': 729091bd2e9SMike Galbraith case 'f': 730091bd2e9SMike Galbraith case 'z': 731091bd2e9SMike Galbraith case 'q': 732091bd2e9SMike Galbraith case 'Q': 7338ffcda17SArnaldo Carvalho de Melo case 'K': 7348ffcda17SArnaldo Carvalho de Melo case 'U': 7356cff0e8dSKirill Smelkov case 'F': 7366cff0e8dSKirill Smelkov case 's': 7376cff0e8dSKirill Smelkov case 'S': 738091bd2e9SMike Galbraith return 1; 739091bd2e9SMike Galbraith case 'E': 740091bd2e9SMike Galbraith case 'w': 741091bd2e9SMike Galbraith return nr_counters > 1 ? 1 : 0; 74283a0944fSIngo Molnar default: 74383a0944fSIngo Molnar break; 744091bd2e9SMike Galbraith } 745091bd2e9SMike Galbraith 746091bd2e9SMike Galbraith return 0; 747923c42c1SMike Galbraith } 748923c42c1SMike Galbraith 749923c42c1SMike Galbraith static void handle_keypress(int c) 750923c42c1SMike Galbraith { 751091bd2e9SMike Galbraith if (!key_mapped(c)) { 752091bd2e9SMike Galbraith struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 753091bd2e9SMike Galbraith struct termios tc, save; 754091bd2e9SMike Galbraith 755091bd2e9SMike Galbraith print_mapped_keys(); 756091bd2e9SMike Galbraith fprintf(stdout, "\nEnter selection, or unmapped key to continue: "); 757091bd2e9SMike Galbraith fflush(stdout); 758091bd2e9SMike Galbraith 759091bd2e9SMike Galbraith tcgetattr(0, &save); 760091bd2e9SMike Galbraith tc = save; 761091bd2e9SMike Galbraith tc.c_lflag &= ~(ICANON | ECHO); 762091bd2e9SMike Galbraith tc.c_cc[VMIN] = 0; 763091bd2e9SMike Galbraith tc.c_cc[VTIME] = 0; 764091bd2e9SMike Galbraith tcsetattr(0, TCSANOW, &tc); 765091bd2e9SMike Galbraith 766091bd2e9SMike Galbraith poll(&stdin_poll, 1, -1); 767091bd2e9SMike Galbraith c = getc(stdin); 768091bd2e9SMike Galbraith 769091bd2e9SMike Galbraith tcsetattr(0, TCSAFLUSH, &save); 770091bd2e9SMike Galbraith if (!key_mapped(c)) 771091bd2e9SMike Galbraith return; 772091bd2e9SMike Galbraith } 773091bd2e9SMike Galbraith 774923c42c1SMike Galbraith switch (c) { 775923c42c1SMike Galbraith case 'd': 776923c42c1SMike Galbraith prompt_integer(&delay_secs, "Enter display delay"); 777dc79959aSTim Blechmann if (delay_secs < 1) 778dc79959aSTim Blechmann delay_secs = 1; 779923c42c1SMike Galbraith break; 780923c42c1SMike Galbraith case 'e': 781923c42c1SMike Galbraith prompt_integer(&print_entries, "Enter display entries (lines)"); 7823b6ed988SArnaldo Carvalho de Melo if (print_entries == 0) { 78313cc5079SArnaldo Carvalho de Melo sig_winch_handler(SIGWINCH); 7843b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, sig_winch_handler); 7853b6ed988SArnaldo Carvalho de Melo } else 7863b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, SIG_DFL); 787923c42c1SMike Galbraith break; 788923c42c1SMike Galbraith case 'E': 789923c42c1SMike Galbraith if (nr_counters > 1) { 790923c42c1SMike Galbraith int i; 791923c42c1SMike Galbraith 792923c42c1SMike Galbraith fprintf(stderr, "\nAvailable events:"); 793923c42c1SMike Galbraith for (i = 0; i < nr_counters; i++) 794923c42c1SMike Galbraith fprintf(stderr, "\n\t%d %s", i, event_name(i)); 795923c42c1SMike Galbraith 796923c42c1SMike Galbraith prompt_integer(&sym_counter, "Enter details event counter"); 797923c42c1SMike Galbraith 798923c42c1SMike Galbraith if (sym_counter >= nr_counters) { 799923c42c1SMike Galbraith fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(0)); 800923c42c1SMike Galbraith sym_counter = 0; 801923c42c1SMike Galbraith sleep(1); 802923c42c1SMike Galbraith } 803923c42c1SMike Galbraith } else sym_counter = 0; 804923c42c1SMike Galbraith break; 805923c42c1SMike Galbraith case 'f': 806923c42c1SMike Galbraith prompt_integer(&count_filter, "Enter display event count filter"); 807923c42c1SMike Galbraith break; 808923c42c1SMike Galbraith case 'F': 809923c42c1SMike Galbraith prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)"); 810923c42c1SMike Galbraith break; 8118ffcda17SArnaldo Carvalho de Melo case 'K': 8128ffcda17SArnaldo Carvalho de Melo hide_kernel_symbols = !hide_kernel_symbols; 8138ffcda17SArnaldo Carvalho de Melo break; 814923c42c1SMike Galbraith case 'q': 815923c42c1SMike Galbraith case 'Q': 816923c42c1SMike Galbraith printf("exiting.\n"); 817c338aee8SArnaldo Carvalho de Melo if (dump_symtab) 818c338aee8SArnaldo Carvalho de Melo dsos__fprintf(stderr); 819923c42c1SMike Galbraith exit(0); 820923c42c1SMike Galbraith case 's': 821923c42c1SMike Galbraith prompt_symbol(&sym_filter_entry, "Enter details symbol"); 822923c42c1SMike Galbraith break; 823923c42c1SMike Galbraith case 'S': 824923c42c1SMike Galbraith if (!sym_filter_entry) 825923c42c1SMike Galbraith break; 826923c42c1SMike Galbraith else { 827923c42c1SMike Galbraith struct sym_entry *syme = sym_filter_entry; 828923c42c1SMike Galbraith 829b269876cSArnaldo Carvalho de Melo pthread_mutex_lock(&syme->src->lock); 830923c42c1SMike Galbraith sym_filter_entry = NULL; 831923c42c1SMike Galbraith __zero_source_counters(syme); 832b269876cSArnaldo Carvalho de Melo pthread_mutex_unlock(&syme->src->lock); 833923c42c1SMike Galbraith } 834923c42c1SMike Galbraith break; 8358ffcda17SArnaldo Carvalho de Melo case 'U': 8368ffcda17SArnaldo Carvalho de Melo hide_user_symbols = !hide_user_symbols; 8378ffcda17SArnaldo Carvalho de Melo break; 83846ab9764SMike Galbraith case 'w': 83946ab9764SMike Galbraith display_weighted = ~display_weighted; 84046ab9764SMike Galbraith break; 841923c42c1SMike Galbraith case 'z': 842923c42c1SMike Galbraith zero = ~zero; 843923c42c1SMike Galbraith break; 84483a0944fSIngo Molnar default: 84583a0944fSIngo Molnar break; 846923c42c1SMike Galbraith } 847923c42c1SMike Galbraith } 848923c42c1SMike Galbraith 849f37a291cSIngo Molnar static void *display_thread(void *arg __used) 85086470930SIngo Molnar { 85186470930SIngo Molnar struct pollfd stdin_poll = { .fd = 0, .events = POLLIN }; 852923c42c1SMike Galbraith struct termios tc, save; 853923c42c1SMike Galbraith int delay_msecs, c; 85486470930SIngo Molnar 855923c42c1SMike Galbraith tcgetattr(0, &save); 856923c42c1SMike Galbraith tc = save; 857923c42c1SMike Galbraith tc.c_lflag &= ~(ICANON | ECHO); 858923c42c1SMike Galbraith tc.c_cc[VMIN] = 0; 859923c42c1SMike Galbraith tc.c_cc[VTIME] = 0; 860091bd2e9SMike Galbraith 861923c42c1SMike Galbraith repeat: 862923c42c1SMike Galbraith delay_msecs = delay_secs * 1000; 863923c42c1SMike Galbraith tcsetattr(0, TCSANOW, &tc); 864923c42c1SMike Galbraith /* trash return*/ 865923c42c1SMike Galbraith getc(stdin); 86686470930SIngo Molnar 86786470930SIngo Molnar do { 86886470930SIngo Molnar print_sym_table(); 86986470930SIngo Molnar } while (!poll(&stdin_poll, 1, delay_msecs) == 1); 87086470930SIngo Molnar 871923c42c1SMike Galbraith c = getc(stdin); 872923c42c1SMike Galbraith tcsetattr(0, TCSAFLUSH, &save); 873923c42c1SMike Galbraith 874923c42c1SMike Galbraith handle_keypress(c); 875923c42c1SMike Galbraith goto repeat; 87686470930SIngo Molnar 87786470930SIngo Molnar return NULL; 87886470930SIngo Molnar } 87986470930SIngo Molnar 8802ab52083SAnton Blanchard /* Tag samples to be skipped. */ 881f37a291cSIngo Molnar static const char *skip_symbols[] = { 8822ab52083SAnton Blanchard "default_idle", 8832ab52083SAnton Blanchard "cpu_idle", 8842ab52083SAnton Blanchard "enter_idle", 8852ab52083SAnton Blanchard "exit_idle", 8862ab52083SAnton Blanchard "mwait_idle", 88759b90056SArnaldo Carvalho de Melo "mwait_idle_with_hints", 8888357275bSArnaldo Carvalho de Melo "poll_idle", 8893a3393efSAnton Blanchard "ppc64_runlatch_off", 8903a3393efSAnton Blanchard "pseries_dedicated_idle_sleep", 8912ab52083SAnton Blanchard NULL 8922ab52083SAnton Blanchard }; 8932ab52083SAnton Blanchard 894439d473bSArnaldo Carvalho de Melo static int symbol_filter(struct map *map, struct symbol *sym) 89586470930SIngo Molnar { 89686470930SIngo Molnar struct sym_entry *syme; 89786470930SIngo Molnar const char *name = sym->name; 8982ab52083SAnton Blanchard int i; 89986470930SIngo Molnar 9003a3393efSAnton Blanchard /* 9013a3393efSAnton Blanchard * ppc64 uses function descriptors and appends a '.' to the 9023a3393efSAnton Blanchard * start of every instruction address. Remove it. 9033a3393efSAnton Blanchard */ 9043a3393efSAnton Blanchard if (name[0] == '.') 9053a3393efSAnton Blanchard name++; 9063a3393efSAnton Blanchard 90786470930SIngo Molnar if (!strcmp(name, "_text") || 90886470930SIngo Molnar !strcmp(name, "_etext") || 90986470930SIngo Molnar !strcmp(name, "_sinittext") || 91086470930SIngo Molnar !strncmp("init_module", name, 11) || 91186470930SIngo Molnar !strncmp("cleanup_module", name, 14) || 91286470930SIngo Molnar strstr(name, "_text_start") || 91386470930SIngo Molnar strstr(name, "_text_end")) 91486470930SIngo Molnar return 1; 91586470930SIngo Molnar 91600a192b3SArnaldo Carvalho de Melo syme = symbol__priv(sym); 917439d473bSArnaldo Carvalho de Melo syme->map = map; 918b269876cSArnaldo Carvalho de Melo syme->src = NULL; 9196cff0e8dSKirill Smelkov 9206cff0e8dSKirill Smelkov if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) { 9216cff0e8dSKirill Smelkov /* schedule initial sym_filter_entry setup */ 9226cff0e8dSKirill Smelkov sym_filter_entry_sched = syme; 9236cff0e8dSKirill Smelkov sym_filter = NULL; 9246cff0e8dSKirill Smelkov } 925923c42c1SMike Galbraith 9262ab52083SAnton Blanchard for (i = 0; skip_symbols[i]; i++) { 9272ab52083SAnton Blanchard if (!strcmp(skip_symbols[i], name)) { 92886470930SIngo Molnar syme->skip = 1; 9292ab52083SAnton Blanchard break; 9302ab52083SAnton Blanchard } 9312ab52083SAnton Blanchard } 93286470930SIngo Molnar 93313cc5079SArnaldo Carvalho de Melo if (!syme->skip) 93413cc5079SArnaldo Carvalho de Melo syme->name_len = strlen(sym->name); 93513cc5079SArnaldo Carvalho de Melo 93686470930SIngo Molnar return 0; 93786470930SIngo Molnar } 93886470930SIngo Molnar 939b3165f41SArnaldo Carvalho de Melo static void event__process_sample(const event_t *self, 940b3165f41SArnaldo Carvalho de Melo struct perf_session *session, int counter) 94186470930SIngo Molnar { 9425b2bb75aSArnaldo Carvalho de Melo u64 ip = self->ip.ip; 9435b2bb75aSArnaldo Carvalho de Melo struct sym_entry *syme; 9441ed091c4SArnaldo Carvalho de Melo struct addr_location al; 9458ffcda17SArnaldo Carvalho de Melo u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 94686470930SIngo Molnar 94724bfef0fSArnaldo Carvalho de Melo ++samples; 94824bfef0fSArnaldo Carvalho de Melo 9498ffcda17SArnaldo Carvalho de Melo switch (origin) { 9501ed091c4SArnaldo Carvalho de Melo case PERF_RECORD_MISC_USER: 95124bfef0fSArnaldo Carvalho de Melo ++userspace_samples; 9528ffcda17SArnaldo Carvalho de Melo if (hide_user_symbols) 9538ffcda17SArnaldo Carvalho de Melo return; 9545b2bb75aSArnaldo Carvalho de Melo break; 9555b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_MISC_KERNEL: 9568ffcda17SArnaldo Carvalho de Melo if (hide_kernel_symbols) 9578ffcda17SArnaldo Carvalho de Melo return; 9585b2bb75aSArnaldo Carvalho de Melo break; 9595b2bb75aSArnaldo Carvalho de Melo default: 9605b2bb75aSArnaldo Carvalho de Melo return; 9615b2bb75aSArnaldo Carvalho de Melo } 9625b2bb75aSArnaldo Carvalho de Melo 963b3165f41SArnaldo Carvalho de Melo if (event__preprocess_sample(self, session, &al, symbol_filter) < 0 || 96472b8fa17SArnaldo Carvalho de Melo al.filtered) 9651ed091c4SArnaldo Carvalho de Melo return; 96686470930SIngo Molnar 96772b8fa17SArnaldo Carvalho de Melo if (al.sym == NULL) { 96872b8fa17SArnaldo Carvalho de Melo /* 96972b8fa17SArnaldo Carvalho de Melo * As we do lazy loading of symtabs we only will know if the 97072b8fa17SArnaldo Carvalho de Melo * specified vmlinux file is invalid when we actually have a 97172b8fa17SArnaldo Carvalho de Melo * hit in kernel space and then try to load it. So if we get 97272b8fa17SArnaldo Carvalho de Melo * here and there are _no_ symbols in the DSO backing the 97372b8fa17SArnaldo Carvalho de Melo * kernel map, bail out. 97472b8fa17SArnaldo Carvalho de Melo * 97572b8fa17SArnaldo Carvalho de Melo * We may never get here, for instance, if we use -K/ 97672b8fa17SArnaldo Carvalho de Melo * --hide-kernel-symbols, even if the user specifies an 97772b8fa17SArnaldo Carvalho de Melo * invalid --vmlinux ;-) 97872b8fa17SArnaldo Carvalho de Melo */ 97972b8fa17SArnaldo Carvalho de Melo if (al.map == session->vmlinux_maps[MAP__FUNCTION] && 98072b8fa17SArnaldo Carvalho de Melo RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 98172b8fa17SArnaldo Carvalho de Melo pr_err("The %s file can't be used\n", 98272b8fa17SArnaldo Carvalho de Melo symbol_conf.vmlinux_name); 98372b8fa17SArnaldo Carvalho de Melo exit(1); 98472b8fa17SArnaldo Carvalho de Melo } 98572b8fa17SArnaldo Carvalho de Melo 98672b8fa17SArnaldo Carvalho de Melo return; 98772b8fa17SArnaldo Carvalho de Melo } 98872b8fa17SArnaldo Carvalho de Melo 9896cff0e8dSKirill Smelkov /* let's see, whether we need to install initial sym_filter_entry */ 9906cff0e8dSKirill Smelkov if (sym_filter_entry_sched) { 9916cff0e8dSKirill Smelkov sym_filter_entry = sym_filter_entry_sched; 9926cff0e8dSKirill Smelkov sym_filter_entry_sched = NULL; 9936cff0e8dSKirill Smelkov parse_source(sym_filter_entry); 9946cff0e8dSKirill Smelkov } 9956cff0e8dSKirill Smelkov 9961ed091c4SArnaldo Carvalho de Melo syme = symbol__priv(al.sym); 99786470930SIngo Molnar if (!syme->skip) { 99886470930SIngo Molnar syme->count[counter]++; 9998ffcda17SArnaldo Carvalho de Melo syme->origin = origin; 1000923c42c1SMike Galbraith record_precise_ip(syme, counter, ip); 100186470930SIngo Molnar pthread_mutex_lock(&active_symbols_lock); 100286470930SIngo Molnar if (list_empty(&syme->node) || !syme->node.next) 100386470930SIngo Molnar __list_insert_active_sym(syme); 100486470930SIngo Molnar pthread_mutex_unlock(&active_symbols_lock); 100586470930SIngo Molnar } 100686470930SIngo Molnar } 100786470930SIngo Molnar 1008d8f66248SArnaldo Carvalho de Melo static int event__process(event_t *event, struct perf_session *session) 10095b2bb75aSArnaldo Carvalho de Melo { 10105b2bb75aSArnaldo Carvalho de Melo switch (event->header.type) { 10115b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_COMM: 1012d8f66248SArnaldo Carvalho de Melo event__process_comm(event, session); 10135b2bb75aSArnaldo Carvalho de Melo break; 10145b2bb75aSArnaldo Carvalho de Melo case PERF_RECORD_MMAP: 1015d8f66248SArnaldo Carvalho de Melo event__process_mmap(event, session); 10165b2bb75aSArnaldo Carvalho de Melo break; 10170f35cd4cSArnaldo Carvalho de Melo case PERF_RECORD_FORK: 10180f35cd4cSArnaldo Carvalho de Melo case PERF_RECORD_EXIT: 10190f35cd4cSArnaldo Carvalho de Melo event__process_task(event, session); 10200f35cd4cSArnaldo Carvalho de Melo break; 10215b2bb75aSArnaldo Carvalho de Melo default: 10225b2bb75aSArnaldo Carvalho de Melo break; 10235b2bb75aSArnaldo Carvalho de Melo } 10245b2bb75aSArnaldo Carvalho de Melo 10255b2bb75aSArnaldo Carvalho de Melo return 0; 102686470930SIngo Molnar } 102786470930SIngo Molnar 102886470930SIngo Molnar struct mmap_data { 102986470930SIngo Molnar int counter; 103086470930SIngo Molnar void *base; 1031f37a291cSIngo Molnar int mask; 103286470930SIngo Molnar unsigned int prev; 103386470930SIngo Molnar }; 103486470930SIngo Molnar 103586470930SIngo Molnar static unsigned int mmap_read_head(struct mmap_data *md) 103686470930SIngo Molnar { 1037cdd6c482SIngo Molnar struct perf_event_mmap_page *pc = md->base; 103886470930SIngo Molnar int head; 103986470930SIngo Molnar 104086470930SIngo Molnar head = pc->data_head; 104186470930SIngo Molnar rmb(); 104286470930SIngo Molnar 104386470930SIngo Molnar return head; 104486470930SIngo Molnar } 104586470930SIngo Molnar 1046d8f66248SArnaldo Carvalho de Melo static void perf_session__mmap_read_counter(struct perf_session *self, 1047d8f66248SArnaldo Carvalho de Melo struct mmap_data *md) 104886470930SIngo Molnar { 104986470930SIngo Molnar unsigned int head = mmap_read_head(md); 105086470930SIngo Molnar unsigned int old = md->prev; 105186470930SIngo Molnar unsigned char *data = md->base + page_size; 105286470930SIngo Molnar int diff; 105386470930SIngo Molnar 105486470930SIngo Molnar /* 105586470930SIngo Molnar * If we're further behind than half the buffer, there's a chance 105686470930SIngo Molnar * the writer will bite our tail and mess up the samples under us. 105786470930SIngo Molnar * 105886470930SIngo Molnar * If we somehow ended up ahead of the head, we got messed up. 105986470930SIngo Molnar * 106086470930SIngo Molnar * In either case, truncate and restart at head. 106186470930SIngo Molnar */ 106286470930SIngo Molnar diff = head - old; 106386470930SIngo Molnar if (diff > md->mask / 2 || diff < 0) { 1064f4f0b418SMike Galbraith fprintf(stderr, "WARNING: failed to keep up with mmap data.\n"); 106586470930SIngo Molnar 106686470930SIngo Molnar /* 106786470930SIngo Molnar * head points to a known good entry, start there. 106886470930SIngo Molnar */ 106986470930SIngo Molnar old = head; 107086470930SIngo Molnar } 107186470930SIngo Molnar 107286470930SIngo Molnar for (; old != head;) { 107386470930SIngo Molnar event_t *event = (event_t *)&data[old & md->mask]; 107486470930SIngo Molnar 107586470930SIngo Molnar event_t event_copy; 107686470930SIngo Molnar 107786470930SIngo Molnar size_t size = event->header.size; 107886470930SIngo Molnar 107986470930SIngo Molnar /* 108086470930SIngo Molnar * Event straddles the mmap boundary -- header should always 108186470930SIngo Molnar * be inside due to u64 alignment of output. 108286470930SIngo Molnar */ 108386470930SIngo Molnar if ((old & md->mask) + size != ((old + size) & md->mask)) { 108486470930SIngo Molnar unsigned int offset = old; 108586470930SIngo Molnar unsigned int len = min(sizeof(*event), size), cpy; 108686470930SIngo Molnar void *dst = &event_copy; 108786470930SIngo Molnar 108886470930SIngo Molnar do { 108986470930SIngo Molnar cpy = min(md->mask + 1 - (offset & md->mask), len); 109086470930SIngo Molnar memcpy(dst, &data[offset & md->mask], cpy); 109186470930SIngo Molnar offset += cpy; 109286470930SIngo Molnar dst += cpy; 109386470930SIngo Molnar len -= cpy; 109486470930SIngo Molnar } while (len); 109586470930SIngo Molnar 109686470930SIngo Molnar event = &event_copy; 109786470930SIngo Molnar } 109886470930SIngo Molnar 10995b2bb75aSArnaldo Carvalho de Melo if (event->header.type == PERF_RECORD_SAMPLE) 1100b3165f41SArnaldo Carvalho de Melo event__process_sample(event, self, md->counter); 11015b2bb75aSArnaldo Carvalho de Melo else 1102d8f66248SArnaldo Carvalho de Melo event__process(event, self); 110386470930SIngo Molnar old += size; 110486470930SIngo Molnar } 110586470930SIngo Molnar 110686470930SIngo Molnar md->prev = old; 110786470930SIngo Molnar } 110886470930SIngo Molnar 110986470930SIngo Molnar static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS]; 111086470930SIngo Molnar static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS]; 111186470930SIngo Molnar 1112d8f66248SArnaldo Carvalho de Melo static void perf_session__mmap_read(struct perf_session *self) 11132f01190aSFrederic Weisbecker { 11142f01190aSFrederic Weisbecker int i, counter; 11152f01190aSFrederic Weisbecker 11162f01190aSFrederic Weisbecker for (i = 0; i < nr_cpus; i++) { 11172f01190aSFrederic Weisbecker for (counter = 0; counter < nr_counters; counter++) 1118d8f66248SArnaldo Carvalho de Melo perf_session__mmap_read_counter(self, &mmap_array[i][counter]); 11192f01190aSFrederic Weisbecker } 11202f01190aSFrederic Weisbecker } 11212f01190aSFrederic Weisbecker 1122716c69feSIngo Molnar int nr_poll; 1123716c69feSIngo Molnar int group_fd; 1124716c69feSIngo Molnar 1125716c69feSIngo Molnar static void start_counter(int i, int counter) 112686470930SIngo Molnar { 1127cdd6c482SIngo Molnar struct perf_event_attr *attr; 11280fdc7e67SMike Galbraith int cpu; 112986470930SIngo Molnar 113086470930SIngo Molnar cpu = profile_cpu; 113186470930SIngo Molnar if (target_pid == -1 && profile_cpu == -1) 1132a12b51c4SPaul Mackerras cpu = cpumap[i]; 113386470930SIngo Molnar 113486470930SIngo Molnar attr = attrs + counter; 113586470930SIngo Molnar 113686470930SIngo Molnar attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID; 11377e4ff9e3SMike Galbraith 11387e4ff9e3SMike Galbraith if (freq) { 11397e4ff9e3SMike Galbraith attr->sample_type |= PERF_SAMPLE_PERIOD; 11407e4ff9e3SMike Galbraith attr->freq = 1; 11417e4ff9e3SMike Galbraith attr->sample_freq = freq; 11427e4ff9e3SMike Galbraith } 11437e4ff9e3SMike Galbraith 11440fdc7e67SMike Galbraith attr->inherit = (cpu < 0) && inherit; 11455b2bb75aSArnaldo Carvalho de Melo attr->mmap = 1; 114686470930SIngo Molnar 1147716c69feSIngo Molnar try_again: 1148cdd6c482SIngo Molnar fd[i][counter] = sys_perf_event_open(attr, target_pid, cpu, group_fd, 0); 1149716c69feSIngo Molnar 115086470930SIngo Molnar if (fd[i][counter] < 0) { 115186470930SIngo Molnar int err = errno; 115286470930SIngo Molnar 1153c10edee2SPekka Enberg if (err == EPERM || err == EACCES) 1154716c69feSIngo Molnar die("No permission - are you root?\n"); 1155716c69feSIngo Molnar /* 1156716c69feSIngo Molnar * If it's cycles then fall back to hrtimer 1157716c69feSIngo Molnar * based cpu-clock-tick sw counter, which 1158716c69feSIngo Molnar * is always available even if no PMU support: 1159716c69feSIngo Molnar */ 1160716c69feSIngo Molnar if (attr->type == PERF_TYPE_HARDWARE 1161f4dbfa8fSPeter Zijlstra && attr->config == PERF_COUNT_HW_CPU_CYCLES) { 1162716c69feSIngo Molnar 11633da297a6SIngo Molnar if (verbose) 1164716c69feSIngo Molnar warning(" ... trying to fall back to cpu-clock-ticks\n"); 11653da297a6SIngo Molnar 1166716c69feSIngo Molnar attr->type = PERF_TYPE_SOFTWARE; 1167f4dbfa8fSPeter Zijlstra attr->config = PERF_COUNT_SW_CPU_CLOCK; 1168716c69feSIngo Molnar goto try_again; 1169716c69feSIngo Molnar } 117030c806a0SIngo Molnar printf("\n"); 117130c806a0SIngo Molnar error("perfcounter syscall returned with %d (%s)\n", 117230c806a0SIngo Molnar fd[i][counter], strerror(err)); 1173cdd6c482SIngo Molnar die("No CONFIG_PERF_EVENTS=y kernel support configured?\n"); 117486470930SIngo Molnar exit(-1); 117586470930SIngo Molnar } 117686470930SIngo Molnar assert(fd[i][counter] >= 0); 117786470930SIngo Molnar fcntl(fd[i][counter], F_SETFL, O_NONBLOCK); 117886470930SIngo Molnar 117986470930SIngo Molnar /* 118086470930SIngo Molnar * First counter acts as the group leader: 118186470930SIngo Molnar */ 118286470930SIngo Molnar if (group && group_fd == -1) 118386470930SIngo Molnar group_fd = fd[i][counter]; 118486470930SIngo Molnar 118586470930SIngo Molnar event_array[nr_poll].fd = fd[i][counter]; 118686470930SIngo Molnar event_array[nr_poll].events = POLLIN; 118786470930SIngo Molnar nr_poll++; 118886470930SIngo Molnar 118986470930SIngo Molnar mmap_array[i][counter].counter = counter; 119086470930SIngo Molnar mmap_array[i][counter].prev = 0; 119186470930SIngo Molnar mmap_array[i][counter].mask = mmap_pages*page_size - 1; 119286470930SIngo Molnar mmap_array[i][counter].base = mmap(NULL, (mmap_pages+1)*page_size, 119386470930SIngo Molnar PROT_READ, MAP_SHARED, fd[i][counter], 0); 119486470930SIngo Molnar if (mmap_array[i][counter].base == MAP_FAILED) 119586470930SIngo Molnar die("failed to mmap with %d (%s)\n", errno, strerror(errno)); 119686470930SIngo Molnar } 1197716c69feSIngo Molnar 1198716c69feSIngo Molnar static int __cmd_top(void) 1199716c69feSIngo Molnar { 1200716c69feSIngo Molnar pthread_t thread; 1201716c69feSIngo Molnar int i, counter; 1202716c69feSIngo Molnar int ret; 1203d8f66248SArnaldo Carvalho de Melo /* 1204b3165f41SArnaldo Carvalho de Melo * FIXME: perf_session__new should allow passing a O_MMAP, so that all this 1205b3165f41SArnaldo Carvalho de Melo * mmap reading, etc is encapsulated in it. Use O_WRONLY for now. 1206d8f66248SArnaldo Carvalho de Melo */ 120775be6cf4SArnaldo Carvalho de Melo struct perf_session *session = perf_session__new(NULL, O_WRONLY, false); 1208b3165f41SArnaldo Carvalho de Melo if (session == NULL) 1209b3165f41SArnaldo Carvalho de Melo return -ENOMEM; 1210716c69feSIngo Molnar 12115b2bb75aSArnaldo Carvalho de Melo if (target_pid != -1) 1212d8f66248SArnaldo Carvalho de Melo event__synthesize_thread(target_pid, event__process, session); 12135b2bb75aSArnaldo Carvalho de Melo else 1214d8f66248SArnaldo Carvalho de Melo event__synthesize_threads(event__process, session); 12155b2bb75aSArnaldo Carvalho de Melo 1216716c69feSIngo Molnar for (i = 0; i < nr_cpus; i++) { 1217716c69feSIngo Molnar group_fd = -1; 1218716c69feSIngo Molnar for (counter = 0; counter < nr_counters; counter++) 1219716c69feSIngo Molnar start_counter(i, counter); 122086470930SIngo Molnar } 122186470930SIngo Molnar 12222f01190aSFrederic Weisbecker /* Wait for a minimal set of events before starting the snapshot */ 12232f01190aSFrederic Weisbecker poll(event_array, nr_poll, 100); 12242f01190aSFrederic Weisbecker 1225d8f66248SArnaldo Carvalho de Melo perf_session__mmap_read(session); 12262f01190aSFrederic Weisbecker 122786470930SIngo Molnar if (pthread_create(&thread, NULL, display_thread, NULL)) { 122886470930SIngo Molnar printf("Could not create display thread.\n"); 122986470930SIngo Molnar exit(-1); 123086470930SIngo Molnar } 123186470930SIngo Molnar 123286470930SIngo Molnar if (realtime_prio) { 123386470930SIngo Molnar struct sched_param param; 123486470930SIngo Molnar 123586470930SIngo Molnar param.sched_priority = realtime_prio; 123686470930SIngo Molnar if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 123786470930SIngo Molnar printf("Could not set realtime priority.\n"); 123886470930SIngo Molnar exit(-1); 123986470930SIngo Molnar } 124086470930SIngo Molnar } 124186470930SIngo Molnar 124286470930SIngo Molnar while (1) { 124386470930SIngo Molnar int hits = samples; 124486470930SIngo Molnar 1245d8f66248SArnaldo Carvalho de Melo perf_session__mmap_read(session); 124686470930SIngo Molnar 124786470930SIngo Molnar if (hits == samples) 124886470930SIngo Molnar ret = poll(event_array, nr_poll, 100); 124986470930SIngo Molnar } 125086470930SIngo Molnar 125186470930SIngo Molnar return 0; 125286470930SIngo Molnar } 125386470930SIngo Molnar 125486470930SIngo Molnar static const char * const top_usage[] = { 125586470930SIngo Molnar "perf top [<options>]", 125686470930SIngo Molnar NULL 125786470930SIngo Molnar }; 125886470930SIngo Molnar 125986470930SIngo Molnar static const struct option options[] = { 126086470930SIngo Molnar OPT_CALLBACK('e', "event", NULL, "event", 126186470930SIngo Molnar "event selector. use 'perf list' to list available events", 126286470930SIngo Molnar parse_events), 126386470930SIngo Molnar OPT_INTEGER('c', "count", &default_interval, 126486470930SIngo Molnar "event period to sample"), 126586470930SIngo Molnar OPT_INTEGER('p', "pid", &target_pid, 126686470930SIngo Molnar "profile events on existing pid"), 126786470930SIngo Molnar OPT_BOOLEAN('a', "all-cpus", &system_wide, 126886470930SIngo Molnar "system-wide collection from all CPUs"), 126986470930SIngo Molnar OPT_INTEGER('C', "CPU", &profile_cpu, 127086470930SIngo Molnar "CPU to profile on"), 1271b32d133aSArnaldo Carvalho de Melo OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 1272b32d133aSArnaldo Carvalho de Melo "file", "vmlinux pathname"), 12738ffcda17SArnaldo Carvalho de Melo OPT_BOOLEAN('K', "hide_kernel_symbols", &hide_kernel_symbols, 12748ffcda17SArnaldo Carvalho de Melo "hide kernel symbols"), 127586470930SIngo Molnar OPT_INTEGER('m', "mmap-pages", &mmap_pages, 127686470930SIngo Molnar "number of mmap data pages"), 127786470930SIngo Molnar OPT_INTEGER('r', "realtime", &realtime_prio, 127886470930SIngo Molnar "collect data with this RT SCHED_FIFO priority"), 127986470930SIngo Molnar OPT_INTEGER('d', "delay", &delay_secs, 128086470930SIngo Molnar "number of seconds to delay between refreshes"), 128186470930SIngo Molnar OPT_BOOLEAN('D', "dump-symtab", &dump_symtab, 128286470930SIngo Molnar "dump the symbol table used for profiling"), 128386470930SIngo Molnar OPT_INTEGER('f', "count-filter", &count_filter, 128486470930SIngo Molnar "only display functions with more events than this"), 128586470930SIngo Molnar OPT_BOOLEAN('g', "group", &group, 128686470930SIngo Molnar "put the counters into a counter group"), 12870fdc7e67SMike Galbraith OPT_BOOLEAN('i', "inherit", &inherit, 12880fdc7e67SMike Galbraith "child tasks inherit counters"), 1289923c42c1SMike Galbraith OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name", 12906cff0e8dSKirill Smelkov "symbol to annotate"), 12911f208ea6SAnton Blanchard OPT_BOOLEAN('z', "zero", &zero, 129286470930SIngo Molnar "zero history across updates"), 129386470930SIngo Molnar OPT_INTEGER('F', "freq", &freq, 129486470930SIngo Molnar "profile at this frequency"), 129586470930SIngo Molnar OPT_INTEGER('E', "entries", &print_entries, 129686470930SIngo Molnar "display this many functions"), 12978ffcda17SArnaldo Carvalho de Melo OPT_BOOLEAN('U', "hide_user_symbols", &hide_user_symbols, 12988ffcda17SArnaldo Carvalho de Melo "hide user symbols"), 12993da297a6SIngo Molnar OPT_BOOLEAN('v', "verbose", &verbose, 13003da297a6SIngo Molnar "be more verbose (show counter open errors, etc)"), 130186470930SIngo Molnar OPT_END() 130286470930SIngo Molnar }; 130386470930SIngo Molnar 1304f37a291cSIngo Molnar int cmd_top(int argc, const char **argv, const char *prefix __used) 130586470930SIngo Molnar { 1306b32d133aSArnaldo Carvalho de Melo int counter; 130786470930SIngo Molnar 130886470930SIngo Molnar page_size = sysconf(_SC_PAGE_SIZE); 130986470930SIngo Molnar 131086470930SIngo Molnar argc = parse_options(argc, argv, options, top_usage, 0); 131186470930SIngo Molnar if (argc) 131286470930SIngo Molnar usage_with_options(top_usage, options); 131386470930SIngo Molnar 131486470930SIngo Molnar /* CPU and PID are mutually exclusive */ 131586470930SIngo Molnar if (target_pid != -1 && profile_cpu != -1) { 131686470930SIngo Molnar printf("WARNING: PID switch overriding CPU\n"); 131786470930SIngo Molnar sleep(1); 131886470930SIngo Molnar profile_cpu = -1; 131986470930SIngo Molnar } 132086470930SIngo Molnar 132186470930SIngo Molnar if (!nr_counters) 132286470930SIngo Molnar nr_counters = 1; 132386470930SIngo Molnar 1324b32d133aSArnaldo Carvalho de Melo symbol_conf.priv_size = (sizeof(struct sym_entry) + 13255a8e5a30SArnaldo Carvalho de Melo (nr_counters + 1) * sizeof(unsigned long)); 13266cff0e8dSKirill Smelkov 13276cff0e8dSKirill Smelkov symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 132875be6cf4SArnaldo Carvalho de Melo if (symbol__init() < 0) 1329b32d133aSArnaldo Carvalho de Melo return -1; 13305a8e5a30SArnaldo Carvalho de Melo 133186470930SIngo Molnar if (delay_secs < 1) 133286470930SIngo Molnar delay_secs = 1; 133386470930SIngo Molnar 13347e4ff9e3SMike Galbraith /* 13357e4ff9e3SMike Galbraith * User specified count overrides default frequency. 13367e4ff9e3SMike Galbraith */ 13377e4ff9e3SMike Galbraith if (default_interval) 13387e4ff9e3SMike Galbraith freq = 0; 13397e4ff9e3SMike Galbraith else if (freq) { 13407e4ff9e3SMike Galbraith default_interval = freq; 13417e4ff9e3SMike Galbraith } else { 13427e4ff9e3SMike Galbraith fprintf(stderr, "frequency and count are zero, aborting\n"); 13437e4ff9e3SMike Galbraith exit(EXIT_FAILURE); 13447e4ff9e3SMike Galbraith } 13457e4ff9e3SMike Galbraith 134686470930SIngo Molnar /* 134786470930SIngo Molnar * Fill in the ones not specifically initialized via -c: 134886470930SIngo Molnar */ 134986470930SIngo Molnar for (counter = 0; counter < nr_counters; counter++) { 135086470930SIngo Molnar if (attrs[counter].sample_period) 135186470930SIngo Molnar continue; 135286470930SIngo Molnar 135386470930SIngo Molnar attrs[counter].sample_period = default_interval; 135486470930SIngo Molnar } 135586470930SIngo Molnar 135686470930SIngo Molnar if (target_pid != -1 || profile_cpu != -1) 135786470930SIngo Molnar nr_cpus = 1; 1358a12b51c4SPaul Mackerras else 1359a12b51c4SPaul Mackerras nr_cpus = read_cpu_map(); 136086470930SIngo Molnar 136113cc5079SArnaldo Carvalho de Melo get_term_dimensions(&winsize); 13623b6ed988SArnaldo Carvalho de Melo if (print_entries == 0) { 136313cc5079SArnaldo Carvalho de Melo update_print_entries(&winsize); 13643b6ed988SArnaldo Carvalho de Melo signal(SIGWINCH, sig_winch_handler); 13653b6ed988SArnaldo Carvalho de Melo } 13663b6ed988SArnaldo Carvalho de Melo 136786470930SIngo Molnar return __cmd_top(); 136886470930SIngo Molnar } 1369