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