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