9cbdcbc4cd5697408584c12809d839f66ed19b0d
[linux-2.6.git] / tools / perf / builtin-report.c
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 #include "util/values.h"
21
22 #include "perf.h"
23 #include "util/debug.h"
24 #include "util/header.h"
25 #include "util/session.h"
26
27 #include "util/parse-options.h"
28 #include "util/parse-events.h"
29
30 #include "util/thread.h"
31 #include "util/sort.h"
32 #include "util/hist.h"
33
34 static char             const *input_name = "perf.data";
35
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
40 static int              force;
41
42 static int              show_nr_samples;
43
44 static int              show_threads;
45 static struct perf_read_values  show_threads_values;
46
47 static char             default_pretty_printing_style[] = "normal";
48 static char             *pretty_printing_style = default_pretty_printing_style;
49
50 static int              exclude_other = 1;
51
52 static char             callchain_default_opt[] = "fractal,0.5";
53
54 static u64              sample_type;
55
56 struct symbol_conf      symbol_conf;
57
58
59 static size_t
60 callchain__fprintf_left_margin(FILE *fp, int left_margin)
61 {
62         int i;
63         int ret;
64
65         ret = fprintf(fp, "            ");
66
67         for (i = 0; i < left_margin; i++)
68                 ret += fprintf(fp, " ");
69
70         return ret;
71 }
72
73 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
74                                           int left_margin)
75 {
76         int i;
77         size_t ret = 0;
78
79         ret += callchain__fprintf_left_margin(fp, left_margin);
80
81         for (i = 0; i < depth; i++)
82                 if (depth_mask & (1 << i))
83                         ret += fprintf(fp, "|          ");
84                 else
85                         ret += fprintf(fp, "           ");
86
87         ret += fprintf(fp, "\n");
88
89         return ret;
90 }
91 static size_t
92 ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
93                        int depth_mask, int count, u64 total_samples,
94                        int hits, int left_margin)
95 {
96         int i;
97         size_t ret = 0;
98
99         ret += callchain__fprintf_left_margin(fp, left_margin);
100         for (i = 0; i < depth; i++) {
101                 if (depth_mask & (1 << i))
102                         ret += fprintf(fp, "|");
103                 else
104                         ret += fprintf(fp, " ");
105                 if (!count && i == depth - 1) {
106                         double percent;
107
108                         percent = hits * 100.0 / total_samples;
109                         ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
110                 } else
111                         ret += fprintf(fp, "%s", "          ");
112         }
113         if (chain->sym)
114                 ret += fprintf(fp, "%s\n", chain->sym->name);
115         else
116                 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
117
118         return ret;
119 }
120
121 static struct symbol *rem_sq_bracket;
122 static struct callchain_list rem_hits;
123
124 static void init_rem_hits(void)
125 {
126         rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
127         if (!rem_sq_bracket) {
128                 fprintf(stderr, "Not enough memory to display remaining hits\n");
129                 return;
130         }
131
132         strcpy(rem_sq_bracket->name, "[...]");
133         rem_hits.sym = rem_sq_bracket;
134 }
135
136 static size_t
137 __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
138                            u64 total_samples, int depth, int depth_mask,
139                            int left_margin)
140 {
141         struct rb_node *node, *next;
142         struct callchain_node *child;
143         struct callchain_list *chain;
144         int new_depth_mask = depth_mask;
145         u64 new_total;
146         u64 remaining;
147         size_t ret = 0;
148         int i;
149
150         if (callchain_param.mode == CHAIN_GRAPH_REL)
151                 new_total = self->children_hit;
152         else
153                 new_total = total_samples;
154
155         remaining = new_total;
156
157         node = rb_first(&self->rb_root);
158         while (node) {
159                 u64 cumul;
160
161                 child = rb_entry(node, struct callchain_node, rb_node);
162                 cumul = cumul_hits(child);
163                 remaining -= cumul;
164
165                 /*
166                  * The depth mask manages the output of pipes that show
167                  * the depth. We don't want to keep the pipes of the current
168                  * level for the last child of this depth.
169                  * Except if we have remaining filtered hits. They will
170                  * supersede the last child
171                  */
172                 next = rb_next(node);
173                 if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
174                         new_depth_mask &= ~(1 << (depth - 1));
175
176                 /*
177                  * But we keep the older depth mask for the line seperator
178                  * to keep the level link until we reach the last child
179                  */
180                 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
181                                                    left_margin);
182                 i = 0;
183                 list_for_each_entry(chain, &child->val, list) {
184                         if (chain->ip >= PERF_CONTEXT_MAX)
185                                 continue;
186                         ret += ipchain__fprintf_graph(fp, chain, depth,
187                                                       new_depth_mask, i++,
188                                                       new_total,
189                                                       cumul,
190                                                       left_margin);
191                 }
192                 ret += __callchain__fprintf_graph(fp, child, new_total,
193                                                   depth + 1,
194                                                   new_depth_mask | (1 << depth),
195                                                   left_margin);
196                 node = next;
197         }
198
199         if (callchain_param.mode == CHAIN_GRAPH_REL &&
200                 remaining && remaining != new_total) {
201
202                 if (!rem_sq_bracket)
203                         return ret;
204
205                 new_depth_mask &= ~(1 << (depth - 1));
206
207                 ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
208                                               new_depth_mask, 0, new_total,
209                                               remaining, left_margin);
210         }
211
212         return ret;
213 }
214
215
216 static size_t
217 callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
218                          u64 total_samples, int left_margin)
219 {
220         struct callchain_list *chain;
221         bool printed = false;
222         int i = 0;
223         int ret = 0;
224
225         list_for_each_entry(chain, &self->val, list) {
226                 if (chain->ip >= PERF_CONTEXT_MAX)
227                         continue;
228
229                 if (!i++ && sort__first_dimension == SORT_SYM)
230                         continue;
231
232                 if (!printed) {
233                         ret += callchain__fprintf_left_margin(fp, left_margin);
234                         ret += fprintf(fp, "|\n");
235                         ret += callchain__fprintf_left_margin(fp, left_margin);
236                         ret += fprintf(fp, "---");
237
238                         left_margin += 3;
239                         printed = true;
240                 } else
241                         ret += callchain__fprintf_left_margin(fp, left_margin);
242
243                 if (chain->sym)
244                         ret += fprintf(fp, " %s\n", chain->sym->name);
245                 else
246                         ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
247         }
248
249         ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
250
251         return ret;
252 }
253
254 static size_t
255 callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
256                         u64 total_samples)
257 {
258         struct callchain_list *chain;
259         size_t ret = 0;
260
261         if (!self)
262                 return 0;
263
264         ret += callchain__fprintf_flat(fp, self->parent, total_samples);
265
266
267         list_for_each_entry(chain, &self->val, list) {
268                 if (chain->ip >= PERF_CONTEXT_MAX)
269                         continue;
270                 if (chain->sym)
271                         ret += fprintf(fp, "                %s\n", chain->sym->name);
272                 else
273                         ret += fprintf(fp, "                %p\n",
274                                         (void *)(long)chain->ip);
275         }
276
277         return ret;
278 }
279
280 static size_t
281 hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
282                               u64 total_samples, int left_margin)
283 {
284         struct rb_node *rb_node;
285         struct callchain_node *chain;
286         size_t ret = 0;
287
288         rb_node = rb_first(&self->sorted_chain);
289         while (rb_node) {
290                 double percent;
291
292                 chain = rb_entry(rb_node, struct callchain_node, rb_node);
293                 percent = chain->hit * 100.0 / total_samples;
294                 switch (callchain_param.mode) {
295                 case CHAIN_FLAT:
296                         ret += percent_color_fprintf(fp, "           %6.2f%%\n",
297                                                      percent);
298                         ret += callchain__fprintf_flat(fp, chain, total_samples);
299                         break;
300                 case CHAIN_GRAPH_ABS: /* Falldown */
301                 case CHAIN_GRAPH_REL:
302                         ret += callchain__fprintf_graph(fp, chain, total_samples,
303                                                         left_margin);
304                 case CHAIN_NONE:
305                 default:
306                         break;
307                 }
308                 ret += fprintf(fp, "\n");
309                 rb_node = rb_next(rb_node);
310         }
311
312         return ret;
313 }
314
315 static size_t
316 hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
317 {
318         struct sort_entry *se;
319         size_t ret;
320
321         if (exclude_other && !self->parent)
322                 return 0;
323
324         if (total_samples)
325                 ret = percent_color_fprintf(fp,
326                                             field_sep ? "%.2f" : "   %6.2f%%",
327                                         (self->count * 100.0) / total_samples);
328         else
329                 ret = fprintf(fp, field_sep ? "%lld" : "%12lld ", self->count);
330
331         if (show_nr_samples) {
332                 if (field_sep)
333                         fprintf(fp, "%c%lld", *field_sep, self->count);
334                 else
335                         fprintf(fp, "%11lld", self->count);
336         }
337
338         list_for_each_entry(se, &hist_entry__sort_list, list) {
339                 if (se->elide)
340                         continue;
341
342                 fprintf(fp, "%s", field_sep ?: "  ");
343                 ret += se->print(fp, self, se->width ? *se->width : 0);
344         }
345
346         ret += fprintf(fp, "\n");
347
348         if (callchain) {
349                 int left_margin = 0;
350
351                 if (sort__first_dimension == SORT_COMM) {
352                         se = list_first_entry(&hist_entry__sort_list, typeof(*se),
353                                                 list);
354                         left_margin = se->width ? *se->width : 0;
355                         left_margin -= thread__comm_len(self->thread);
356                 }
357
358                 hist_entry_callchain__fprintf(fp, self, total_samples,
359                                               left_margin);
360         }
361
362         return ret;
363 }
364
365 /*
366  *
367  */
368
369 static void dso__calc_col_width(struct dso *self)
370 {
371         if (!col_width_list_str && !field_sep &&
372             (!dso_list || strlist__has_entry(dso_list, self->name))) {
373                 unsigned int slen = strlen(self->name);
374                 if (slen > dsos__col_width)
375                         dsos__col_width = slen;
376         }
377
378         self->slen_calculated = 1;
379 }
380
381 static void thread__comm_adjust(struct thread *self)
382 {
383         char *comm = self->comm;
384
385         if (!col_width_list_str && !field_sep &&
386             (!comm_list || strlist__has_entry(comm_list, comm))) {
387                 unsigned int slen = strlen(comm);
388
389                 if (slen > comms__col_width) {
390                         comms__col_width = slen;
391                         threads__col_width = slen + 6;
392                 }
393         }
394 }
395
396 static int thread__set_comm_adjust(struct thread *self, const char *comm)
397 {
398         int ret = thread__set_comm(self, comm);
399
400         if (ret)
401                 return ret;
402
403         thread__comm_adjust(self);
404
405         return 0;
406 }
407
408 static int call__match(struct symbol *sym)
409 {
410         if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
411                 return 1;
412
413         return 0;
414 }
415
416 static struct symbol **resolve_callchain(struct thread *thread,
417                                          struct perf_session *session,
418                                          struct ip_callchain *chain,
419                                          struct symbol **parent)
420 {
421         u8 cpumode = PERF_RECORD_MISC_USER;
422         struct symbol **syms = NULL;
423         unsigned int i;
424
425         if (callchain) {
426                 syms = calloc(chain->nr, sizeof(*syms));
427                 if (!syms) {
428                         fprintf(stderr, "Can't allocate memory for symbols\n");
429                         exit(-1);
430                 }
431         }
432
433         for (i = 0; i < chain->nr; i++) {
434                 u64 ip = chain->ips[i];
435                 struct addr_location al;
436
437                 if (ip >= PERF_CONTEXT_MAX) {
438                         switch (ip) {
439                         case PERF_CONTEXT_HV:
440                                 cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
441                         case PERF_CONTEXT_KERNEL:
442                                 cpumode = PERF_RECORD_MISC_KERNEL;      break;
443                         case PERF_CONTEXT_USER:
444                                 cpumode = PERF_RECORD_MISC_USER;        break;
445                         default:
446                                 break;
447                         }
448                         continue;
449                 }
450
451                 thread__find_addr_location(thread, session, cpumode,
452                                            MAP__FUNCTION, ip, &al, NULL);
453                 if (al.sym != NULL) {
454                         if (sort__has_parent && !*parent &&
455                             call__match(al.sym))
456                                 *parent = al.sym;
457                         if (!callchain)
458                                 break;
459                         syms[i] = al.sym;
460                 }
461         }
462
463         return syms;
464 }
465
466 /*
467  * collect histogram counts
468  */
469
470 static int hist_entry__add(struct addr_location *al,
471                            struct perf_session *session,
472                            struct ip_callchain *chain, u64 count)
473 {
474         struct symbol **syms = NULL, *parent = NULL;
475         bool hit;
476         struct hist_entry *he;
477
478         if ((sort__has_parent || callchain) && chain)
479                 syms = resolve_callchain(al->thread, session, chain, &parent);
480
481         he = __hist_entry__add(al, parent, count, &hit);
482         if (he == NULL)
483                 return -ENOMEM;
484
485         if (hit)
486                 he->count += count;
487
488         if (callchain) {
489                 if (!hit)
490                         callchain_init(&he->callchain);
491                 append_chain(&he->callchain, chain, syms);
492                 free(syms);
493         }
494
495         return 0;
496 }
497
498 static size_t output__fprintf(FILE *fp, u64 total_samples)
499 {
500         struct hist_entry *pos;
501         struct sort_entry *se;
502         struct rb_node *nd;
503         size_t ret = 0;
504         unsigned int width;
505         char *col_width = col_width_list_str;
506         int raw_printing_style;
507
508         raw_printing_style = !strcmp(pretty_printing_style, "raw");
509
510         init_rem_hits();
511
512         fprintf(fp, "# Samples: %Ld\n", (u64)total_samples);
513         fprintf(fp, "#\n");
514
515         fprintf(fp, "# Overhead");
516         if (show_nr_samples) {
517                 if (field_sep)
518                         fprintf(fp, "%cSamples", *field_sep);
519                 else
520                         fputs("  Samples  ", fp);
521         }
522         list_for_each_entry(se, &hist_entry__sort_list, list) {
523                 if (se->elide)
524                         continue;
525                 if (field_sep) {
526                         fprintf(fp, "%c%s", *field_sep, se->header);
527                         continue;
528                 }
529                 width = strlen(se->header);
530                 if (se->width) {
531                         if (col_width_list_str) {
532                                 if (col_width) {
533                                         *se->width = atoi(col_width);
534                                         col_width = strchr(col_width, ',');
535                                         if (col_width)
536                                                 ++col_width;
537                                 }
538                         }
539                         width = *se->width = max(*se->width, width);
540                 }
541                 fprintf(fp, "  %*s", width, se->header);
542         }
543         fprintf(fp, "\n");
544
545         if (field_sep)
546                 goto print_entries;
547
548         fprintf(fp, "# ........");
549         if (show_nr_samples)
550                 fprintf(fp, " ..........");
551         list_for_each_entry(se, &hist_entry__sort_list, list) {
552                 unsigned int i;
553
554                 if (se->elide)
555                         continue;
556
557                 fprintf(fp, "  ");
558                 if (se->width)
559                         width = *se->width;
560                 else
561                         width = strlen(se->header);
562                 for (i = 0; i < width; i++)
563                         fprintf(fp, ".");
564         }
565         fprintf(fp, "\n");
566
567         fprintf(fp, "#\n");
568
569 print_entries:
570         for (nd = rb_first(&hist); nd; nd = rb_next(nd)) {
571                 pos = rb_entry(nd, struct hist_entry, rb_node);
572                 ret += hist_entry__fprintf(fp, pos, total_samples);
573         }
574
575         if (sort_order == default_sort_order &&
576                         parent_pattern == default_parent_pattern) {
577                 fprintf(fp, "#\n");
578                 fprintf(fp, "# (For a higher level overview, try: perf report --sort comm,dso)\n");
579                 fprintf(fp, "#\n");
580         }
581         fprintf(fp, "\n");
582
583         free(rem_sq_bracket);
584
585         if (show_threads)
586                 perf_read_values_display(fp, &show_threads_values,
587                                          raw_printing_style);
588
589         return ret;
590 }
591
592 static int validate_chain(struct ip_callchain *chain, event_t *event)
593 {
594         unsigned int chain_size;
595
596         chain_size = event->header.size;
597         chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
598
599         if (chain->nr*sizeof(u64) > chain_size)
600                 return -1;
601
602         return 0;
603 }
604
605 static int process_sample_event(event_t *event, struct perf_session *session)
606 {
607         struct sample_data data;
608         int cpumode;
609         struct addr_location al;
610         struct thread *thread;
611
612         memset(&data, 0, sizeof(data));
613         data.period = 1;
614
615         event__parse_sample(event, sample_type, &data);
616
617         dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
618                 event->header.misc,
619                 data.pid, data.tid,
620                 (void *)(long)data.ip,
621                 (long long)data.period);
622
623         if (sample_type & PERF_SAMPLE_CALLCHAIN) {
624                 unsigned int i;
625
626                 dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
627
628                 if (validate_chain(data.callchain, event) < 0) {
629                         pr_debug("call-chain problem with event, "
630                                  "skipping it.\n");
631                         return 0;
632                 }
633
634                 if (dump_trace) {
635                         for (i = 0; i < data.callchain->nr; i++)
636                                 dump_printf("..... %2d: %016Lx\n",
637                                             i, data.callchain->ips[i]);
638                 }
639         }
640
641         thread = perf_session__findnew(session, data.pid);
642         if (thread == NULL) {
643                 pr_debug("problem processing %d event, skipping it.\n",
644                         event->header.type);
645                 return -1;
646         }
647
648         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
649
650         if (comm_list && !strlist__has_entry(comm_list, thread->comm))
651                 return 0;
652
653         cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
654
655         thread__find_addr_location(thread, session, cpumode,
656                                    MAP__FUNCTION, data.ip, &al, NULL);
657         /*
658          * We have to do this here as we may have a dso with no symbol hit that
659          * has a name longer than the ones with symbols sampled.
660          */
661         if (al.map && !sort_dso.elide && !al.map->dso->slen_calculated)
662                 dso__calc_col_width(al.map->dso);
663
664         if (dso_list &&
665             (!al.map || !al.map->dso ||
666              !(strlist__has_entry(dso_list, al.map->dso->short_name) ||
667                (al.map->dso->short_name != al.map->dso->long_name &&
668                 strlist__has_entry(dso_list, al.map->dso->long_name)))))
669                 return 0;
670
671         if (sym_list && al.sym && !strlist__has_entry(sym_list, al.sym->name))
672                 return 0;
673
674         if (hist_entry__add(&al, session, data.callchain, data.period)) {
675                 pr_debug("problem incrementing symbol count, skipping event\n");
676                 return -1;
677         }
678
679         event__stats.total += data.period;
680
681         return 0;
682 }
683
684 static int process_comm_event(event_t *event, struct perf_session *session)
685 {
686         struct thread *thread = perf_session__findnew(session, event->comm.pid);
687
688         dump_printf(": %s:%d\n", event->comm.comm, event->comm.pid);
689
690         if (thread == NULL ||
691             thread__set_comm_adjust(thread, event->comm.comm)) {
692                 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
693                 return -1;
694         }
695
696         return 0;
697 }
698
699 static int process_read_event(event_t *event, struct perf_session *session __used)
700 {
701         struct perf_event_attr *attr;
702
703         attr = perf_header__find_attr(event->read.id, &session->header);
704
705         if (show_threads) {
706                 const char *name = attr ? __event_name(attr->type, attr->config)
707                                    : "unknown";
708                 perf_read_values_add_value(&show_threads_values,
709                                            event->read.pid, event->read.tid,
710                                            event->read.id,
711                                            name,
712                                            event->read.value);
713         }
714
715         dump_printf(": %d %d %s %Lu\n", event->read.pid, event->read.tid,
716                     attr ? __event_name(attr->type, attr->config) : "FAIL",
717                     event->read.value);
718
719         return 0;
720 }
721
722 static int sample_type_check(u64 type)
723 {
724         sample_type = type;
725
726         if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
727                 if (sort__has_parent) {
728                         fprintf(stderr, "selected --sort parent, but no"
729                                         " callchain data. Did you call"
730                                         " perf record without -g?\n");
731                         return -1;
732                 }
733                 if (callchain) {
734                         fprintf(stderr, "selected -g but no callchain data."
735                                         " Did you call perf record without"
736                                         " -g?\n");
737                         return -1;
738                 }
739         } else if (callchain_param.mode != CHAIN_NONE && !callchain) {
740                         callchain = 1;
741                         if (register_callchain_param(&callchain_param) < 0) {
742                                 fprintf(stderr, "Can't register callchain"
743                                                 " params\n");
744                                 return -1;
745                         }
746         }
747
748         return 0;
749 }
750
751 static struct perf_event_ops event_ops = {
752         .process_sample_event   = process_sample_event,
753         .process_mmap_event     = event__process_mmap,
754         .process_comm_event     = process_comm_event,
755         .process_exit_event     = event__process_task,
756         .process_fork_event     = event__process_task,
757         .process_lost_event     = event__process_lost,
758         .process_read_event     = process_read_event,
759         .sample_type_check      = sample_type_check,
760 };
761
762
763 static int __cmd_report(void)
764 {
765         int ret;
766         struct perf_session *session;
767
768         session = perf_session__new(input_name, O_RDONLY, force, &symbol_conf);
769         if (session == NULL)
770                 return -ENOMEM;
771
772         if (show_threads)
773                 perf_read_values_init(&show_threads_values);
774
775         ret = perf_session__process_events(session, &event_ops);
776         if (ret)
777                 goto out_delete;
778
779         if (dump_trace) {
780                 event__print_totals();
781                 goto out_delete;
782         }
783
784         if (verbose > 3)
785                 perf_session__fprintf(session, stdout);
786
787         if (verbose > 2)
788                 dsos__fprintf(stdout);
789
790         collapse__resort();
791         output__resort(event__stats.total);
792         output__fprintf(stdout, event__stats.total);
793
794         if (show_threads)
795                 perf_read_values_destroy(&show_threads_values);
796 out_delete:
797         perf_session__delete(session);
798         return ret;
799 }
800
801 static int
802 parse_callchain_opt(const struct option *opt __used, const char *arg,
803                     int unset __used)
804 {
805         char *tok;
806         char *endptr;
807
808         callchain = 1;
809
810         if (!arg)
811                 return 0;
812
813         tok = strtok((char *)arg, ",");
814         if (!tok)
815                 return -1;
816
817         /* get the output mode */
818         if (!strncmp(tok, "graph", strlen(arg)))
819                 callchain_param.mode = CHAIN_GRAPH_ABS;
820
821         else if (!strncmp(tok, "flat", strlen(arg)))
822                 callchain_param.mode = CHAIN_FLAT;
823
824         else if (!strncmp(tok, "fractal", strlen(arg)))
825                 callchain_param.mode = CHAIN_GRAPH_REL;
826
827         else if (!strncmp(tok, "none", strlen(arg))) {
828                 callchain_param.mode = CHAIN_NONE;
829                 callchain = 0;
830
831                 return 0;
832         }
833
834         else
835                 return -1;
836
837         /* get the min percentage */
838         tok = strtok(NULL, ",");
839         if (!tok)
840                 goto setup;
841
842         callchain_param.min_percent = strtod(tok, &endptr);
843         if (tok == endptr)
844                 return -1;
845
846 setup:
847         if (register_callchain_param(&callchain_param) < 0) {
848                 fprintf(stderr, "Can't register callchain params\n");
849                 return -1;
850         }
851         return 0;
852 }
853
854 //static const char * const report_usage[] = {
855 const char * const report_usage[] = {
856         "perf report [<options>] <command>",
857         NULL
858 };
859
860 static const struct option options[] = {
861         OPT_STRING('i', "input", &input_name, "file",
862                     "input file name"),
863         OPT_BOOLEAN('v', "verbose", &verbose,
864                     "be more verbose (show symbol address, etc)"),
865         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
866                     "dump raw trace in ASCII"),
867         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
868                    "file", "vmlinux pathname"),
869         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
870         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
871                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
872         OPT_BOOLEAN('n', "show-nr-samples", &show_nr_samples,
873                     "Show a column with the number of samples"),
874         OPT_BOOLEAN('T', "threads", &show_threads,
875                     "Show per-thread event counters"),
876         OPT_STRING(0, "pretty", &pretty_printing_style, "key",
877                    "pretty printing style key: normal raw"),
878         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
879                    "sort by key(s): pid, comm, dso, symbol, parent"),
880         OPT_BOOLEAN('P', "full-paths", &event_ops.full_paths,
881                     "Don't shorten the pathnames taking into account the cwd"),
882         OPT_STRING('p', "parent", &parent_pattern, "regex",
883                    "regex filter to identify parent, see: '--sort parent'"),
884         OPT_BOOLEAN('x', "exclude-other", &exclude_other,
885                     "Only display entries with parent-match"),
886         OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
887                      "Display callchains using output_type and min percent threshold. "
888                      "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
889         OPT_STRING('d', "dsos", &dso_list_str, "dso[,dso...]",
890                    "only consider symbols in these dsos"),
891         OPT_STRING('C', "comms", &comm_list_str, "comm[,comm...]",
892                    "only consider symbols in these comms"),
893         OPT_STRING('S', "symbols", &sym_list_str, "symbol[,symbol...]",
894                    "only consider these symbols"),
895         OPT_STRING('w', "column-widths", &col_width_list_str,
896                    "width[,width...]",
897                    "don't try to adjust column width, use these fixed values"),
898         OPT_STRING('t', "field-separator", &field_sep, "separator",
899                    "separator for columns, no spaces will be added between "
900                    "columns '.' is reserved."),
901         OPT_END()
902 };
903
904 static void setup_sorting(void)
905 {
906         char *tmp, *tok, *str = strdup(sort_order);
907
908         for (tok = strtok_r(str, ", ", &tmp);
909                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
910                 if (sort_dimension__add(tok) < 0) {
911                         error("Unknown --sort key: `%s'", tok);
912                         usage_with_options(report_usage, options);
913                 }
914         }
915
916         free(str);
917 }
918
919 static void setup_list(struct strlist **list, const char *list_str,
920                        struct sort_entry *se, const char *list_name,
921                        FILE *fp)
922 {
923         if (list_str) {
924                 *list = strlist__new(true, list_str);
925                 if (!*list) {
926                         fprintf(stderr, "problems parsing %s list\n",
927                                 list_name);
928                         exit(129);
929                 }
930                 if (strlist__nr_entries(*list) == 1) {
931                         fprintf(fp, "# %s: %s\n", list_name,
932                                 strlist__entry(*list, 0)->s);
933                         se->elide = true;
934                 }
935         }
936 }
937
938 int cmd_report(int argc, const char **argv, const char *prefix __used)
939 {
940         if (symbol__init(&symbol_conf) < 0)
941                 return -1;
942
943         argc = parse_options(argc, argv, options, report_usage, 0);
944
945         setup_sorting();
946
947         if (parent_pattern != default_parent_pattern) {
948                 sort_dimension__add("parent");
949                 sort_parent.elide = 1;
950         } else
951                 exclude_other = 0;
952
953         /*
954          * Any (unrecognized) arguments left?
955          */
956         if (argc)
957                 usage_with_options(report_usage, options);
958
959         setup_pager();
960
961         setup_list(&dso_list, dso_list_str, &sort_dso, "dso", stdout);
962         setup_list(&comm_list, comm_list_str, &sort_comm, "comm", stdout);
963         setup_list(&sym_list, sym_list_str, &sort_sym, "symbol", stdout);
964
965         if (field_sep && *field_sep == '.') {
966                 fputs("'.' is the only non valid --field-separator argument\n",
967                       stderr);
968                 exit(129);
969         }
970
971         return __cmd_report();
972 }