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