perf_counter tools: Move from Documentation/perf_counter/ to tools/perf/
[linux-2.6.git] / tools / perf / builtin-annotate.c
1 /*
2  * builtin-annotate.c
3  *
4  * Builtin annotate command: Analyze the perf.data input file,
5  * look up and read DSOs and symbol information and display
6  * a histogram of results, along various sorting keys.
7  */
8 #include "builtin.h"
9
10 #include "util/util.h"
11
12 #include "util/color.h"
13 #include "util/list.h"
14 #include "util/cache.h"
15 #include "util/rbtree.h"
16 #include "util/symbol.h"
17 #include "util/string.h"
18
19 #include "perf.h"
20
21 #include "util/parse-options.h"
22 #include "util/parse-events.h"
23
24 #define SHOW_KERNEL     1
25 #define SHOW_USER       2
26 #define SHOW_HV         4
27
28 static char             const *input_name = "perf.data";
29 static char             *vmlinux = NULL;
30
31 static char             default_sort_order[] = "comm,symbol";
32 static char             *sort_order = default_sort_order;
33
34 static int              input;
35 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
36
37 static int              dump_trace = 0;
38 #define dprintf(x...)   do { if (dump_trace) printf(x); } while (0)
39
40 static int              verbose;
41
42 static unsigned long    page_size;
43 static unsigned long    mmap_window = 32;
44
45 struct ip_event {
46         struct perf_event_header header;
47         __u64 ip;
48         __u32 pid, tid;
49 };
50
51 struct mmap_event {
52         struct perf_event_header header;
53         __u32 pid, tid;
54         __u64 start;
55         __u64 len;
56         __u64 pgoff;
57         char filename[PATH_MAX];
58 };
59
60 struct comm_event {
61         struct perf_event_header header;
62         __u32 pid, tid;
63         char comm[16];
64 };
65
66 struct fork_event {
67         struct perf_event_header header;
68         __u32 pid, ppid;
69 };
70
71 struct period_event {
72         struct perf_event_header header;
73         __u64 time;
74         __u64 id;
75         __u64 sample_period;
76 };
77
78 typedef union event_union {
79         struct perf_event_header        header;
80         struct ip_event                 ip;
81         struct mmap_event               mmap;
82         struct comm_event               comm;
83         struct fork_event               fork;
84         struct period_event             period;
85 } event_t;
86
87 static LIST_HEAD(dsos);
88 static struct dso *kernel_dso;
89 static struct dso *vdso;
90
91
92 static void dsos__add(struct dso *dso)
93 {
94         list_add_tail(&dso->node, &dsos);
95 }
96
97 static struct dso *dsos__find(const char *name)
98 {
99         struct dso *pos;
100
101         list_for_each_entry(pos, &dsos, node)
102                 if (strcmp(pos->name, name) == 0)
103                         return pos;
104         return NULL;
105 }
106
107 static struct dso *dsos__findnew(const char *name)
108 {
109         struct dso *dso = dsos__find(name);
110         int nr;
111
112         if (dso)
113                 return dso;
114
115         dso = dso__new(name, 0);
116         if (!dso)
117                 goto out_delete_dso;
118
119         nr = dso__load(dso, NULL, verbose);
120         if (nr < 0) {
121                 if (verbose)
122                         fprintf(stderr, "Failed to open: %s\n", name);
123                 goto out_delete_dso;
124         }
125         if (!nr && verbose) {
126                 fprintf(stderr,
127                 "No symbols found in: %s, maybe install a debug package?\n",
128                                 name);
129         }
130
131         dsos__add(dso);
132
133         return dso;
134
135 out_delete_dso:
136         dso__delete(dso);
137         return NULL;
138 }
139
140 static void dsos__fprintf(FILE *fp)
141 {
142         struct dso *pos;
143
144         list_for_each_entry(pos, &dsos, node)
145                 dso__fprintf(pos, fp);
146 }
147
148 static struct symbol *vdso__find_symbol(struct dso *dso, uint64_t ip)
149 {
150         return dso__find_symbol(kernel_dso, ip);
151 }
152
153 static int load_kernel(void)
154 {
155         int err;
156
157         kernel_dso = dso__new("[kernel]", 0);
158         if (!kernel_dso)
159                 return -1;
160
161         err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose);
162         if (err) {
163                 dso__delete(kernel_dso);
164                 kernel_dso = NULL;
165         } else
166                 dsos__add(kernel_dso);
167
168         vdso = dso__new("[vdso]", 0);
169         if (!vdso)
170                 return -1;
171
172         vdso->find_symbol = vdso__find_symbol;
173
174         dsos__add(vdso);
175
176         return err;
177 }
178
179 struct map {
180         struct list_head node;
181         uint64_t         start;
182         uint64_t         end;
183         uint64_t         pgoff;
184         uint64_t         (*map_ip)(struct map *, uint64_t);
185         struct dso       *dso;
186 };
187
188 static uint64_t map__map_ip(struct map *map, uint64_t ip)
189 {
190         return ip - map->start + map->pgoff;
191 }
192
193 static uint64_t vdso__map_ip(struct map *map, uint64_t ip)
194 {
195         return ip;
196 }
197
198 static struct map *map__new(struct mmap_event *event)
199 {
200         struct map *self = malloc(sizeof(*self));
201
202         if (self != NULL) {
203                 const char *filename = event->filename;
204
205                 self->start = event->start;
206                 self->end   = event->start + event->len;
207                 self->pgoff = event->pgoff;
208
209                 self->dso = dsos__findnew(filename);
210                 if (self->dso == NULL)
211                         goto out_delete;
212
213                 if (self->dso == vdso)
214                         self->map_ip = vdso__map_ip;
215                 else
216                         self->map_ip = map__map_ip;
217         }
218         return self;
219 out_delete:
220         free(self);
221         return NULL;
222 }
223
224 static struct map *map__clone(struct map *self)
225 {
226         struct map *map = malloc(sizeof(*self));
227
228         if (!map)
229                 return NULL;
230
231         memcpy(map, self, sizeof(*self));
232
233         return map;
234 }
235
236 static int map__overlap(struct map *l, struct map *r)
237 {
238         if (l->start > r->start) {
239                 struct map *t = l;
240                 l = r;
241                 r = t;
242         }
243
244         if (l->end > r->start)
245                 return 1;
246
247         return 0;
248 }
249
250 static size_t map__fprintf(struct map *self, FILE *fp)
251 {
252         return fprintf(fp, " %"PRIx64"-%"PRIx64" %"PRIx64" %s\n",
253                        self->start, self->end, self->pgoff, self->dso->name);
254 }
255
256
257 struct thread {
258         struct rb_node   rb_node;
259         struct list_head maps;
260         pid_t            pid;
261         char             *comm;
262 };
263
264 static struct thread *thread__new(pid_t pid)
265 {
266         struct thread *self = malloc(sizeof(*self));
267
268         if (self != NULL) {
269                 self->pid = pid;
270                 self->comm = malloc(32);
271                 if (self->comm)
272                         snprintf(self->comm, 32, ":%d", self->pid);
273                 INIT_LIST_HEAD(&self->maps);
274         }
275
276         return self;
277 }
278
279 static int thread__set_comm(struct thread *self, const char *comm)
280 {
281         if (self->comm)
282                 free(self->comm);
283         self->comm = strdup(comm);
284         return self->comm ? 0 : -ENOMEM;
285 }
286
287 static size_t thread__fprintf(struct thread *self, FILE *fp)
288 {
289         struct map *pos;
290         size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
291
292         list_for_each_entry(pos, &self->maps, node)
293                 ret += map__fprintf(pos, fp);
294
295         return ret;
296 }
297
298
299 static struct rb_root threads;
300 static struct thread *last_match;
301
302 static struct thread *threads__findnew(pid_t pid)
303 {
304         struct rb_node **p = &threads.rb_node;
305         struct rb_node *parent = NULL;
306         struct thread *th;
307
308         /*
309          * Font-end cache - PID lookups come in blocks,
310          * so most of the time we dont have to look up
311          * the full rbtree:
312          */
313         if (last_match && last_match->pid == pid)
314                 return last_match;
315
316         while (*p != NULL) {
317                 parent = *p;
318                 th = rb_entry(parent, struct thread, rb_node);
319
320                 if (th->pid == pid) {
321                         last_match = th;
322                         return th;
323                 }
324
325                 if (pid < th->pid)
326                         p = &(*p)->rb_left;
327                 else
328                         p = &(*p)->rb_right;
329         }
330
331         th = thread__new(pid);
332         if (th != NULL) {
333                 rb_link_node(&th->rb_node, parent, p);
334                 rb_insert_color(&th->rb_node, &threads);
335                 last_match = th;
336         }
337
338         return th;
339 }
340
341 static void thread__insert_map(struct thread *self, struct map *map)
342 {
343         struct map *pos, *tmp;
344
345         list_for_each_entry_safe(pos, tmp, &self->maps, node) {
346                 if (map__overlap(pos, map)) {
347                         list_del_init(&pos->node);
348                         /* XXX leaks dsos */
349                         free(pos);
350                 }
351         }
352
353         list_add_tail(&map->node, &self->maps);
354 }
355
356 static int thread__fork(struct thread *self, struct thread *parent)
357 {
358         struct map *map;
359
360         if (self->comm)
361                 free(self->comm);
362         self->comm = strdup(parent->comm);
363         if (!self->comm)
364                 return -ENOMEM;
365
366         list_for_each_entry(map, &parent->maps, node) {
367                 struct map *new = map__clone(map);
368                 if (!new)
369                         return -ENOMEM;
370                 thread__insert_map(self, new);
371         }
372
373         return 0;
374 }
375
376 static struct map *thread__find_map(struct thread *self, uint64_t ip)
377 {
378         struct map *pos;
379
380         if (self == NULL)
381                 return NULL;
382
383         list_for_each_entry(pos, &self->maps, node)
384                 if (ip >= pos->start && ip <= pos->end)
385                         return pos;
386
387         return NULL;
388 }
389
390 static size_t threads__fprintf(FILE *fp)
391 {
392         size_t ret = 0;
393         struct rb_node *nd;
394
395         for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
396                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
397
398                 ret += thread__fprintf(pos, fp);
399         }
400
401         return ret;
402 }
403
404 /*
405  * histogram, sorted on item, collects counts
406  */
407
408 static struct rb_root hist;
409
410 struct hist_entry {
411         struct rb_node   rb_node;
412
413         struct thread    *thread;
414         struct map       *map;
415         struct dso       *dso;
416         struct symbol    *sym;
417         uint64_t         ip;
418         char             level;
419
420         uint32_t         count;
421 };
422
423 /*
424  * configurable sorting bits
425  */
426
427 struct sort_entry {
428         struct list_head list;
429
430         char *header;
431
432         int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
433         int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
434         size_t  (*print)(FILE *fp, struct hist_entry *);
435 };
436
437 /* --sort pid */
438
439 static int64_t
440 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
441 {
442         return right->thread->pid - left->thread->pid;
443 }
444
445 static size_t
446 sort__thread_print(FILE *fp, struct hist_entry *self)
447 {
448         return fprintf(fp, "%16s:%5d", self->thread->comm ?: "", self->thread->pid);
449 }
450
451 static struct sort_entry sort_thread = {
452         .header = "         Command:  Pid",
453         .cmp    = sort__thread_cmp,
454         .print  = sort__thread_print,
455 };
456
457 /* --sort comm */
458
459 static int64_t
460 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
461 {
462         return right->thread->pid - left->thread->pid;
463 }
464
465 static int64_t
466 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
467 {
468         char *comm_l = left->thread->comm;
469         char *comm_r = right->thread->comm;
470
471         if (!comm_l || !comm_r) {
472                 if (!comm_l && !comm_r)
473                         return 0;
474                 else if (!comm_l)
475                         return -1;
476                 else
477                         return 1;
478         }
479
480         return strcmp(comm_l, comm_r);
481 }
482
483 static size_t
484 sort__comm_print(FILE *fp, struct hist_entry *self)
485 {
486         return fprintf(fp, "%16s", self->thread->comm);
487 }
488
489 static struct sort_entry sort_comm = {
490         .header         = "         Command",
491         .cmp            = sort__comm_cmp,
492         .collapse       = sort__comm_collapse,
493         .print          = sort__comm_print,
494 };
495
496 /* --sort dso */
497
498 static int64_t
499 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
500 {
501         struct dso *dso_l = left->dso;
502         struct dso *dso_r = right->dso;
503
504         if (!dso_l || !dso_r) {
505                 if (!dso_l && !dso_r)
506                         return 0;
507                 else if (!dso_l)
508                         return -1;
509                 else
510                         return 1;
511         }
512
513         return strcmp(dso_l->name, dso_r->name);
514 }
515
516 static size_t
517 sort__dso_print(FILE *fp, struct hist_entry *self)
518 {
519         if (self->dso)
520                 return fprintf(fp, "%-25s", self->dso->name);
521
522         return fprintf(fp, "%016llx         ", (__u64)self->ip);
523 }
524
525 static struct sort_entry sort_dso = {
526         .header = "Shared Object            ",
527         .cmp    = sort__dso_cmp,
528         .print  = sort__dso_print,
529 };
530
531 /* --sort symbol */
532
533 static int64_t
534 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
535 {
536         uint64_t ip_l, ip_r;
537
538         if (left->sym == right->sym)
539                 return 0;
540
541         ip_l = left->sym ? left->sym->start : left->ip;
542         ip_r = right->sym ? right->sym->start : right->ip;
543
544         return (int64_t)(ip_r - ip_l);
545 }
546
547 static size_t
548 sort__sym_print(FILE *fp, struct hist_entry *self)
549 {
550         size_t ret = 0;
551
552         if (verbose)
553                 ret += fprintf(fp, "%#018llx  ", (__u64)self->ip);
554
555         if (self->sym) {
556                 ret += fprintf(fp, "[%c] %s",
557                         self->dso == kernel_dso ? 'k' : '.', self->sym->name);
558         } else {
559                 ret += fprintf(fp, "%#016llx", (__u64)self->ip);
560         }
561
562         return ret;
563 }
564
565 static struct sort_entry sort_sym = {
566         .header = "Symbol",
567         .cmp    = sort__sym_cmp,
568         .print  = sort__sym_print,
569 };
570
571 static int sort__need_collapse = 0;
572
573 struct sort_dimension {
574         char                    *name;
575         struct sort_entry       *entry;
576         int                     taken;
577 };
578
579 static struct sort_dimension sort_dimensions[] = {
580         { .name = "pid",        .entry = &sort_thread,  },
581         { .name = "comm",       .entry = &sort_comm,    },
582         { .name = "dso",        .entry = &sort_dso,     },
583         { .name = "symbol",     .entry = &sort_sym,     },
584 };
585
586 static LIST_HEAD(hist_entry__sort_list);
587
588 static int sort_dimension__add(char *tok)
589 {
590         int i;
591
592         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
593                 struct sort_dimension *sd = &sort_dimensions[i];
594
595                 if (sd->taken)
596                         continue;
597
598                 if (strncasecmp(tok, sd->name, strlen(tok)))
599                         continue;
600
601                 if (sd->entry->collapse)
602                         sort__need_collapse = 1;
603
604                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
605                 sd->taken = 1;
606
607                 return 0;
608         }
609
610         return -ESRCH;
611 }
612
613 static int64_t
614 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
615 {
616         struct sort_entry *se;
617         int64_t cmp = 0;
618
619         list_for_each_entry(se, &hist_entry__sort_list, list) {
620                 cmp = se->cmp(left, right);
621                 if (cmp)
622                         break;
623         }
624
625         return cmp;
626 }
627
628 static int64_t
629 hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
630 {
631         struct sort_entry *se;
632         int64_t cmp = 0;
633
634         list_for_each_entry(se, &hist_entry__sort_list, list) {
635                 int64_t (*f)(struct hist_entry *, struct hist_entry *);
636
637                 f = se->collapse ?: se->cmp;
638
639                 cmp = f(left, right);
640                 if (cmp)
641                         break;
642         }
643
644         return cmp;
645 }
646
647 /*
648  * collect histogram counts
649  */
650 static void hist_hit(struct hist_entry *he, uint64_t ip)
651 {
652         unsigned int sym_size, offset;
653         struct symbol *sym = he->sym;
654
655         he->count++;
656
657         if (!sym || !sym->hist)
658                 return;
659
660         sym_size = sym->end - sym->start;
661         offset = ip - sym->start;
662
663         if (offset >= sym_size)
664                 return;
665
666         sym->hist_sum++;
667         sym->hist[offset]++;
668
669         if (verbose >= 3)
670                 printf("%p %s: count++ [ip: %p, %08Lx] => %Ld\n",
671                         (void *)he->sym->start,
672                         he->sym->name,
673                         (void *)ip, ip - he->sym->start,
674                         sym->hist[offset]);
675 }
676
677 static int
678 hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
679                 struct symbol *sym, uint64_t ip, char level)
680 {
681         struct rb_node **p = &hist.rb_node;
682         struct rb_node *parent = NULL;
683         struct hist_entry *he;
684         struct hist_entry entry = {
685                 .thread = thread,
686                 .map    = map,
687                 .dso    = dso,
688                 .sym    = sym,
689                 .ip     = ip,
690                 .level  = level,
691                 .count  = 1,
692         };
693         int cmp;
694
695         while (*p != NULL) {
696                 parent = *p;
697                 he = rb_entry(parent, struct hist_entry, rb_node);
698
699                 cmp = hist_entry__cmp(&entry, he);
700
701                 if (!cmp) {
702                         hist_hit(he, ip);
703
704                         return 0;
705                 }
706
707                 if (cmp < 0)
708                         p = &(*p)->rb_left;
709                 else
710                         p = &(*p)->rb_right;
711         }
712
713         he = malloc(sizeof(*he));
714         if (!he)
715                 return -ENOMEM;
716         *he = entry;
717         rb_link_node(&he->rb_node, parent, p);
718         rb_insert_color(&he->rb_node, &hist);
719
720         return 0;
721 }
722
723 static void hist_entry__free(struct hist_entry *he)
724 {
725         free(he);
726 }
727
728 /*
729  * collapse the histogram
730  */
731
732 static struct rb_root collapse_hists;
733
734 static void collapse__insert_entry(struct hist_entry *he)
735 {
736         struct rb_node **p = &collapse_hists.rb_node;
737         struct rb_node *parent = NULL;
738         struct hist_entry *iter;
739         int64_t cmp;
740
741         while (*p != NULL) {
742                 parent = *p;
743                 iter = rb_entry(parent, struct hist_entry, rb_node);
744
745                 cmp = hist_entry__collapse(iter, he);
746
747                 if (!cmp) {
748                         iter->count += he->count;
749                         hist_entry__free(he);
750                         return;
751                 }
752
753                 if (cmp < 0)
754                         p = &(*p)->rb_left;
755                 else
756                         p = &(*p)->rb_right;
757         }
758
759         rb_link_node(&he->rb_node, parent, p);
760         rb_insert_color(&he->rb_node, &collapse_hists);
761 }
762
763 static void collapse__resort(void)
764 {
765         struct rb_node *next;
766         struct hist_entry *n;
767
768         if (!sort__need_collapse)
769                 return;
770
771         next = rb_first(&hist);
772         while (next) {
773                 n = rb_entry(next, struct hist_entry, rb_node);
774                 next = rb_next(&n->rb_node);
775
776                 rb_erase(&n->rb_node, &hist);
777                 collapse__insert_entry(n);
778         }
779 }
780
781 /*
782  * reverse the map, sort on count.
783  */
784
785 static struct rb_root output_hists;
786
787 static void output__insert_entry(struct hist_entry *he)
788 {
789         struct rb_node **p = &output_hists.rb_node;
790         struct rb_node *parent = NULL;
791         struct hist_entry *iter;
792
793         while (*p != NULL) {
794                 parent = *p;
795                 iter = rb_entry(parent, struct hist_entry, rb_node);
796
797                 if (he->count > iter->count)
798                         p = &(*p)->rb_left;
799                 else
800                         p = &(*p)->rb_right;
801         }
802
803         rb_link_node(&he->rb_node, parent, p);
804         rb_insert_color(&he->rb_node, &output_hists);
805 }
806
807 static void output__resort(void)
808 {
809         struct rb_node *next;
810         struct hist_entry *n;
811         struct rb_root *tree = &hist;
812
813         if (sort__need_collapse)
814                 tree = &collapse_hists;
815
816         next = rb_first(tree);
817
818         while (next) {
819                 n = rb_entry(next, struct hist_entry, rb_node);
820                 next = rb_next(&n->rb_node);
821
822                 rb_erase(&n->rb_node, tree);
823                 output__insert_entry(n);
824         }
825 }
826
827 static void register_idle_thread(void)
828 {
829         struct thread *thread = threads__findnew(0);
830
831         if (thread == NULL ||
832                         thread__set_comm(thread, "[idle]")) {
833                 fprintf(stderr, "problem inserting idle task.\n");
834                 exit(-1);
835         }
836 }
837
838 static unsigned long total = 0,
839                      total_mmap = 0,
840                      total_comm = 0,
841                      total_fork = 0,
842                      total_unknown = 0;
843
844 static int
845 process_overflow_event(event_t *event, unsigned long offset, unsigned long head)
846 {
847         char level;
848         int show = 0;
849         struct dso *dso = NULL;
850         struct thread *thread = threads__findnew(event->ip.pid);
851         uint64_t ip = event->ip.ip;
852         struct map *map = NULL;
853
854         dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
855                 (void *)(offset + head),
856                 (void *)(long)(event->header.size),
857                 event->header.misc,
858                 event->ip.pid,
859                 (void *)(long)ip);
860
861         dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
862
863         if (thread == NULL) {
864                 fprintf(stderr, "problem processing %d event, skipping it.\n",
865                         event->header.type);
866                 return -1;
867         }
868
869         if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
870                 show = SHOW_KERNEL;
871                 level = 'k';
872
873                 dso = kernel_dso;
874
875                 dprintf(" ...... dso: %s\n", dso->name);
876
877         } else if (event->header.misc & PERF_EVENT_MISC_USER) {
878
879                 show = SHOW_USER;
880                 level = '.';
881
882                 map = thread__find_map(thread, ip);
883                 if (map != NULL) {
884                         ip = map->map_ip(map, ip);
885                         dso = map->dso;
886                 } else {
887                         /*
888                          * If this is outside of all known maps,
889                          * and is a negative address, try to look it
890                          * up in the kernel dso, as it might be a
891                          * vsyscall (which executes in user-mode):
892                          */
893                         if ((long long)ip < 0)
894                                 dso = kernel_dso;
895                 }
896                 dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
897
898         } else {
899                 show = SHOW_HV;
900                 level = 'H';
901                 dprintf(" ...... dso: [hypervisor]\n");
902         }
903
904         if (show & show_mask) {
905                 struct symbol *sym = NULL;
906
907                 if (dso)
908                         sym = dso->find_symbol(dso, ip);
909
910                 if (hist_entry__add(thread, map, dso, sym, ip, level)) {
911                         fprintf(stderr,
912                 "problem incrementing symbol count, skipping event\n");
913                         return -1;
914                 }
915         }
916         total++;
917
918         return 0;
919 }
920
921 static int
922 process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
923 {
924         struct thread *thread = threads__findnew(event->mmap.pid);
925         struct map *map = map__new(&event->mmap);
926
927         dprintf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
928                 (void *)(offset + head),
929                 (void *)(long)(event->header.size),
930                 event->mmap.pid,
931                 (void *)(long)event->mmap.start,
932                 (void *)(long)event->mmap.len,
933                 (void *)(long)event->mmap.pgoff,
934                 event->mmap.filename);
935
936         if (thread == NULL || map == NULL) {
937                 dprintf("problem processing PERF_EVENT_MMAP, skipping event.\n");
938                 return 0;
939         }
940
941         thread__insert_map(thread, map);
942         total_mmap++;
943
944         return 0;
945 }
946
947 static int
948 process_comm_event(event_t *event, unsigned long offset, unsigned long head)
949 {
950         struct thread *thread = threads__findnew(event->comm.pid);
951
952         dprintf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
953                 (void *)(offset + head),
954                 (void *)(long)(event->header.size),
955                 event->comm.comm, event->comm.pid);
956
957         if (thread == NULL ||
958             thread__set_comm(thread, event->comm.comm)) {
959                 dprintf("problem processing PERF_EVENT_COMM, skipping event.\n");
960                 return -1;
961         }
962         total_comm++;
963
964         return 0;
965 }
966
967 static int
968 process_fork_event(event_t *event, unsigned long offset, unsigned long head)
969 {
970         struct thread *thread = threads__findnew(event->fork.pid);
971         struct thread *parent = threads__findnew(event->fork.ppid);
972
973         dprintf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
974                 (void *)(offset + head),
975                 (void *)(long)(event->header.size),
976                 event->fork.pid, event->fork.ppid);
977
978         if (!thread || !parent || thread__fork(thread, parent)) {
979                 dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
980                 return -1;
981         }
982         total_fork++;
983
984         return 0;
985 }
986
987 static int
988 process_period_event(event_t *event, unsigned long offset, unsigned long head)
989 {
990         dprintf("%p [%p]: PERF_EVENT_PERIOD: time:%Ld, id:%Ld: period:%Ld\n",
991                 (void *)(offset + head),
992                 (void *)(long)(event->header.size),
993                 event->period.time,
994                 event->period.id,
995                 event->period.sample_period);
996
997         return 0;
998 }
999
1000 static int
1001 process_event(event_t *event, unsigned long offset, unsigned long head)
1002 {
1003         if (event->header.misc & PERF_EVENT_MISC_OVERFLOW)
1004                 return process_overflow_event(event, offset, head);
1005
1006         switch (event->header.type) {
1007         case PERF_EVENT_MMAP:
1008                 return process_mmap_event(event, offset, head);
1009
1010         case PERF_EVENT_COMM:
1011                 return process_comm_event(event, offset, head);
1012
1013         case PERF_EVENT_FORK:
1014                 return process_fork_event(event, offset, head);
1015
1016         case PERF_EVENT_PERIOD:
1017                 return process_period_event(event, offset, head);
1018         /*
1019          * We dont process them right now but they are fine:
1020          */
1021
1022         case PERF_EVENT_THROTTLE:
1023         case PERF_EVENT_UNTHROTTLE:
1024                 return 0;
1025
1026         default:
1027                 return -1;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int
1034 parse_line(FILE *file, struct symbol *sym, uint64_t start, uint64_t len)
1035 {
1036         char *line = NULL, *tmp, *tmp2;
1037         unsigned int offset;
1038         size_t line_len;
1039         __u64 line_ip;
1040         int ret;
1041         char *c;
1042
1043         if (getline(&line, &line_len, file) < 0)
1044                 return -1;
1045         if (!line)
1046                 return -1;
1047
1048         c = strchr(line, '\n');
1049         if (c)
1050                 *c = 0;
1051
1052         line_ip = -1;
1053         offset = 0;
1054         ret = -2;
1055
1056         /*
1057          * Strip leading spaces:
1058          */
1059         tmp = line;
1060         while (*tmp) {
1061                 if (*tmp != ' ')
1062                         break;
1063                 tmp++;
1064         }
1065
1066         if (*tmp) {
1067                 /*
1068                  * Parse hexa addresses followed by ':'
1069                  */
1070                 line_ip = strtoull(tmp, &tmp2, 16);
1071                 if (*tmp2 != ':')
1072                         line_ip = -1;
1073         }
1074
1075         if (line_ip != -1) {
1076                 unsigned int hits = 0;
1077                 double percent = 0.0;
1078                 char *color = PERF_COLOR_NORMAL;
1079
1080                 offset = line_ip - start;
1081                 if (offset < len)
1082                         hits = sym->hist[offset];
1083
1084                 if (sym->hist_sum)
1085                         percent = 100.0 * hits / sym->hist_sum;
1086
1087                 /*
1088                  * We color high-overhead entries in red, low-overhead
1089                  * entries in green - and keep the middle ground normal:
1090                  */
1091                 if (percent >= 5.0)
1092                         color = PERF_COLOR_RED;
1093                 else {
1094                         if (percent > 0.5)
1095                                 color = PERF_COLOR_GREEN;
1096                 }
1097
1098                 color_fprintf(stdout, color, " %7.2f", percent);
1099                 printf(" :      ");
1100                 color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
1101         } else {
1102                 if (!*line)
1103                         printf("         :\n");
1104                 else
1105                         printf("         :      %s\n", line);
1106         }
1107
1108         return 0;
1109 }
1110
1111 static void annotate_sym(struct dso *dso, struct symbol *sym)
1112 {
1113         char *filename = dso->name;
1114         uint64_t start, end, len;
1115         char command[PATH_MAX*2];
1116         FILE *file;
1117
1118         if (!filename)
1119                 return;
1120         if (dso == kernel_dso)
1121                 filename = vmlinux;
1122
1123         printf("\n------------------------------------------------\n");
1124         printf(" Percent |      Source code & Disassembly of %s\n", filename);
1125         printf("------------------------------------------------\n");
1126
1127         if (verbose >= 2)
1128                 printf("annotating [%p] %30s : [%p] %30s\n", dso, dso->name, sym, sym->name);
1129
1130         start = sym->obj_start;
1131         if (!start)
1132                 start = sym->start;
1133
1134         end = start + sym->end - sym->start + 1;
1135         len = sym->end - sym->start;
1136
1137         sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s", (__u64)start, (__u64)end, filename);
1138
1139         if (verbose >= 3)
1140                 printf("doing: %s\n", command);
1141
1142         file = popen(command, "r");
1143         if (!file)
1144                 return;
1145
1146         while (!feof(file)) {
1147                 if (parse_line(file, sym, start, len) < 0)
1148                         break;
1149         }
1150
1151         pclose(file);
1152 }
1153
1154 static void find_annotations(void)
1155 {
1156         struct rb_node *nd;
1157         struct dso *dso;
1158         int count = 0;
1159
1160         list_for_each_entry(dso, &dsos, node) {
1161
1162                 for (nd = rb_first(&dso->syms); nd; nd = rb_next(nd)) {
1163                         struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
1164
1165                         if (sym->hist) {
1166                                 annotate_sym(dso, sym);
1167                                 count++;
1168                         }
1169                 }
1170         }
1171
1172         if (!count)
1173                 printf(" Error: symbol '%s' not present amongst the samples.\n", sym_hist_filter);
1174 }
1175
1176 static int __cmd_annotate(void)
1177 {
1178         int ret, rc = EXIT_FAILURE;
1179         unsigned long offset = 0;
1180         unsigned long head = 0;
1181         struct stat stat;
1182         event_t *event;
1183         uint32_t size;
1184         char *buf;
1185
1186         register_idle_thread();
1187
1188         input = open(input_name, O_RDONLY);
1189         if (input < 0) {
1190                 perror("failed to open file");
1191                 exit(-1);
1192         }
1193
1194         ret = fstat(input, &stat);
1195         if (ret < 0) {
1196                 perror("failed to stat file");
1197                 exit(-1);
1198         }
1199
1200         if (!stat.st_size) {
1201                 fprintf(stderr, "zero-sized file, nothing to do!\n");
1202                 exit(0);
1203         }
1204
1205         if (load_kernel() < 0) {
1206                 perror("failed to load kernel symbols");
1207                 return EXIT_FAILURE;
1208         }
1209
1210 remap:
1211         buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
1212                            MAP_SHARED, input, offset);
1213         if (buf == MAP_FAILED) {
1214                 perror("failed to mmap file");
1215                 exit(-1);
1216         }
1217
1218 more:
1219         event = (event_t *)(buf + head);
1220
1221         size = event->header.size;
1222         if (!size)
1223                 size = 8;
1224
1225         if (head + event->header.size >= page_size * mmap_window) {
1226                 unsigned long shift = page_size * (head / page_size);
1227                 int ret;
1228
1229                 ret = munmap(buf, page_size * mmap_window);
1230                 assert(ret == 0);
1231
1232                 offset += shift;
1233                 head -= shift;
1234                 goto remap;
1235         }
1236
1237         size = event->header.size;
1238
1239         dprintf("%p [%p]: event: %d\n",
1240                         (void *)(offset + head),
1241                         (void *)(long)event->header.size,
1242                         event->header.type);
1243
1244         if (!size || process_event(event, offset, head) < 0) {
1245
1246                 dprintf("%p [%p]: skipping unknown header type: %d\n",
1247                         (void *)(offset + head),
1248                         (void *)(long)(event->header.size),
1249                         event->header.type);
1250
1251                 total_unknown++;
1252
1253                 /*
1254                  * assume we lost track of the stream, check alignment, and
1255                  * increment a single u64 in the hope to catch on again 'soon'.
1256                  */
1257
1258                 if (unlikely(head & 7))
1259                         head &= ~7ULL;
1260
1261                 size = 8;
1262         }
1263
1264         head += size;
1265
1266         if (offset + head < stat.st_size)
1267                 goto more;
1268
1269         rc = EXIT_SUCCESS;
1270         close(input);
1271
1272         dprintf("      IP events: %10ld\n", total);
1273         dprintf("    mmap events: %10ld\n", total_mmap);
1274         dprintf("    comm events: %10ld\n", total_comm);
1275         dprintf("    fork events: %10ld\n", total_fork);
1276         dprintf(" unknown events: %10ld\n", total_unknown);
1277
1278         if (dump_trace)
1279                 return 0;
1280
1281         if (verbose >= 3)
1282                 threads__fprintf(stdout);
1283
1284         if (verbose >= 2)
1285                 dsos__fprintf(stdout);
1286
1287         collapse__resort();
1288         output__resort();
1289
1290         find_annotations();
1291
1292         return rc;
1293 }
1294
1295 static const char * const annotate_usage[] = {
1296         "perf annotate [<options>] <command>",
1297         NULL
1298 };
1299
1300 static const struct option options[] = {
1301         OPT_STRING('i', "input", &input_name, "file",
1302                     "input file name"),
1303         OPT_STRING('s', "symbol", &sym_hist_filter, "file",
1304                     "symbol to annotate"),
1305         OPT_BOOLEAN('v', "verbose", &verbose,
1306                     "be more verbose (show symbol address, etc)"),
1307         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1308                     "dump raw trace in ASCII"),
1309         OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
1310         OPT_END()
1311 };
1312
1313 static void setup_sorting(void)
1314 {
1315         char *tmp, *tok, *str = strdup(sort_order);
1316
1317         for (tok = strtok_r(str, ", ", &tmp);
1318                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
1319                 if (sort_dimension__add(tok) < 0) {
1320                         error("Unknown --sort key: `%s'", tok);
1321                         usage_with_options(annotate_usage, options);
1322                 }
1323         }
1324
1325         free(str);
1326 }
1327
1328 int cmd_annotate(int argc, const char **argv, const char *prefix)
1329 {
1330         symbol__init();
1331
1332         page_size = getpagesize();
1333
1334         argc = parse_options(argc, argv, options, annotate_usage, 0);
1335
1336         setup_sorting();
1337
1338         if (argc) {
1339                 /*
1340                  * Special case: if there's an argument left then assume tha
1341                  * it's a symbol filter:
1342                  */
1343                 if (argc > 1)
1344                         usage_with_options(annotate_usage, options);
1345
1346                 sym_hist_filter = argv[0];
1347         }
1348
1349         if (!sym_hist_filter)
1350                 usage_with_options(annotate_usage, options);
1351
1352         setup_pager();
1353
1354         return __cmd_annotate();
1355 }