?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf report: Annotate variable initialization
[linux-2.6/verdex.git] / tools / perf / builtin-report.c
blobfa937f5c3c395afb0e44c1553877fe1b8ba5733e
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 <linux/list.h>
14 #include "util/cache.h"
15 #include <linux/rbtree.h>
16 #include "util/symbol.h"
17 #include "util/string.h"
18 #include "util/callchain.h"
19 #include "util/strlist.h"
20
21 #include "perf.h"
22 #include "util/header.h"
23
24 #include "util/parse-options.h"
25 #include "util/parse-events.h"
26
27 #define SHOW_KERNEL 1
28 #define SHOW_USER 2
29 #define SHOW_HV 4
30
31 static char const *input_name = "perf.data";
32 static char *vmlinux = NULL;
33
34 static char default_sort_order[] = "comm,dso";
35 static char *sort_order = default_sort_order;
36 static char *dso_list_str, *comm_list_str, *sym_list_str;
37 static struct strlist *dso_list, *comm_list, *sym_list;
38
39 static int input;
40 static int show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
41
42 static int dump_trace = 0;
43 #define dprintf(x...) do { if (dump_trace) printf(x); } while (0)
44 #define cdprintf(x...) do { if (dump_trace) color_fprintf(stdout, color, x); } while (0)
45
46 static int verbose;
47 #define eprintf(x...) do { if (verbose) fprintf(stderr, x); } while (0)
48
49 static int modules;
50
51 static int full_paths;
52
53 static unsigned long page_size;
54 static unsigned long mmap_window = 32;
55
56 static char default_parent_pattern[] = "^sys_|^do_page_fault";
57 static char *parent_pattern = default_parent_pattern;
58 static regex_t parent_regex;
59
60 static int exclude_other = 1;
61 static int callchain;
62 static enum chain_mode callchain_mode;
63 static double callchain_min_percent = 0.0;
64
65 static u64 sample_type;
66
67 struct ip_event {
68 struct perf_event_header header;
69 u64 ip;
70 u32 pid, tid;
71 unsigned char __more_data[];
72 };
73
74 struct mmap_event {
75 struct perf_event_header header;
76 u32 pid, tid;
77 u64 start;
78 u64 len;
79 u64 pgoff;
80 char filename[PATH_MAX];
81 };
82
83 struct comm_event {
84 struct perf_event_header header;
85 u32 pid, tid;
86 char comm[16];
87 };
88
89 struct fork_event {
90 struct perf_event_header header;
91 u32 pid, ppid;
92 };
93
94 struct period_event {
95 struct perf_event_header header;
96 u64 time;
97 u64 id;
98 u64 sample_period;
99 };
100
101 struct lost_event {
102 struct perf_event_header header;
103 u64 id;
104 u64 lost;
105 };
106
107 struct read_event {
108 struct perf_event_header header;
109 u32 pid,tid;
110 u64 value;
111 u64 format[3];
112 };
113
114 typedef union event_union {
115 struct perf_event_header header;
116 struct ip_event ip;
117 struct mmap_event mmap;
118 struct comm_event comm;
119 struct fork_event fork;
120 struct period_event period;
121 struct lost_event lost;
122 struct read_event read;
123 } event_t;
124
125 static LIST_HEAD(dsos);
126 static struct dso *kernel_dso;
127 static struct dso *vdso;
128 static struct dso *hypervisor_dso;
129
130 static void dsos__add(struct dso *dso)
131 {
132 list_add_tail(&dso->node, &dsos);
133 }
134
135 static struct dso *dsos__find(const char *name)
136 {
137 struct dso *pos;
138
139 list_for_each_entry(pos, &dsos, node)
140 if (strcmp(pos->name, name) == 0)
141 return pos;
142 return NULL;
143 }
144
145 static struct dso *dsos__findnew(const char *name)
146 {
147 struct dso *dso = dsos__find(name);
148 int nr;
149
150 if (dso)
151 return dso;
152
153 dso = dso__new(name, 0);
154 if (!dso)
155 goto out_delete_dso;
156
157 nr = dso__load(dso, NULL, verbose);
158 if (nr < 0) {
159 eprintf("Failed to open: %s\n", name);
160 goto out_delete_dso;
161 }
162 if (!nr)
163 eprintf("No symbols found in: %s, maybe install a debug package?\n", name);
164
165 dsos__add(dso);
166
167 return dso;
168
169 out_delete_dso:
170 dso__delete(dso);
171 return NULL;
172 }
173
174 static void dsos__fprintf(FILE *fp)
175 {
176 struct dso *pos;
177
178 list_for_each_entry(pos, &dsos, node)
179 dso__fprintf(pos, fp);
180 }
181
182 static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
183 {
184 return dso__find_symbol(dso, ip);
185 }
186
187 static int load_kernel(void)
188 {
189 int err;
190
191 kernel_dso = dso__new("[kernel]", 0);
192 if (!kernel_dso)
193 return -1;
194
195 err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose, modules);
196 if (err <= 0) {
197 dso__delete(kernel_dso);
198 kernel_dso = NULL;
199 } else
200 dsos__add(kernel_dso);
201
202 vdso = dso__new("[vdso]", 0);
203 if (!vdso)
204 return -1;
205
206 vdso->find_symbol = vdso__find_symbol;
207
208 dsos__add(vdso);
209
210 hypervisor_dso = dso__new("[hypervisor]", 0);
211 if (!hypervisor_dso)
212 return -1;
213 dsos__add(hypervisor_dso);
214
215 return err;
216 }
217
218 static char __cwd[PATH_MAX];
219 static char *cwd = __cwd;
220 static int cwdlen;
221
222 static int strcommon(const char *pathname)
223 {
224 int n = 0;
225
226 while (pathname[n] == cwd[n] && n < cwdlen)
227 ++n;
228
229 return n;
230 }
231
232 struct map {
233 struct list_head node;
234 u64 start;
235 u64 end;
236 u64 pgoff;
237 u64 (*map_ip)(struct map *, u64);
238 struct dso *dso;
239 };
240
241 static u64 map__map_ip(struct map *map, u64 ip)
242 {
243 return ip - map->start + map->pgoff;
244 }
245
246 static u64 vdso__map_ip(struct map *map __used, u64 ip)
247 {
248 return ip;
249 }
250
251 static inline int is_anon_memory(const char *filename)
252 {
253 return strcmp(filename, "//anon") == 0;
254 }
255
256 static struct map *map__new(struct mmap_event *event)
257 {
258 struct map *self = malloc(sizeof(*self));
259
260 if (self != NULL) {
261 const char *filename = event->filename;
262 char newfilename[PATH_MAX];
263 int anon;
264
265 if (cwd) {
266 int n = strcommon(filename);
267
268 if (n == cwdlen) {
269 snprintf(newfilename, sizeof(newfilename),
270 ".%s", filename + n);
271 filename = newfilename;
272 }
273 }
274
275 anon = is_anon_memory(filename);
276
277 if (anon) {
278 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
279 filename = newfilename;
280 }
281
282 self->start = event->start;
283 self->end = event->start + event->len;
284 self->pgoff = event->pgoff;
285
286 self->dso = dsos__findnew(filename);
287 if (self->dso == NULL)
288 goto out_delete;
289
290 if (self->dso == vdso || anon)
291 self->map_ip = vdso__map_ip;
292 else
293 self->map_ip = map__map_ip;
294 }
295 return self;
296 out_delete:
297 free(self);
298 return NULL;
299 }
300
301 static struct map *map__clone(struct map *self)
302 {
303 struct map *map = malloc(sizeof(*self));
304
305 if (!map)
306 return NULL;
307
308 memcpy(map, self, sizeof(*self));
309
310 return map;
311 }
312
313 static int map__overlap(struct map *l, struct map *r)
314 {
315 if (l->start > r->start) {
316 struct map *t = l;
317 l = r;
318 r = t;
319 }
320
321 if (l->end > r->start)
322 return 1;
323
324 return 0;
325 }
326
327 static size_t map__fprintf(struct map *self, FILE *fp)
328 {
329 return fprintf(fp, " %Lx-%Lx %Lx %s\n",
330 self->start, self->end, self->pgoff, self->dso->name);
331 }
332
333
334 struct thread {
335 struct rb_node rb_node;
336 struct list_head maps;
337 pid_t pid;
338 char *comm;
339 };
340
341 static struct thread *thread__new(pid_t pid)
342 {
343 struct thread *self = malloc(sizeof(*self));
344
345 if (self != NULL) {
346 self->pid = pid;
347 self->comm = malloc(32);
348 if (self->comm)
349 snprintf(self->comm, 32, ":%d", self->pid);
350 INIT_LIST_HEAD(&self->maps);
351 }
352
353 return self;
354 }
355
356 static int thread__set_comm(struct thread *self, const char *comm)
357 {
358 if (self->comm)
359 free(self->comm);
360 self->comm = strdup(comm);
361 return self->comm ? 0 : -ENOMEM;
362 }
363
364 static size_t thread__fprintf(struct thread *self, FILE *fp)
365 {
366 struct map *pos;
367 size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
368
369 list_for_each_entry(pos, &self->maps, node)
370 ret += map__fprintf(pos, fp);
371
372 return ret;
373 }
374
375
376 static struct rb_root threads;
377 static struct thread *last_match;
378
379 static struct thread *threads__findnew(pid_t pid)
380 {
381 struct rb_node **p = &threads.rb_node;
382 struct rb_node *parent = NULL;
383 struct thread *th;
384
385 /*
386 * Font-end cache - PID lookups come in blocks,
387 * so most of the time we dont have to look up
388 * the full rbtree:
389 */
390 if (last_match && last_match->pid == pid)
391 return last_match;
392
393 while (*p != NULL) {
394 parent = *p;
395 th = rb_entry(parent, struct thread, rb_node);
396
397 if (th->pid == pid) {
398 last_match = th;
399 return th;
400 }
401
402 if (pid < th->pid)
403 p = &(*p)->rb_left;
404 else
405 p = &(*p)->rb_right;
406 }
407
408 th = thread__new(pid);
409 if (th != NULL) {
410 rb_link_node(&th->rb_node, parent, p);
411 rb_insert_color(&th->rb_node, &threads);
412 last_match = th;
413 }
414
415 return th;
416 }
417
418 static void thread__insert_map(struct thread *self, struct map *map)
419 {
420 struct map *pos, *tmp;
421
422 list_for_each_entry_safe(pos, tmp, &self->maps, node) {
423 if (map__overlap(pos, map)) {
424 if (verbose >= 2) {
425 printf("overlapping maps:\n");
426 map__fprintf(map, stdout);
427 map__fprintf(pos, stdout);
428 }
429
430 if (map->start <= pos->start && map->end > pos->start)
431 pos->start = map->end;
432
433 if (map->end >= pos->end && map->start < pos->end)
434 pos->end = map->start;
435
436 if (verbose >= 2) {
437 printf("after collision:\n");
438 map__fprintf(pos, stdout);
439 }
440
441 if (pos->start >= pos->end) {
442 list_del_init(&pos->node);
443 free(pos);
444 }
445 }
446 }
447
448 list_add_tail(&map->node, &self->maps);
449 }
450
451 static int thread__fork(struct thread *self, struct thread *parent)
452 {
453 struct map *map;
454
455 if (self->comm)
456 free(self->comm);
457 self->comm = strdup(parent->comm);
458 if (!self->comm)
459 return -ENOMEM;
460
461 list_for_each_entry(map, &parent->maps, node) {
462 struct map *new = map__clone(map);
463 if (!new)
464 return -ENOMEM;
465 thread__insert_map(self, new);
466 }
467
468 return 0;
469 }
470
471 static struct map *thread__find_map(struct thread *self, u64 ip)
472 {
473 struct map *pos;
474
475 if (self == NULL)
476 return NULL;
477
478 list_for_each_entry(pos, &self->maps, node)
479 if (ip >= pos->start && ip <= pos->end)
480 return pos;
481
482 return NULL;
483 }
484
485 static size_t threads__fprintf(FILE *fp)
486 {
487 size_t ret = 0;
488 struct rb_node *nd;
489
490 for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
491 struct thread *pos = rb_entry(nd, struct thread, rb_node);
492
493 ret += thread__fprintf(pos, fp);
494 }
495
496 return ret;
497 }
498
499 /*
500 * histogram, sorted on item, collects counts
501 */
502
503 static struct rb_root hist;
504
505 struct hist_entry {
506 struct rb_node rb_node;
507
508 struct thread *thread;
509 struct map *map;
510 struct dso *dso;
511 struct symbol *sym;
512 struct symbol *parent;
513 u64 ip;
514 char level;
515 struct callchain_node callchain;
516 struct rb_root sorted_chain;
517
518 u64 count;
519 };
520
521 /*
522 * configurable sorting bits
523 */
524
525 struct sort_entry {
526 struct list_head list;
527
528 char *header;
529
530 int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
531 int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
532 size_t (*print)(FILE *fp, struct hist_entry *);
533 };
534
535 static int64_t cmp_null(void *l, void *r)
536 {
537 if (!l && !r)
538 return 0;
539 else if (!l)
540 return -1;
541 else
542 return 1;
543 }
544
545 /* --sort pid */
546
547 static int64_t
548 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
549 {
550 return right->thread->pid - left->thread->pid;
551 }
552
553 static size_t
554 sort__thread_print(FILE *fp, struct hist_entry *self)
555 {
556 return fprintf(fp, "%16s:%5d", self->thread->comm ?: "", self->thread->pid);
557 }
558
559 static struct sort_entry sort_thread = {
560 .header = " Command: Pid",
561 .cmp = sort__thread_cmp,
562 .print = sort__thread_print,
563 };
564
565 /* --sort comm */
566
567 static int64_t
568 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
569 {
570 return right->thread->pid - left->thread->pid;
571 }
572
573 static int64_t
574 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
575 {
576 char *comm_l = left->thread->comm;
577 char *comm_r = right->thread->comm;
578
579 if (!comm_l || !comm_r)
580 return cmp_null(comm_l, comm_r);
581
582 return strcmp(comm_l, comm_r);
583 }
584
585 static size_t
586 sort__comm_print(FILE *fp, struct hist_entry *self)
587 {
588 return fprintf(fp, "%16s", self->thread->comm);
589 }
590
591 static struct sort_entry sort_comm = {
592 .header = " Command",
593 .cmp = sort__comm_cmp,
594 .collapse = sort__comm_collapse,
595 .print = sort__comm_print,
596 };
597
598 /* --sort dso */
599
600 static int64_t
601 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
602 {
603 struct dso *dso_l = left->dso;
604 struct dso *dso_r = right->dso;
605
606 if (!dso_l || !dso_r)
607 return cmp_null(dso_l, dso_r);
608
609 return strcmp(dso_l->name, dso_r->name);
610 }
611
612 static size_t
613 sort__dso_print(FILE *fp, struct hist_entry *self)
614 {
615 if (self->dso)
616 return fprintf(fp, "%-25s", self->dso->name);
617
618 return fprintf(fp, "%016llx ", (u64)self->ip);
619 }
620
621 static struct sort_entry sort_dso = {
622 .header = "Shared Object ",
623 .cmp = sort__dso_cmp,
624 .print = sort__dso_print,
625 };
626
627 /* --sort symbol */
628
629 static int64_t
630 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
631 {
632 u64 ip_l, ip_r;
633
634 if (left->sym == right->sym)
635 return 0;
636
637 ip_l = left->sym ? left->sym->start : left->ip;
638 ip_r = right->sym ? right->sym->start : right->ip;
639
640 return (int64_t)(ip_r - ip_l);
641 }
642
643 static size_t
644 sort__sym_print(FILE *fp, struct hist_entry *self)
645 {
646 size_t ret = 0;
647
648 if (verbose)
649 ret += fprintf(fp, "%#018llx ", (u64)self->ip);
650
651 if (self->sym) {
652 ret += fprintf(fp, "[%c] %s",
653 self->dso == kernel_dso ? 'k' :
654 self->dso == hypervisor_dso ? 'h' : '.', self->sym->name);
655
656 if (self->sym->module)
657 ret += fprintf(fp, "\t[%s]", self->sym->module->name);
658 } else {
659 ret += fprintf(fp, "%#016llx", (u64)self->ip);
660 }
661
662 return ret;
663 }
664
665 static struct sort_entry sort_sym = {
666 .header = "Symbol",
667 .cmp = sort__sym_cmp,
668 .print = sort__sym_print,
669 };
670
671 /* --sort parent */
672
673 static int64_t
674 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
675 {
676 struct symbol *sym_l = left->parent;
677 struct symbol *sym_r = right->parent;
678
679 if (!sym_l || !sym_r)
680 return cmp_null(sym_l, sym_r);
681
682 return strcmp(sym_l->name, sym_r->name);
683 }
684
685 static size_t
686 sort__parent_print(FILE *fp, struct hist_entry *self)
687 {
688 size_t ret = 0;
689
690 ret += fprintf(fp, "%-20s", self->parent ? self->parent->name : "[other]");
691
692 return ret;
693 }
694
695 static struct sort_entry sort_parent = {
696 .header = "Parent symbol ",
697 .cmp = sort__parent_cmp,
698 .print = sort__parent_print,
699 };
700
701 static int sort__need_collapse = 0;
702 static int sort__has_parent = 0;
703
704 struct sort_dimension {
705 char *name;
706 struct sort_entry *entry;
707 int taken;
708 };
709
710 static struct sort_dimension sort_dimensions[] = {
711 { .name = "pid", .entry = &sort_thread, },
712 { .name = "comm", .entry = &sort_comm, },
713 { .name = "dso", .entry = &sort_dso, },
714 { .name = "symbol", .entry = &sort_sym, },
715 { .name = "parent", .entry = &sort_parent, },
716 };
717
718 static LIST_HEAD(hist_entry__sort_list);
719
720 static int sort_dimension__add(char *tok)
721 {
722 unsigned int i;
723
724 for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
725 struct sort_dimension *sd = &sort_dimensions[i];
726
727 if (sd->taken)
728 continue;
729
730 if (strncasecmp(tok, sd->name, strlen(tok)))
731 continue;
732
733 if (sd->entry->collapse)
734 sort__need_collapse = 1;
735
736 if (sd->entry == &sort_parent) {
737 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
738 if (ret) {
739 char err[BUFSIZ];
740
741 regerror(ret, &parent_regex, err, sizeof(err));
742 fprintf(stderr, "Invalid regex: %s\n%s",
743 parent_pattern, err);
744 exit(-1);
745 }
746 sort__has_parent = 1;
747 }
748
749 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
750 sd->taken = 1;
751
752 return 0;
753 }
754
755 return -ESRCH;
756 }
757
758 static int64_t
759 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
760 {
761 struct sort_entry *se;
762 int64_t cmp = 0;
763
764 list_for_each_entry(se, &hist_entry__sort_list, list) {
765 cmp = se->cmp(left, right);
766 if (cmp)
767 break;
768 }
769
770 return cmp;
771 }
772
773 static int64_t
774 hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
775 {
776 struct sort_entry *se;
777 int64_t cmp = 0;
778
779 list_for_each_entry(se, &hist_entry__sort_list, list) {
780 int64_t (*f)(struct hist_entry *, struct hist_entry *);
781
782 f = se->collapse ?: se->cmp;
783
784 cmp = f(left, right);
785 if (cmp)
786 break;
787 }
788
789 return cmp;
790 }
791
792 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
793 {
794 int i;
795 size_t ret = 0;
796
797 ret += fprintf(fp, "%s", " ");
798
799 for (i = 0; i < depth; i++)
800 if (depth_mask & (1 << i))
801 ret += fprintf(fp, "| ");
802 else
803 ret += fprintf(fp, " ");
804
805 ret += fprintf(fp, "\n");
806
807 return ret;
808 }
809 static size_t
810 ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
811 int depth_mask, int count, u64 total_samples,
812 int hits)
813 {
814 int i;
815 size_t ret = 0;
816
817 ret += fprintf(fp, "%s", " ");
818 for (i = 0; i < depth; i++) {
819 if (depth_mask & (1 << i))
820 ret += fprintf(fp, "|");
821 else
822 ret += fprintf(fp, " ");
823 if (!count && i == depth - 1) {
824 double percent;
825
826 percent = hits * 100.0 / total_samples;
827 ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
828 } else
829 ret += fprintf(fp, "%s", " ");
830 }
831 if (chain->sym)
832 ret += fprintf(fp, "%s\n", chain->sym->name);
833 else
834 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
835
836 return ret;
837 }
838
839 static size_t
840 callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
841 u64 total_samples, int depth, int depth_mask)
842 {
843 struct rb_node *node, *next;
844 struct callchain_node *child;
845 struct callchain_list *chain;
846 int new_depth_mask = depth_mask;
847 size_t ret = 0;
848 int i;
849
850 node = rb_first(&self->rb_root);
851 while (node) {
852 child = rb_entry(node, struct callchain_node, rb_node);
853
854 /*
855 * The depth mask manages the output of pipes that show
856 * the depth. We don't want to keep the pipes of the current
857 * level for the last child of this depth
858 */
859 next = rb_next(node);
860 if (!next)
861 new_depth_mask &= ~(1 << (depth - 1));
862
863 /*
864 * But we keep the older depth mask for the line seperator
865 * to keep the level link until we reach the last child
866 */
867 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask);
868 i = 0;
869 list_for_each_entry(chain, &child->val, list) {
870 if (chain->ip >= PERF_CONTEXT_MAX)
871 continue;
872 ret += ipchain__fprintf_graph(fp, chain, depth,
873 new_depth_mask, i++,
874 total_samples,
875 child->cumul_hit);
876 }
877 ret += callchain__fprintf_graph(fp, child, total_samples,
878 depth + 1,
879 new_depth_mask | (1 << depth));
880 node = next;
881 }
882
883 return ret;
884 }
885
886 static size_t
887 callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
888 u64 total_samples)
889 {
890 struct callchain_list *chain;
891 size_t ret = 0;
892
893 if (!self)
894 return 0;
895
896 ret += callchain__fprintf_flat(fp, self->parent, total_samples);
897
898
899 list_for_each_entry(chain, &self->val, list) {
900 if (chain->ip >= PERF_CONTEXT_MAX)
901 continue;
902 if (chain->sym)
903 ret += fprintf(fp, " %s\n", chain->sym->name);
904 else
905 ret += fprintf(fp, " %p\n",
906 (void *)(long)chain->ip);
907 }
908
909 return ret;
910 }
911
912 static size_t
913 hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
914 u64 total_samples)
915 {
916 struct rb_node *rb_node;
917 struct callchain_node *chain;
918 size_t ret = 0;
919
920 rb_node = rb_first(&self->sorted_chain);
921 while (rb_node) {
922 double percent;
923
924 chain = rb_entry(rb_node, struct callchain_node, rb_node);
925 percent = chain->hit * 100.0 / total_samples;
926 if (callchain_mode == FLAT) {
927 ret += percent_color_fprintf(fp, " %6.2f%%\n",
928 percent);
929 ret += callchain__fprintf_flat(fp, chain, total_samples);
930 } else if (callchain_mode == GRAPH) {
931 ret += callchain__fprintf_graph(fp, chain,
932 total_samples, 1, 1);
933 }
934 ret += fprintf(fp, "\n");
935 rb_node = rb_next(rb_node);
936 }
937
938 return ret;
939 }
940
941
942 static size_t
943 hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
944 {
945 struct sort_entry *se;
946 size_t ret;
947
948 if (exclude_other && !self->parent)
949 return 0;
950
951 if (total_samples)
952 ret = percent_color_fprintf(fp, " %6.2f%%",
953 (self->count * 100.0) / total_samples);
954 else
955 ret = fprintf(fp, "%12Ld ", self->count);
956
957 list_for_each_entry(se, &hist_entry__sort_list, list) {
958 if (exclude_other && (se == &sort_parent))
959 continue;
960
961 fprintf(fp, " ");
962 ret += se->print(fp, self);
963 }
964
965 ret += fprintf(fp, "\n");
966
967 if (callchain)
968 hist_entry_callchain__fprintf(fp, self, total_samples);
969
970 return ret;
971 }
972
973 /*
974 *
975 */
976
977 static struct symbol *
978 resolve_symbol(struct thread *thread, struct map **mapp,
979 struct dso **dsop, u64 *ipp)
980 {
981 struct dso *dso = dsop ? *dsop : NULL;
982 struct map *map = mapp ? *mapp : NULL;
983 u64 ip = *ipp;
984
985 if (!thread)
986 return NULL;
987
988 if (dso)
989 goto got_dso;
990
991 if (map)
992 goto got_map;
993
994 map = thread__find_map(thread, ip);
995 if (map != NULL) {
996 if (mapp)
997 *mapp = map;
998 got_map:
999 ip = map->map_ip(map, ip);
1000
1001 dso = map->dso;
1002 } else {
1003 /*
1004 * If this is outside of all known maps,
1005 * and is a negative address, try to look it
1006 * up in the kernel dso, as it might be a
1007 * vsyscall (which executes in user-mode):
1008 */
1009 if ((long long)ip < 0)
1010 dso = kernel_dso;
1011 }
1012 dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
1013 dprintf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
1014 *ipp = ip;
1015
1016 if (dsop)
1017 *dsop = dso;
1018
1019 if (!dso)
1020 return NULL;
1021 got_dso:
1022 return dso->find_symbol(dso, ip);
1023 }
1024
1025 static int call__match(struct symbol *sym)
1026 {
1027 if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
1028 return 1;
1029
1030 return 0;
1031 }
1032
1033 static struct symbol **
1034 resolve_callchain(struct thread *thread, struct map *map __used,
1035 struct ip_callchain *chain, struct hist_entry *entry)
1036 {
1037 u64 context = PERF_CONTEXT_MAX;
1038 struct symbol **syms = NULL;
1039 unsigned int i;
1040
1041 if (callchain) {
1042 syms = calloc(chain->nr, sizeof(*syms));
1043 if (!syms) {
1044 fprintf(stderr, "Can't allocate memory for symbols\n");
1045 exit(-1);
1046 }
1047 }
1048
1049 for (i = 0; i < chain->nr; i++) {
1050 u64 ip = chain->ips[i];
1051 struct dso *dso = NULL;
1052 struct symbol *sym;
1053
1054 if (ip >= PERF_CONTEXT_MAX) {
1055 context = ip;
1056 continue;
1057 }
1058
1059 switch (context) {
1060 case PERF_CONTEXT_HV:
1061 dso = hypervisor_dso;
1062 break;
1063 case PERF_CONTEXT_KERNEL:
1064 dso = kernel_dso;
1065 break;
1066 default:
1067 break;
1068 }
1069
1070 sym = resolve_symbol(thread, NULL, &dso, &ip);
1071
1072 if (sym) {
1073 if (sort__has_parent && call__match(sym) &&
1074 !entry->parent)
1075 entry->parent = sym;
1076 if (!callchain)
1077 break;
1078 syms[i] = sym;
1079 }
1080 }
1081
1082 return syms;
1083 }
1084
1085 /*
1086 * collect histogram counts
1087 */
1088
1089 static int
1090 hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
1091 struct symbol *sym, u64 ip, struct ip_callchain *chain,
1092 char level, u64 count)
1093 {
1094 struct rb_node **p = &hist.rb_node;
1095 struct rb_node *parent = NULL;
1096 struct hist_entry *he;
1097 struct symbol **syms = NULL;
1098 struct hist_entry entry = {
1099 .thread = thread,
1100 .map = map,
1101 .dso = dso,
1102 .sym = sym,
1103 .ip = ip,
1104 .level = level,
1105 .count = count,
1106 .parent = NULL,
1107 .sorted_chain = RB_ROOT
1108 };
1109 int cmp;
1110
1111 if ((sort__has_parent || callchain) && chain)
1112 syms = resolve_callchain(thread, map, chain, &entry);
1113
1114 while (*p != NULL) {
1115 parent = *p;
1116 he = rb_entry(parent, struct hist_entry, rb_node);
1117
1118 cmp = hist_entry__cmp(&entry, he);
1119
1120 if (!cmp) {
1121 he->count += count;
1122 if (callchain) {
1123 append_chain(&he->callchain, chain, syms);
1124 free(syms);
1125 }
1126 return 0;
1127 }
1128
1129 if (cmp < 0)
1130 p = &(*p)->rb_left;
1131 else
1132 p = &(*p)->rb_right;
1133 }
1134
1135 he = malloc(sizeof(*he));
1136 if (!he)
1137 return -ENOMEM;
1138 *he = entry;
1139 if (callchain) {
1140 callchain_init(&he->callchain);
1141 append_chain(&he->callchain, chain, syms);
1142 free(syms);
1143 }
1144 rb_link_node(&he->rb_node, parent, p);
1145 rb_insert_color(&he->rb_node, &hist);
1146
1147 return 0;
1148 }
1149
1150 static void hist_entry__free(struct hist_entry *he)
1151 {
1152 free(he);
1153 }
1154
1155 /*
1156 * collapse the histogram
1157 */
1158
1159 static struct rb_root collapse_hists;
1160
1161 static void collapse__insert_entry(struct hist_entry *he)
1162 {
1163 struct rb_node **p = &collapse_hists.rb_node;
1164 struct rb_node *parent = NULL;
1165 struct hist_entry *iter;
1166 int64_t cmp;
1167
1168 while (*p != NULL) {
1169 parent = *p;
1170 iter = rb_entry(parent, struct hist_entry, rb_node);
1171
1172 cmp = hist_entry__collapse(iter, he);
1173
1174 if (!cmp) {
1175 iter->count += he->count;
1176 hist_entry__free(he);
1177 return;
1178 }
1179
1180 if (cmp < 0)
1181 p = &(*p)->rb_left;
1182 else
1183 p = &(*p)->rb_right;
1184 }
1185
1186 rb_link_node(&he->rb_node, parent, p);
1187 rb_insert_color(&he->rb_node, &collapse_hists);
1188 }
1189
1190 static void collapse__resort(void)
1191 {
1192 struct rb_node *next;
1193 struct hist_entry *n;
1194
1195 if (!sort__need_collapse)
1196 return;
1197
1198 next = rb_first(&hist);
1199 while (next) {
1200 n = rb_entry(next, struct hist_entry, rb_node);
1201 next = rb_next(&n->rb_node);
1202
1203 rb_erase(&n->rb_node, &hist);
1204 collapse__insert_entry(n);
1205 }
1206 }
1207
1208 /*
1209 * reverse the map, sort on count.
1210 */
1211
1212 static struct rb_root output_hists;
1213
1214 static void output__insert_entry(struct hist_entry *he, u64 min_callchain_hits)
1215 {
1216 struct rb_node **p = &output_hists.rb_node;
1217 struct rb_node *parent = NULL;
1218 struct hist_entry *iter;
1219
1220 if (callchain) {
1221 if (callchain_mode == FLAT)
1222 sort_chain_flat(&he->sorted_chain, &he->callchain,
1223 min_callchain_hits);
1224 else if (callchain_mode == GRAPH)
1225 sort_chain_graph(&he->sorted_chain, &he->callchain,
1226 min_callchain_hits);
1227 }
1228
1229 while (*p != NULL) {
1230 parent = *p;
1231 iter = rb_entry(parent, struct hist_entry, rb_node);
1232
1233 if (he->count > iter->count)
1234 p = &(*p)->rb_left;
1235 else
1236 p = &(*p)->rb_right;
1237 }
1238
1239 rb_link_node(&he->rb_node, parent, p);
1240 rb_insert_color(&he->rb_node, &output_hists);
1241 }
1242
1243 static void output__resort(u64 total_samples)
1244 {
1245 struct rb_node *next;
1246 struct hist_entry *n;
1247 struct rb_root *tree = &hist;
1248 u64 min_callchain_hits;
1249
1250 min_callchain_hits = total_samples * (callchain_min_percent / 100);
1251
1252 if (sort__need_collapse)
1253 tree = &collapse_hists;
1254
1255 next = rb_first(tree);
1256
1257 while (next) {
1258 n = rb_entry(next, struct hist_entry, rb_node);
1259 next = rb_next(&n->rb_node);
1260
1261 rb_erase(&n->rb_node, tree);
1262 output__insert_entry(n, min_callchain_hits);
1263 }
1264 }
1265
1266 static size_t output__fprintf(FILE *fp, u64 total_samples)
1267 {
1268 struct hist_entry *pos;
1269 struct sort_entry *se;
1270 struct rb_node *nd;
1271 size_t ret = 0;
1272
1273 fprintf(fp, "\n");
1274 fprintf(fp, "#\n");
1275 fprintf(fp, "# (%Ld samples)\n", (u64)total_samples);
1276 fprintf(fp, "#\n");
1277
1278 fprintf(fp, "# Overhead");
1279 list_for_each_entry(se, &hist_entry__sort_list, list) {
1280 if (exclude_other && (se == &sort_parent))
1281 continue;
1282 fprintf(fp, " %s", se->header);
1283 }
1284 fprintf(fp, "\n");
1285
1286 fprintf(fp, "# ........");
1287 list_for_each_entry(se, &hist_entry__sort_list, list) {
1288 unsigned int i;
1289
1290 if (exclude_other && (se == &sort_parent))
1291 continue;
1292
1293 fprintf(fp, " ");
1294 for (i = 0; i < strlen(se->header); i++)
1295 fprintf(fp, ".");
1296 }
1297 fprintf(fp, "\n");
1298
1299 fprintf(fp, "#\n");
1300
1301 for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
1302 pos = rb_entry(nd, struct hist_entry, rb_node);
1303 ret += hist_entry__fprintf(fp, pos, total_samples);
1304 }
1305
1306 if (sort_order == default_sort_order &&
1307 parent_pattern == default_parent_pattern) {
1308 fprintf(fp, "#\n");
1309 fprintf(fp, "# (For more details, try: perf report --sort comm,dso,symbol)\n");
1310 fprintf(fp, "#\n");
1311 }
1312 fprintf(fp, "\n");
1313
1314 return ret;
1315 }
1316
1317 static void register_idle_thread(void)
1318 {
1319 struct thread *thread = threads__findnew(0);
1320
1321 if (thread == NULL ||
1322 thread__set_comm(thread, "[idle]")) {
1323 fprintf(stderr, "problem inserting idle task.\n");
1324 exit(-1);
1325 }
1326 }
1327
1328 static unsigned long total = 0,
1329 total_mmap = 0,
1330 total_comm = 0,
1331 total_fork = 0,
1332 total_unknown = 0,
1333 total_lost = 0;
1334
1335 static int validate_chain(struct ip_callchain *chain, event_t *event)
1336 {
1337 unsigned int chain_size;
1338
1339 chain_size = event->header.size;
1340 chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
1341
1342 if (chain->nr*sizeof(u64) > chain_size)
1343 return -1;
1344
1345 return 0;
1346 }
1347
1348 static int
1349 process_sample_event(event_t *event, unsigned long offset, unsigned long head)
1350 {
1351 char level;
1352 int show = 0;
1353 struct dso *dso = NULL;
1354 struct thread *thread = threads__findnew(event->ip.pid);
1355 u64 ip = event->ip.ip;
1356 u64 period = 1;
1357 struct map *map = NULL;
1358 void *more_data = event->ip.__more_data;
1359 struct ip_callchain *chain = NULL;
1360 int cpumode;
1361
1362 if (sample_type & PERF_SAMPLE_PERIOD) {
1363 period = *(u64 *)more_data;
1364 more_data += sizeof(u64);
1365 }
1366
1367 dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d: %p period: %Ld\n",
1368 (void *)(offset + head),
1369 (void *)(long)(event->header.size),
1370 event->header.misc,
1371 event->ip.pid,
1372 (void *)(long)ip,
1373 (long long)period);
1374
1375 if (sample_type & PERF_SAMPLE_CALLCHAIN) {
1376 unsigned int i;
1377
1378 chain = (void *)more_data;
1379
1380 dprintf("... chain: nr:%Lu\n", chain->nr);
1381
1382 if (validate_chain(chain, event) < 0) {
1383 eprintf("call-chain problem with event, skipping it.\n");
1384 return 0;
1385 }
1386
1387 if (dump_trace) {
1388 for (i = 0; i < chain->nr; i++)
1389 dprintf("..... %2d: %016Lx\n", i, chain->ips[i]);
1390 }
1391 }
1392
1393 dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
1394
1395 if (thread == NULL) {
1396 eprintf("problem processing %d event, skipping it.\n",
1397 event->header.type);
1398 return -1;
1399 }
1400
1401 if (comm_list && !strlist__has_entry(comm_list, thread->comm))
1402 return 0;
1403
1404 cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
1405
1406 if (cpumode == PERF_EVENT_MISC_KERNEL) {
1407 show = SHOW_KERNEL;
1408 level = 'k';
1409
1410 dso = kernel_dso;
1411
1412 dprintf(" ...... dso: %s\n", dso->name);
1413
1414 } else if (cpumode == PERF_EVENT_MISC_USER) {
1415
1416 show = SHOW_USER;
1417 level = '.';
1418
1419 } else {
1420 show = SHOW_HV;
1421 level = 'H';
1422
1423 dso = hypervisor_dso;
1424
1425 dprintf(" ...... dso: [hypervisor]\n");
1426 }
1427
1428 if (show & show_mask) {
1429 struct symbol *sym = resolve_symbol(thread, &map, &dso, &ip);
1430
1431 if (dso_list && dso && dso->name && !strlist__has_entry(dso_list, dso->name))
1432 return 0;
1433
1434 if (sym_list && sym && !strlist__has_entry(sym_list, sym->name))
1435 return 0;
1436
1437 if (hist_entry__add(thread, map, dso, sym, ip, chain, level, period)) {
1438 eprintf("problem incrementing symbol count, skipping event\n");
1439 return -1;
1440 }
1441 }
1442 total += period;
1443
1444 return 0;
1445 }
1446
1447 static int
1448 process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
1449 {
1450 struct thread *thread = threads__findnew(event->mmap.pid);
1451 struct map *map = map__new(&event->mmap);
1452
1453 dprintf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
1454 (void *)(offset + head),
1455 (void *)(long)(event->header.size),
1456 event->mmap.pid,
1457 (void *)(long)event->mmap.start,
1458 (void *)(long)event->mmap.len,
1459 (void *)(long)event->mmap.pgoff,
1460 event->mmap.filename);
1461
1462 if (thread == NULL || map == NULL) {
1463 dprintf("problem processing PERF_EVENT_MMAP, skipping event.\n");
1464 return 0;
1465 }
1466
1467 thread__insert_map(thread, map);
1468 total_mmap++;
1469
1470 return 0;
1471 }
1472
1473 static int
1474 process_comm_event(event_t *event, unsigned long offset, unsigned long head)
1475 {
1476 struct thread *thread = threads__findnew(event->comm.pid);
1477
1478 dprintf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
1479 (void *)(offset + head),
1480 (void *)(long)(event->header.size),
1481 event->comm.comm, event->comm.pid);
1482
1483 if (thread == NULL ||
1484 thread__set_comm(thread, event->comm.comm)) {
1485 dprintf("problem processing PERF_EVENT_COMM, skipping event.\n");
1486 return -1;
1487 }
1488 total_comm++;
1489
1490 return 0;
1491 }
1492
1493 static int
1494 process_fork_event(event_t *event, unsigned long offset, unsigned long head)
1495 {
1496 struct thread *thread = threads__findnew(event->fork.pid);
1497 struct thread *parent = threads__findnew(event->fork.ppid);
1498
1499 dprintf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
1500 (void *)(offset + head),
1501 (void *)(long)(event->header.size),
1502 event->fork.pid, event->fork.ppid);
1503
1504 if (!thread || !parent || thread__fork(thread, parent)) {
1505 dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
1506 return -1;
1507 }
1508 total_fork++;
1509
1510 return 0;
1511 }
1512
1513 static int
1514 process_period_event(event_t *event, unsigned long offset, unsigned long head)
1515 {
1516 dprintf("%p [%p]: PERF_EVENT_PERIOD: time:%Ld, id:%Ld: period:%Ld\n",
1517 (void *)(offset + head),
1518 (void *)(long)(event->header.size),
1519 event->period.time,
1520 event->period.id,
1521 event->period.sample_period);
1522
1523 return 0;
1524 }
1525
1526 static int
1527 process_lost_event(event_t *event, unsigned long offset, unsigned long head)
1528 {
1529 dprintf("%p [%p]: PERF_EVENT_LOST: id:%Ld: lost:%Ld\n",
1530 (void *)(offset + head),
1531 (void *)(long)(event->header.size),
1532 event->lost.id,
1533 event->lost.lost);
1534
1535 total_lost += event->lost.lost;
1536
1537 return 0;
1538 }
1539
1540 static void trace_event(event_t *event)
1541 {
1542 unsigned char *raw_event = (void *)event;
1543 char *color = PERF_COLOR_BLUE;
1544 int i, j;
1545
1546 if (!dump_trace)
1547 return;
1548
1549 dprintf(".");
1550 cdprintf("\n. ... raw event: size %d bytes\n", event->header.size);
1551
1552 for (i = 0; i < event->header.size; i++) {
1553 if ((i & 15) == 0) {
1554 dprintf(".");
1555 cdprintf(" %04x: ", i);
1556 }
1557
1558 cdprintf(" %02x", raw_event[i]);
1559
1560 if (((i & 15) == 15) || i == event->header.size-1) {
1561 cdprintf(" ");
1562 for (j = 0; j < 15-(i & 15); j++)
1563 cdprintf(" ");
1564 for (j = 0; j < (i & 15); j++) {
1565 if (isprint(raw_event[i-15+j]))
1566 cdprintf("%c", raw_event[i-15+j]);
1567 else
1568 cdprintf(".");
1569 }
1570 cdprintf("\n");
1571 }
1572 }
1573 dprintf(".\n");
1574 }
1575
1576 static int
1577 process_read_event(event_t *event, unsigned long offset, unsigned long head)
1578 {
1579 dprintf("%p [%p]: PERF_EVENT_READ: %d %d %Lu\n",
1580 (void *)(offset + head),
1581 (void *)(long)(event->header.size),
1582 event->read.pid,
1583 event->read.tid,
1584 event->read.value);
1585
1586 return 0;
1587 }
1588
1589 static int
1590 process_event(event_t *event, unsigned long offset, unsigned long head)
1591 {
1592 trace_event(event);
1593
1594 switch (event->header.type) {
1595 case PERF_EVENT_SAMPLE:
1596 return process_sample_event(event, offset, head);
1597
1598 case PERF_EVENT_MMAP:
1599 return process_mmap_event(event, offset, head);
1600
1601 case PERF_EVENT_COMM:
1602 return process_comm_event(event, offset, head);
1603
1604 case PERF_EVENT_FORK:
1605 return process_fork_event(event, offset, head);
1606
1607 case PERF_EVENT_PERIOD:
1608 return process_period_event(event, offset, head);
1609
1610 case PERF_EVENT_LOST:
1611 return process_lost_event(event, offset, head);
1612
1613 case PERF_EVENT_READ:
1614 return process_read_event(event, offset, head);
1615
1616 /*
1617 * We dont process them right now but they are fine:
1618 */
1619
1620 case PERF_EVENT_THROTTLE:
1621 case PERF_EVENT_UNTHROTTLE:
1622 return 0;
1623
1624 default:
1625 return -1;
1626 }
1627
1628 return 0;
1629 }
1630
1631 static struct perf_header *header;
1632
1633 static u64 perf_header__sample_type(void)
1634 {
1635 u64 sample_type = 0;
1636 int i;
1637
1638 for (i = 0; i < header->attrs; i++) {
1639 struct perf_header_attr *attr = header->attr[i];
1640
1641 if (!sample_type)
1642 sample_type = attr->attr.sample_type;
1643 else if (sample_type != attr->attr.sample_type)
1644 die("non matching sample_type");
1645 }
1646
1647 return sample_type;
1648 }
1649
1650 static int __cmd_report(void)
1651 {
1652 int ret, rc = EXIT_FAILURE;
1653 unsigned long offset = 0;
1654 unsigned long head, shift;
1655 struct stat stat;
1656 event_t *event;
1657 uint32_t size;
1658 char *buf;
1659
1660 register_idle_thread();
1661
1662 input = open(input_name, O_RDONLY);
1663 if (input < 0) {
1664 fprintf(stderr, " failed to open file: %s", input_name);
1665 if (!strcmp(input_name, "perf.data"))
1666 fprintf(stderr, " (try 'perf record' first)");
1667 fprintf(stderr, "\n");
1668 exit(-1);
1669 }
1670
1671 ret = fstat(input, &stat);
1672 if (ret < 0) {
1673 perror("failed to stat file");
1674 exit(-1);
1675 }
1676
1677 if (!stat.st_size) {
1678 fprintf(stderr, "zero-sized file, nothing to do!\n");
1679 exit(0);
1680 }
1681
1682 header = perf_header__read(input);
1683 head = header->data_offset;
1684
1685 sample_type = perf_header__sample_type();
1686
1687 if (sort__has_parent && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
1688 fprintf(stderr, "selected --sort parent, but no callchain data\n");
1689 exit(-1);
1690 }
1691
1692 if (load_kernel() < 0) {
1693 perror("failed to load kernel symbols");
1694 return EXIT_FAILURE;
1695 }
1696
1697 if (!full_paths) {
1698 if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
1699 perror("failed to get the current directory");
1700 return EXIT_FAILURE;
1701 }
1702 cwdlen = strlen(cwd);
1703 } else {
1704 cwd = NULL;
1705 cwdlen = 0;
1706 }
1707
1708 shift = page_size * (head / page_size);
1709 offset += shift;
1710 head -= shift;
1711
1712 remap:
1713 buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
1714 MAP_SHARED, input, offset);
1715 if (buf == MAP_FAILED) {
1716 perror("failed to mmap file");
1717 exit(-1);
1718 }
1719
1720 more:
1721 event = (event_t *)(buf + head);
1722
1723 size = event->header.size;
1724 if (!size)
1725 size = 8;
1726
1727 if (head + event->header.size >= page_size * mmap_window) {
1728 int ret;
1729
1730 shift = page_size * (head / page_size);
1731
1732 ret = munmap(buf, page_size * mmap_window);
1733 assert(ret == 0);
1734
1735 offset += shift;
1736 head -= shift;
1737 goto remap;
1738 }
1739
1740 size = event->header.size;
1741
1742 dprintf("\n%p [%p]: event: %d\n",
1743 (void *)(offset + head),
1744 (void *)(long)event->header.size,
1745 event->header.type);
1746
1747 if (!size || process_event(event, offset, head) < 0) {
1748
1749 dprintf("%p [%p]: skipping unknown header type: %d\n",
1750 (void *)(offset + head),
1751 (void *)(long)(event->header.size),
1752 event->header.type);
1753
1754 total_unknown++;
1755
1756 /*
1757 * assume we lost track of the stream, check alignment, and
1758 * increment a single u64 in the hope to catch on again 'soon'.
1759 */
1760
1761 if (unlikely(head & 7))
1762 head &= ~7ULL;
1763
1764 size = 8;
1765 }
1766
1767 head += size;
1768
1769 if (offset + head >= header->data_offset + header->data_size)
1770 goto done;
1771
1772 if (offset + head < (unsigned long)stat.st_size)
1773 goto more;
1774
1775 done:
1776 rc = EXIT_SUCCESS;
1777 close(input);
1778
1779 dprintf(" IP events: %10ld\n", total);
1780 dprintf(" mmap events: %10ld\n", total_mmap);
1781 dprintf(" comm events: %10ld\n", total_comm);
1782 dprintf(" fork events: %10ld\n", total_fork);
1783 dprintf(" lost events: %10ld\n", total_lost);
1784 dprintf(" unknown events: %10ld\n", total_unknown);
1785
1786 if (dump_trace)
1787 return 0;
1788
1789 if (verbose >= 3)
1790 threads__fprintf(stdout);
1791
1792 if (verbose >= 2)
1793 dsos__fprintf(stdout);
1794
1795 collapse__resort();
1796 output__resort(total);
1797 output__fprintf(stdout, total);
1798
1799 return rc;
1800 }
1801
1802 static int
1803 parse_callchain_opt(const struct option *opt __used, const char *arg,
1804 int unset __used)
1805 {
1806 char *tok;
1807 char *endptr;
1808
1809 callchain = 1;
1810
1811 if (!arg)
1812 return 0;
1813
1814 tok = strtok((char *)arg, ",");
1815 if (!tok)
1816 return -1;
1817
1818 /* get the output mode */
1819 if (!strncmp(tok, "graph", strlen(arg)))
1820 callchain_mode = GRAPH;
1821
1822 else if (!strncmp(tok, "flat", strlen(arg)))
1823 callchain_mode = FLAT;
1824 else
1825 return -1;
1826
1827 /* get the min percentage */
1828 tok = strtok(NULL, ",");
1829 if (!tok)
1830 return 0;
1831
1832 callchain_min_percent = strtod(tok, &endptr);
1833 if (tok == endptr)
1834 return -1;
1835
1836 return 0;
1837 }
1838
1839 static const char * const report_usage[] = {
1840 "perf report [<options>] <command>",
1841 NULL
1842 };
1843
1844 static const struct option options[] = {
1845 OPT_STRING('i', "input", &input_name, "file",
1846 "input file name"),
1847 OPT_BOOLEAN('v', "verbose", &verbose,
1848 "be more verbose (show symbol address, etc)"),
1849 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1850 "dump raw trace in ASCII"),
1851 OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
1852 OPT_BOOLEAN('m', "modules", &modules,
1853 "load module symbols - WARNING: use only with -k and LIVE kernel"),
1854 OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1855 "sort by key(s): pid, comm, dso, symbol, parent"),
1856 OPT_BOOLEAN('P', "full-paths", &full_paths,
1857 "Don't shorten the pathnames taking into account the cwd"),
1858 OPT_STRING('p', "parent", &parent_pattern, "regex",
1859 "regex filter to identify parent, see: '--sort parent'"),
1860 OPT_BOOLEAN('x', "exclude-other", &exclude_other,
1861 "Only display entries with parent-match"),
1862 OPT_CALLBACK_DEFAULT('c', "callchain", NULL, "output_type,min_percent",
1863 "Display callchains using output_type and min percent threshold. "
1864 "Default: flat,0", &parse_callchain_opt, "flat,100"),
1865 OPT_STRING('d', "dsos", &dso_list_str, "dso[,dso...]",
1866 "only consider symbols in these dsos"),
1867 OPT_STRING('C', "comms", &comm_list_str, "comm[,comm...]",
1868 "only consider symbols in these comms"),
1869 OPT_STRING('S', "symbols", &sym_list_str, "symbol[,symbol...]",
1870 "only consider these symbols"),
1871 OPT_END()
1872 };
1873
1874 static void setup_sorting(void)
1875 {
1876 char *tmp, *tok, *str = strdup(sort_order);
1877
1878 for (tok = strtok_r(str, ", ", &tmp);
1879 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1880 if (sort_dimension__add(tok) < 0) {
1881 error("Unknown --sort key: `%s'", tok);
1882 usage_with_options(report_usage, options);
1883 }
1884 }
1885
1886 free(str);
1887 }
1888
1889 static void setup_list(struct strlist **list, const char *list_str,
1890 const char *list_name)
1891 {
1892 if (list_str) {
1893 *list = strlist__new(true, list_str);
1894 if (!*list) {
1895 fprintf(stderr, "problems parsing %s list\n",
1896 list_name);
1897 exit(129);
1898 }
1899 }
1900 }
1901
1902 int cmd_report(int argc, const char **argv, const char *prefix __used)
1903 {
1904 symbol__init();
1905
1906 page_size = getpagesize();
1907
1908 argc = parse_options(argc, argv, options, report_usage, 0);
1909
1910 setup_sorting();
1911
1912 if (parent_pattern != default_parent_pattern)
1913 sort_dimension__add("parent");
1914 else
1915 exclude_other = 0;
1916
1917 /*
1918 * Any (unrecognized) arguments left?
1919 */
1920 if (argc)
1921 usage_with_options(report_usage, options);
1922
1923 setup_list(&dso_list, dso_list_str, "dso");
1924 setup_list(&comm_list, comm_list_str, "comm");
1925 setup_list(&sym_list, sym_list_str, "symbol");
1926
1927 setup_pager();
1928
1929 return __cmd_report();
1930 }
Verdex Pro support