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