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