Documentation/perf_counter/builtin-report.c

   1 #include "util/util.h"
   2 #include "builtin.h"
   3
   4 #include <libelf.h>
   5 #include <gelf.h>
   6 #include <elf.h>
   7
   8 #include "util/list.h"
   9 #include "util/cache.h"
  10 #include "util/rbtree.h"
  11
  12 #include "perf.h"
  13
  14 #include "util/parse-options.h"
  15 #include "util/parse-events.h"
  16
  17 #define SHOW_KERNEL     1
  18 #define SHOW_USER       2
  19 #define SHOW_HV         4
  20
  21 static char             const *input_name = "perf.data";
  22 static char             *vmlinux = NULL;
  23 static char             *sort_order = "pid,symbol";
  24 static int              input;
  25 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
  26
  27 static int              dump_trace = 0;
  28 static int              verbose;
  29
  30 static unsigned long    page_size;
  31 static unsigned long    mmap_window = 32;
  32
  33 const char *perf_event_names[] = {
  34         [PERF_EVENT_MMAP]   = " PERF_EVENT_MMAP",
  35         [PERF_EVENT_MUNMAP] = " PERF_EVENT_MUNMAP",
  36         [PERF_EVENT_COMM]   = " PERF_EVENT_COMM",
  37 };
  38
  39 struct ip_event {
  40         struct perf_event_header header;
  41         __u64 ip;
  42         __u32 pid, tid;
  43 };
  44 struct mmap_event {
  45         struct perf_event_header header;
  46         __u32 pid, tid;
  47         __u64 start;
  48         __u64 len;
  49         __u64 pgoff;
  50         char filename[PATH_MAX];
  51 };
  52 struct comm_event {
  53         struct perf_event_header header;
  54         __u32 pid,tid;
  55         char comm[16];
  56 };
  57
  58 typedef union event_union {
  59         struct perf_event_header header;
  60         struct ip_event ip;
  61         struct mmap_event mmap;
  62         struct comm_event comm;
  63 } event_t;
  64
  65 struct symbol {
  66         struct rb_node          rb_node;
  67         __u64                   start;
  68         __u64                   end;
  69         char                    name[0];
  70 };
  71
  72 static struct symbol *symbol__new(uint64_t start, uint64_t len, const char *name)
  73 {
  74         struct symbol *self = malloc(sizeof(*self) + strlen(name) + 1);
  75
  76         if (self != NULL) {
  77                 self->start = start;
  78                 self->end   = start + len;
  79                 strcpy(self->name, name);
  80         }
  81
  82         return self;
  83 }
  84
  85 static void symbol__delete(struct symbol *self)
  86 {
  87         free(self);
  88 }
  89
  90 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
  91 {
  92         return fprintf(fp, " %llx-%llx %s\n",
  93                        self->start, self->end, self->name);
  94 }
  95
  96 struct dso {
  97         struct list_head node;
  98         struct rb_root   syms;
  99         char             name[0];
 100 };
 101
 102 static struct dso *dso__new(const char *name)
 103 {
 104         struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
 105
 106         if (self != NULL) {
 107                 strcpy(self->name, name);
 108                 self->syms = RB_ROOT;
 109         }
 110
 111         return self;
 112 }
 113
 114 static void dso__delete_symbols(struct dso *self)
 115 {
 116         struct symbol *pos;
 117         struct rb_node *next = rb_first(&self->syms);
 118
 119         while (next) {
 120                 pos = rb_entry(next, struct symbol, rb_node);
 121                 next = rb_next(&pos->rb_node);
 122                 symbol__delete(pos);
 123         }
 124 }
 125
 126 static void dso__delete(struct dso *self)
 127 {
 128         dso__delete_symbols(self);
 129         free(self);
 130 }
 131
 132 static void dso__insert_symbol(struct dso *self, struct symbol *sym)
 133 {
 134         struct rb_node **p = &self->syms.rb_node;
 135         struct rb_node *parent = NULL;
 136         const uint64_t ip = sym->start;
 137         struct symbol *s;
 138
 139         while (*p != NULL) {
 140                 parent = *p;
 141                 s = rb_entry(parent, struct symbol, rb_node);
 142                 if (ip < s->start)
 143                         p = &(*p)->rb_left;
 144                 else
 145                         p = &(*p)->rb_right;
 146         }
 147         rb_link_node(&sym->rb_node, parent, p);
 148         rb_insert_color(&sym->rb_node, &self->syms);
 149 }
 150
 151 static struct symbol *dso__find_symbol(struct dso *self, uint64_t ip)
 152 {
 153         struct rb_node *n;
 154
 155         if (self == NULL)
 156                 return NULL;
 157
 158         n = self->syms.rb_node;
 159
 160         while (n) {
 161                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 162
 163                 if (ip < s->start)
 164                         n = n->rb_left;
 165                 else if (ip > s->end)
 166                         n = n->rb_right;
 167                 else
 168                         return s;
 169         }
 170
 171         return NULL;
 172 }
 173
 174 /**
 175  * elf_symtab__for_each_symbol - iterate thru all the symbols
 176  *
 177  * @self: struct elf_symtab instance to iterate
 178  * @index: uint32_t index
 179  * @sym: GElf_Sym iterator
 180  */
 181 #define elf_symtab__for_each_symbol(syms, nr_syms, index, sym) \
 182         for (index = 0, gelf_getsym(syms, index, &sym);\
 183              index < nr_syms; \
 184              index++, gelf_getsym(syms, index, &sym))
 185
 186 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 187 {
 188         return GELF_ST_TYPE(sym->st_info);
 189 }
 190
 191 static inline int elf_sym__is_function(const GElf_Sym *sym)
 192 {
 193         return elf_sym__type(sym) == STT_FUNC &&
 194                sym->st_name != 0 &&
 195                sym->st_shndx != SHN_UNDEF &&
 196                sym->st_size != 0;
 197 }
 198
 199 static inline const char *elf_sym__name(const GElf_Sym *sym,
 200                                         const Elf_Data *symstrs)
 201 {
 202         return symstrs->d_buf + sym->st_name;
 203 }
 204
 205 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 206                                     GElf_Shdr *shp, const char *name,
 207                                     size_t *index)
 208 {
 209         Elf_Scn *sec = NULL;
 210         size_t cnt = 1;
 211
 212         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 213                 char *str;
 214
 215                 gelf_getshdr(sec, shp);
 216                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 217                 if (!strcmp(name, str)) {
 218                         if (index)
 219                                 *index = cnt;
 220                         break;
 221                 }
 222                 ++cnt;
 223         }
 224
 225         return sec;
 226 }
 227
 228 static int dso__load_sym(struct dso *self, int fd, char *name)
 229 {
 230         Elf_Data *symstrs;
 231         uint32_t nr_syms;
 232         int err = -1;
 233         uint32_t index;
 234         GElf_Ehdr ehdr;
 235         GElf_Shdr shdr;
 236         Elf_Data *syms;
 237         GElf_Sym sym;
 238         Elf_Scn *sec;
 239         Elf *elf;
 240         int nr = 0;
 241
 242         elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
 243         if (elf == NULL) {
 244                 fprintf(stderr, "%s: cannot read %s ELF file.\n",
 245                         __func__, name);
 246                 goto out_close;
 247         }
 248
 249         if (gelf_getehdr(elf, &ehdr) == NULL) {
 250                 fprintf(stderr, "%s: cannot get elf header.\n", __func__);
 251                 goto out_elf_end;
 252         }
 253
 254         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 255         if (sec == NULL)
 256                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 257
 258         if (sec == NULL)
 259                 goto out_elf_end;
 260
 261         syms = elf_getdata(sec, NULL);
 262         if (syms == NULL)
 263                 goto out_elf_end;
 264
 265         sec = elf_getscn(elf, shdr.sh_link);
 266         if (sec == NULL)
 267                 goto out_elf_end;
 268
 269         symstrs = elf_getdata(sec, NULL);
 270         if (symstrs == NULL)
 271                 goto out_elf_end;
 272
 273         nr_syms = shdr.sh_size / shdr.sh_entsize;
 274
 275         elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
 276                 struct symbol *f;
 277
 278                 if (!elf_sym__is_function(&sym))
 279                         continue;
 280
 281                 sec = elf_getscn(elf, sym.st_shndx);
 282                 if (!sec)
 283                         goto out_elf_end;
 284
 285                 gelf_getshdr(sec, &shdr);
 286                 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 287
 288                 f = symbol__new(sym.st_value, sym.st_size,
 289                                 elf_sym__name(&sym, symstrs));
 290                 if (!f)
 291                         goto out_elf_end;
 292
 293                 dso__insert_symbol(self, f);
 294
 295                 nr++;
 296         }
 297
 298         err = nr;
 299 out_elf_end:
 300         elf_end(elf);
 301 out_close:
 302         return err;
 303 }
 304
 305 static int dso__load(struct dso *self)
 306 {
 307         int size = strlen(self->name) + sizeof("/usr/lib/debug%s.debug");
 308         char *name = malloc(size);
 309         int variant = 0;
 310         int ret = -1;
 311         int fd;
 312
 313         if (!name)
 314                 return -1;
 315
 316 more:
 317         do {
 318                 switch (variant) {
 319                 case 0: /* Fedora */
 320                         snprintf(name, size, "/usr/lib/debug%s.debug", self->name);
 321                         break;
 322                 case 1: /* Ubuntu */
 323                         snprintf(name, size, "/usr/lib/debug%s", self->name);
 324                         break;
 325                 case 2: /* Sane people */
 326                         snprintf(name, size, "%s", self->name);
 327                         break;
 328
 329                 default:
 330                         goto out;
 331                 }
 332                 variant++;
 333
 334                 fd = open(name, O_RDONLY);
 335         } while (fd < 0);
 336
 337         ret = dso__load_sym(self, fd, name);
 338         close(fd);
 339
 340         /*
 341          * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
 342          */
 343         if (!ret)
 344                 goto more;
 345
 346 out:
 347         free(name);
 348         return ret;
 349 }
 350
 351 static size_t dso__fprintf(struct dso *self, FILE *fp)
 352 {
 353         size_t ret = fprintf(fp, "dso: %s\n", self->name);
 354
 355         struct rb_node *nd;
 356         for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
 357                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 358                 ret += symbol__fprintf(pos, fp);
 359         }
 360
 361         return ret;
 362 }
 363
 364 static LIST_HEAD(dsos);
 365 static struct dso *kernel_dso;
 366
 367 static void dsos__add(struct dso *dso)
 368 {
 369         list_add_tail(&dso->node, &dsos);
 370 }
 371
 372 static struct dso *dsos__find(const char *name)
 373 {
 374         struct dso *pos;
 375
 376         list_for_each_entry(pos, &dsos, node)
 377                 if (strcmp(pos->name, name) == 0)
 378                         return pos;
 379         return NULL;
 380 }
 381
 382 static struct dso *dsos__findnew(const char *name)
 383 {
 384         struct dso *dso = dsos__find(name);
 385         int nr;
 386
 387         if (dso == NULL) {
 388                 dso = dso__new(name);
 389                 if (!dso)
 390                         goto out_delete_dso;
 391
 392                 nr = dso__load(dso);
 393                 if (nr < 0) {
 394                         fprintf(stderr, "Failed to open: %s\n", name);
 395                         goto out_delete_dso;
 396                 }
 397                 if (!nr) {
 398                         fprintf(stderr,
 399                 "Failed to find debug symbols for: %s, maybe install a debug package?\n",
 400                                         name);
 401                 }
 402
 403                 dsos__add(dso);
 404         }
 405
 406         return dso;
 407
 408 out_delete_dso:
 409         dso__delete(dso);
 410         return NULL;
 411 }
 412
 413 static void dsos__fprintf(FILE *fp)
 414 {
 415         struct dso *pos;
 416
 417         list_for_each_entry(pos, &dsos, node)
 418                 dso__fprintf(pos, fp);
 419 }
 420
 421 static int hex(char ch)
 422 {
 423         if ((ch >= '0') && (ch <= '9'))
 424                 return ch - '0';
 425         if ((ch >= 'a') && (ch <= 'f'))
 426                 return ch - 'a' + 10;
 427         if ((ch >= 'A') && (ch <= 'F'))
 428                 return ch - 'A' + 10;
 429         return -1;
 430 }
 431
 432 /*
 433  * While we find nice hex chars, build a long_val.
 434  * Return number of chars processed.
 435  */
 436 static int hex2long(char *ptr, unsigned long *long_val)
 437 {
 438         const char *p = ptr;
 439         *long_val = 0;
 440
 441         while (*p) {
 442                 const int hex_val = hex(*p);
 443
 444                 if (hex_val < 0)
 445                         break;
 446
 447                 *long_val = (*long_val << 4) | hex_val;
 448                 p++;
 449         }
 450
 451         return p - ptr;
 452 }
 453
 454 static int load_kallsyms(void)
 455 {
 456         struct rb_node *nd, *prevnd;
 457         char *line = NULL;
 458         FILE *file;
 459         size_t n;
 460
 461         kernel_dso = dso__new("[kernel]");
 462         if (kernel_dso == NULL)
 463                 return -1;
 464
 465         file = fopen("/proc/kallsyms", "r");
 466         if (file == NULL)
 467                 goto out_delete_dso;
 468
 469         while (!feof(file)) {
 470                 unsigned long start;
 471                 struct symbol *sym;
 472                 int line_len, len;
 473                 char symbol_type;
 474
 475                 line_len = getline(&line, &n, file);
 476                 if (line_len < 0)
 477                         break;
 478
 479                 if (!line)
 480                         goto out_delete_dso;
 481
 482                 line[--line_len] = '\0'; /* \n */
 483
 484                 len = hex2long(line, &start);
 485
 486                 len++;
 487                 if (len + 2 >= line_len)
 488                         continue;
 489
 490                 symbol_type = toupper(line[len]);
 491                 /*
 492                  * We're interested only in code ('T'ext)
 493                  */
 494                 if (symbol_type != 'T' && symbol_type != 'W')
 495                         continue;
 496                 /*
 497                  * Well fix up the end later, when we have all sorted.
 498                  */
 499                 sym = symbol__new(start, 0xdead, line + len + 2);
 500
 501                 if (sym == NULL)
 502                         goto out_delete_dso;
 503
 504                 dso__insert_symbol(kernel_dso, sym);
 505         }
 506
 507         /*
 508          * Now that we have all sorted out, just set the ->end of all
 509          * symbols
 510          */
 511         prevnd = rb_first(&kernel_dso->syms);
 512
 513         if (prevnd == NULL)
 514                 goto out_delete_line;
 515
 516         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 517                 struct symbol *prev = rb_entry(prevnd, struct symbol, rb_node),
 518                               *curr = rb_entry(nd, struct symbol, rb_node);
 519
 520                 prev->end = curr->start - 1;
 521                 prevnd = nd;
 522         }
 523
 524         dsos__add(kernel_dso);
 525         free(line);
 526         fclose(file);
 527
 528         return 0;
 529
 530 out_delete_line:
 531         free(line);
 532 out_delete_dso:
 533         dso__delete(kernel_dso);
 534         return -1;
 535 }
 536
 537 static int load_kernel(void)
 538 {
 539         int fd, nr;
 540
 541         if (!vmlinux)
 542                 goto kallsyms;
 543
 544         fd = open(vmlinux, O_RDONLY);
 545         if (fd < 0)
 546                 goto kallsyms;
 547
 548         kernel_dso = dso__new("[kernel]");
 549         if (!kernel_dso)
 550                 goto fail_open;
 551
 552         nr = dso__load_sym(kernel_dso, fd, vmlinux);
 553
 554         if (nr <= 0)
 555                 goto fail_load;
 556
 557         dsos__add(kernel_dso);
 558         close(fd);
 559
 560         return 0;
 561
 562 fail_load:
 563         dso__delete(kernel_dso);
 564 fail_open:
 565         close(fd);
 566 kallsyms:
 567         return load_kallsyms();
 568 }
 569
 570 struct map {
 571         struct list_head node;
 572         uint64_t         start;
 573         uint64_t         end;
 574         uint64_t         pgoff;
 575         struct dso       *dso;
 576 };
 577
 578 static struct map *map__new(struct mmap_event *event)
 579 {
 580         struct map *self = malloc(sizeof(*self));
 581
 582         if (self != NULL) {
 583                 self->start = event->start;
 584                 self->end   = event->start + event->len;
 585                 self->pgoff = event->pgoff;
 586
 587                 self->dso = dsos__findnew(event->filename);
 588                 if (self->dso == NULL)
 589                         goto out_delete;
 590         }
 591         return self;
 592 out_delete:
 593         free(self);
 594         return NULL;
 595 }
 596
 597 struct thread;
 598
 599 static const char *thread__name(struct thread *self, char *bf, size_t size);
 600
 601 struct thread {
 602         struct rb_node   rb_node;
 603         struct list_head maps;
 604         pid_t            pid;
 605         char             *comm;
 606 };
 607
 608 static const char *thread__name(struct thread *self, char *bf, size_t size)
 609 {
 610         if (self->comm)
 611                 return self->comm;
 612
 613         snprintf(bf, sizeof(bf), ":%u", self->pid);
 614         return bf;
 615 }
 616
 617 static struct thread *thread__new(pid_t pid)
 618 {
 619         struct thread *self = malloc(sizeof(*self));
 620
 621         if (self != NULL) {
 622                 self->pid = pid;
 623                 self->comm = NULL;
 624                 INIT_LIST_HEAD(&self->maps);
 625         }
 626
 627         return self;
 628 }
 629
 630 static int thread__set_comm(struct thread *self, const char *comm)
 631 {
 632         self->comm = strdup(comm);
 633         return self->comm ? 0 : -ENOMEM;
 634 }
 635
 636 static struct rb_root threads;
 637
 638 static struct thread *threads__findnew(pid_t pid)
 639 {
 640         struct rb_node **p = &threads.rb_node;
 641         struct rb_node *parent = NULL;
 642         struct thread *th;
 643
 644         while (*p != NULL) {
 645                 parent = *p;
 646                 th = rb_entry(parent, struct thread, rb_node);
 647
 648                 if (th->pid == pid)
 649                         return th;
 650
 651                 if (pid < th->pid)
 652                         p = &(*p)->rb_left;
 653                 else
 654                         p = &(*p)->rb_right;
 655         }
 656
 657         th = thread__new(pid);
 658         if (th != NULL) {
 659                 rb_link_node(&th->rb_node, parent, p);
 660                 rb_insert_color(&th->rb_node, &threads);
 661         }
 662         return th;
 663 }
 664
 665 static void thread__insert_map(struct thread *self, struct map *map)
 666 {
 667         list_add_tail(&map->node, &self->maps);
 668 }
 669
 670 static struct map *thread__find_map(struct thread *self, uint64_t ip)
 671 {
 672         struct map *pos;
 673
 674         if (self == NULL)
 675                 return NULL;
 676
 677         list_for_each_entry(pos, &self->maps, node)
 678                 if (ip >= pos->start && ip <= pos->end)
 679                         return pos;
 680
 681         return NULL;
 682 }
 683
 684 /*
 685  * histogram, sorted on item, collects counts
 686  */
 687
 688 static struct rb_root hist;
 689
 690 struct hist_entry {
 691         struct rb_node   rb_node;
 692
 693         struct thread    *thread;
 694         struct map       *map;
 695         struct dso       *dso;
 696         struct symbol    *sym;
 697         uint64_t         ip;
 698         char             level;
 699
 700         uint32_t         count;
 701 };
 702
 703 /*
 704  * configurable sorting bits
 705  */
 706
 707 struct sort_entry {
 708         struct list_head list;
 709
 710         int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
 711         size_t  (*print)(FILE *fp, struct hist_entry *);
 712 };
 713
 714 static int64_t
 715 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
 716 {
 717         return right->thread->pid - left->thread->pid;
 718 }
 719
 720 static size_t
 721 sort__thread_print(FILE *fp, struct hist_entry *self)
 722 {
 723         char bf[32];
 724
 725         return fprintf(fp, "%14s ",
 726                         thread__name(self->thread, bf, sizeof(bf)));
 727 }
 728
 729 static struct sort_entry sort_thread = {
 730         .cmp    = sort__thread_cmp,
 731         .print  = sort__thread_print,
 732 };
 733
 734 static int64_t
 735 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
 736 {
 737         char *comm_l = left->thread->comm;
 738         char *comm_r = right->thread->comm;
 739
 740         if (!comm_l || !comm_r) {
 741                 if (!comm_l && !comm_r)
 742                         return 0;
 743                 else if (!comm_l)
 744                         return -1;
 745                 else
 746                         return 1;
 747         }
 748
 749         return strcmp(comm_l, comm_r);
 750 }
 751
 752 static size_t
 753 sort__comm_print(FILE *fp, struct hist_entry *self)
 754 {
 755         return fprintf(fp, "%20s ", self->thread->comm ?: "<unknown>");
 756 }
 757
 758 static struct sort_entry sort_comm = {
 759         .cmp    = sort__comm_cmp,
 760         .print  = sort__comm_print,
 761 };
 762
 763 static int64_t
 764 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 765 {
 766         struct dso *dso_l = left->dso;
 767         struct dso *dso_r = right->dso;
 768
 769         if (!dso_l || !dso_r) {
 770                 if (!dso_l && !dso_r)
 771                         return 0;
 772                 else if (!dso_l)
 773                         return -1;
 774                 else
 775                         return 1;
 776         }
 777
 778         return strcmp(dso_l->name, dso_r->name);
 779 }
 780
 781 static size_t
 782 sort__dso_print(FILE *fp, struct hist_entry *self)
 783 {
 784         return fprintf(fp, "%64s ", self->dso ? self->dso->name : "<unknown>");
 785 }
 786
 787 static struct sort_entry sort_dso = {
 788         .cmp    = sort__dso_cmp,
 789         .print  = sort__dso_print,
 790 };
 791
 792 static int64_t
 793 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 794 {
 795         uint64_t ip_l, ip_r;
 796
 797         if (left->sym == right->sym)
 798                 return 0;
 799
 800         ip_l = left->sym ? left->sym->start : left->ip;
 801         ip_r = right->sym ? right->sym->start : right->ip;
 802
 803         return (int64_t)(ip_r - ip_l);
 804 }
 805
 806 static size_t
 807 sort__sym_print(FILE *fp, struct hist_entry *self)
 808 {
 809         size_t ret = 0;
 810
 811         ret += fprintf(fp, "[%c] ", self->level);
 812
 813         if (verbose)
 814                 ret += fprintf(fp, "%#018llx ", (unsigned long long)self->ip);
 815
 816         if (self->level != '.')
 817                 ret += fprintf(fp, "%s ",
 818                                self->sym ? self->sym->name : "<unknown>");
 819         else
 820                 ret += fprintf(fp, "%s: %s ",
 821                                self->dso ? self->dso->name : "<unknown>",
 822                                self->sym ? self->sym->name : "<unknown>");
 823
 824         return ret;
 825 }
 826
 827 static struct sort_entry sort_sym = {
 828         .cmp    = sort__sym_cmp,
 829         .print  = sort__sym_print,
 830 };
 831
 832 struct sort_dimension {
 833         char *name;
 834         struct sort_entry *entry;
 835         int taken;
 836 };
 837
 838 static struct sort_dimension sort_dimensions[] = {
 839         { .name = "pid",        .entry = &sort_thread,  },
 840         { .name = "comm",       .entry = &sort_comm,    },
 841         { .name = "dso",        .entry = &sort_dso,     },
 842         { .name = "symbol",     .entry = &sort_sym,     },
 843 };
 844
 845 static LIST_HEAD(hist_entry__sort_list);
 846
 847 static int sort_dimension__add(char *tok)
 848 {
 849         int i;
 850
 851         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
 852                 struct sort_dimension *sd = &sort_dimensions[i];
 853
 854                 if (sd->taken)
 855                         continue;
 856
 857                 if (strcmp(tok, sd->name))
 858                         continue;
 859
 860                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
 861                 sd->taken = 1;
 862                 return 0;
 863         }
 864
 865         return -ESRCH;
 866 }
 867
 868 static void setup_sorting(void)
 869 {
 870         char *tmp, *tok, *str = strdup(sort_order);
 871
 872         for (tok = strtok_r(str, ", ", &tmp);
 873                         tok; tok = strtok_r(NULL, ", ", &tmp))
 874                 sort_dimension__add(tok);
 875
 876         free(str);
 877 }
 878
 879 static int64_t
 880 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 881 {
 882         struct sort_entry *se;
 883         int64_t cmp = 0;
 884
 885         list_for_each_entry(se, &hist_entry__sort_list, list) {
 886                 cmp = se->cmp(left, right);
 887                 if (cmp)
 888                         break;
 889         }
 890
 891         return cmp;
 892 }
 893
 894 static size_t
 895 hist_entry__fprintf(FILE *fp, struct hist_entry *self, uint64_t total_samples)
 896 {
 897         struct sort_entry *se;
 898         size_t ret;
 899
 900         if (total_samples) {
 901                 ret = fprintf(fp, "%5.2f%% ",
 902                                 (self->count * 100.0) / total_samples);
 903         } else
 904                 ret = fprintf(fp, "%12d ", self->count);
 905
 906         list_for_each_entry(se, &hist_entry__sort_list, list)
 907                 ret += se->print(fp, self);
 908
 909         ret += fprintf(fp, "\n");
 910
 911         return ret;
 912 }
 913
 914 /*
 915  * collect histogram counts
 916  */
 917
 918 static int
 919 hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
 920                 struct symbol *sym, uint64_t ip, char level)
 921 {
 922         struct rb_node **p = &hist.rb_node;
 923         struct rb_node *parent = NULL;
 924         struct hist_entry *he;
 925         struct hist_entry entry = {
 926                 .thread = thread,
 927                 .map    = map,
 928                 .dso    = dso,
 929                 .sym    = sym,
 930                 .ip     = ip,
 931                 .level  = level,
 932                 .count  = 1,
 933         };
 934         int cmp;
 935
 936         while (*p != NULL) {
 937                 parent = *p;
 938                 he = rb_entry(parent, struct hist_entry, rb_node);
 939
 940                 cmp = hist_entry__cmp(&entry, he);
 941
 942                 if (!cmp) {
 943                         he->count++;
 944                         return 0;
 945                 }
 946
 947                 if (cmp < 0)
 948                         p = &(*p)->rb_left;
 949                 else
 950                         p = &(*p)->rb_right;
 951         }
 952
 953         he = malloc(sizeof(*he));
 954         if (!he)
 955                 return -ENOMEM;
 956         *he = entry;
 957         rb_link_node(&he->rb_node, parent, p);
 958         rb_insert_color(&he->rb_node, &hist);
 959
 960         return 0;
 961 }
 962
 963 /*
 964  * reverse the map, sort on count.
 965  */
 966
 967 static struct rb_root output_hists;
 968
 969 static void output__insert_entry(struct hist_entry *he)
 970 {
 971         struct rb_node **p = &output_hists.rb_node;
 972         struct rb_node *parent = NULL;
 973         struct hist_entry *iter;
 974
 975         while (*p != NULL) {
 976                 parent = *p;
 977                 iter = rb_entry(parent, struct hist_entry, rb_node);
 978
 979                 if (he->count > iter->count)
 980                         p = &(*p)->rb_left;
 981                 else
 982                         p = &(*p)->rb_right;
 983         }
 984
 985         rb_link_node(&he->rb_node, parent, p);
 986         rb_insert_color(&he->rb_node, &output_hists);
 987 }
 988
 989 static void output__resort(void)
 990 {
 991         struct rb_node *next = rb_first(&hist);
 992         struct hist_entry *n;
 993
 994         while (next) {
 995                 n = rb_entry(next, struct hist_entry, rb_node);
 996                 next = rb_next(&n->rb_node);
 997
 998                 rb_erase(&n->rb_node, &hist);
 999                 output__insert_entry(n);
1000         }
1001 }
1002
1003 static size_t output__fprintf(FILE *fp, uint64_t total_samples)
1004 {
1005         struct hist_entry *pos;
1006         struct rb_node *nd;
1007         size_t ret = 0;
1008
1009         for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
1010                 pos = rb_entry(nd, struct hist_entry, rb_node);
1011                 ret += hist_entry__fprintf(fp, pos, total_samples);
1012         }
1013
1014         return ret;
1015 }
1016
1017
1018 static int __cmd_report(void)
1019 {
1020         unsigned long offset = 0;
1021         unsigned long head = 0;
1022         struct stat stat;
1023         char *buf;
1024         event_t *event;
1025         int ret, rc = EXIT_FAILURE;
1026         uint32_t size;
1027         unsigned long total = 0, total_mmap = 0, total_comm = 0, total_unknown = 0;
1028
1029         input = open(input_name, O_RDONLY);
1030         if (input < 0) {
1031                 perror("failed to open file");
1032                 exit(-1);
1033         }
1034
1035         ret = fstat(input, &stat);
1036         if (ret < 0) {
1037                 perror("failed to stat file");
1038                 exit(-1);
1039         }
1040
1041         if (!stat.st_size) {
1042                 fprintf(stderr, "zero-sized file, nothing to do!\n");
1043                 exit(0);
1044         }
1045
1046         if (load_kernel() < 0) {
1047                 perror("failed to open kallsyms");
1048                 return EXIT_FAILURE;
1049         }
1050
1051 remap:
1052         buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
1053                            MAP_SHARED, input, offset);
1054         if (buf == MAP_FAILED) {
1055                 perror("failed to mmap file");
1056                 exit(-1);
1057         }
1058
1059 more:
1060         event = (event_t *)(buf + head);
1061
1062         size = event->header.size;
1063         if (!size)
1064                 size = 8;
1065
1066         if (head + event->header.size >= page_size * mmap_window) {
1067                 unsigned long shift = page_size * (head / page_size);
1068                 int ret;
1069
1070                 ret = munmap(buf, page_size * mmap_window);
1071                 assert(ret == 0);
1072
1073                 offset += shift;
1074                 head -= shift;
1075                 goto remap;
1076         }
1077
1078         size = event->header.size;
1079         if (!size)
1080                 goto broken_event;
1081
1082         if (event->header.misc & PERF_EVENT_MISC_OVERFLOW) {
1083                 char level;
1084                 int show = 0;
1085                 struct dso *dso = NULL;
1086                 struct thread *thread = threads__findnew(event->ip.pid);
1087                 uint64_t ip = event->ip.ip;
1088                 struct map *map = NULL;
1089
1090                 if (dump_trace) {
1091                         fprintf(stderr, "%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
1092                                 (void *)(offset + head),
1093                                 (void *)(long)(event->header.size),
1094                                 event->header.misc,
1095                                 event->ip.pid,
1096                                 (void *)(long)ip);
1097                 }
1098
1099                 if (thread == NULL) {
1100                         fprintf(stderr, "problem processing %d event, bailing out\n",
1101                                 event->header.type);
1102                         goto done;
1103                 }
1104
1105                 if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
1106                         show = SHOW_KERNEL;
1107                         level = 'k';
1108
1109                         dso = kernel_dso;
1110
1111                 } else if (event->header.misc & PERF_EVENT_MISC_USER) {
1112
1113                         show = SHOW_USER;
1114                         level = '.';
1115
1116                         map = thread__find_map(thread, ip);
1117                         if (map != NULL) {
1118                                 dso = map->dso;
1119                                 ip -= map->start + map->pgoff;
1120                         }
1121
1122                 } else {
1123                         show = SHOW_HV;
1124                         level = 'H';
1125                 }
1126
1127                 if (show & show_mask) {
1128                         struct symbol *sym = dso__find_symbol(dso, ip);
1129
1130                         if (hist_entry__add(thread, map, dso, sym, ip, level)) {
1131                                 fprintf(stderr,
1132                 "problem incrementing symbol count, bailing out\n");
1133                                 goto done;
1134                         }
1135                 }
1136                 total++;
1137         } else switch (event->header.type) {
1138         case PERF_EVENT_MMAP: {
1139                 struct thread *thread = threads__findnew(event->mmap.pid);
1140                 struct map *map = map__new(&event->mmap);
1141
1142                 if (dump_trace) {
1143                         fprintf(stderr, "%p [%p]: PERF_EVENT_MMAP: [%p(%p) @ %p]: %s\n",
1144                                 (void *)(offset + head),
1145                                 (void *)(long)(event->header.size),
1146                                 (void *)(long)event->mmap.start,
1147                                 (void *)(long)event->mmap.len,
1148                                 (void *)(long)event->mmap.pgoff,
1149                                 event->mmap.filename);
1150                 }
1151                 if (thread == NULL || map == NULL) {
1152                         fprintf(stderr, "problem processing PERF_EVENT_MMAP, bailing out\n");
1153                         goto done;
1154                 }
1155                 thread__insert_map(thread, map);
1156                 total_mmap++;
1157                 break;
1158         }
1159         case PERF_EVENT_COMM: {
1160                 struct thread *thread = threads__findnew(event->comm.pid);
1161
1162                 if (dump_trace) {
1163                         fprintf(stderr, "%p [%p]: PERF_EVENT_COMM: %s:%d\n",
1164                                 (void *)(offset + head),
1165                                 (void *)(long)(event->header.size),
1166                                 event->comm.comm, event->comm.pid);
1167                 }
1168                 if (thread == NULL ||
1169                     thread__set_comm(thread, event->comm.comm)) {
1170                         fprintf(stderr, "problem processing PERF_EVENT_COMM, bailing out\n");
1171                         goto done;
1172                 }
1173                 total_comm++;
1174                 break;
1175         }
1176         default: {
1177 broken_event:
1178                 if (dump_trace)
1179                         fprintf(stderr, "%p [%p]: skipping unknown header type: %d\n",
1180                                         (void *)(offset + head),
1181                                         (void *)(long)(event->header.size),
1182                                         event->header.type);
1183
1184                 total_unknown++;
1185
1186                 /*
1187                  * assume we lost track of the stream, check alignment, and
1188                  * increment a single u64 in the hope to catch on again 'soon'.
1189                  */
1190
1191                 if (unlikely(head & 7))
1192                         head &= ~7ULL;
1193
1194                 size = 8;
1195         }
1196         }
1197
1198         head += size;
1199
1200         if (offset + head < stat.st_size)
1201                 goto more;
1202
1203         rc = EXIT_SUCCESS;
1204 done:
1205         close(input);
1206
1207         if (dump_trace) {
1208                 fprintf(stderr, "      IP events: %10ld\n", total);
1209                 fprintf(stderr, "    mmap events: %10ld\n", total_mmap);
1210                 fprintf(stderr, "    comm events: %10ld\n", total_comm);
1211                 fprintf(stderr, " unknown events: %10ld\n", total_unknown);
1212
1213                 return 0;
1214         }
1215
1216         if (verbose >= 2)
1217                 dsos__fprintf(stdout);
1218
1219         output__resort();
1220         output__fprintf(stdout, total);
1221
1222         return rc;
1223 }
1224
1225 static const char * const report_usage[] = {
1226         "perf report [<options>] <command>",
1227         NULL
1228 };
1229
1230 static const struct option options[] = {
1231         OPT_STRING('i', "input", &input_name, "file",
1232                     "input file name"),
1233         OPT_BOOLEAN('v', "verbose", &verbose,
1234                     "be more verbose (show symbol address, etc)"),
1235         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1236                     "dump raw trace in ASCII"),
1237         OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
1238         OPT_STRING('s', "sort", &sort_order, "foo", "bar"),
1239         OPT_END()
1240 };
1241
1242 int cmd_report(int argc, const char **argv, const char *prefix)
1243 {
1244         elf_version(EV_CURRENT);
1245
1246         page_size = getpagesize();
1247
1248         parse_options(argc, argv, options, report_usage, 0);
1249
1250         setup_sorting();
1251
1252         setup_pager();
1253
1254         return __cmd_report();
1255 }