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_header)(FILE *fp);
 712         size_t  (*print)(FILE *fp, struct hist_entry *);
 713 };
 714
 715 static int64_t
 716 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
 717 {
 718         return right->thread->pid - left->thread->pid;
 719 }
 720
 721 static size_t
 722 sort__thread_print(FILE *fp, struct hist_entry *self)
 723 {
 724         char bf[32];
 725
 726         return fprintf(fp, " %16s",
 727                         thread__name(self->thread, bf, sizeof(bf)));
 728 }
 729
 730 static struct sort_entry sort_thread = {
 731         .cmp    = sort__thread_cmp,
 732         .print  = sort__thread_print,
 733 };
 734
 735 static int64_t
 736 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
 737 {
 738         char *comm_l = left->thread->comm;
 739         char *comm_r = right->thread->comm;
 740
 741         if (!comm_l || !comm_r) {
 742                 if (!comm_l && !comm_r)
 743                         return 0;
 744                 else if (!comm_l)
 745                         return -1;
 746                 else
 747                         return 1;
 748         }
 749
 750         return strcmp(comm_l, comm_r);
 751 }
 752
 753 static size_t
 754 sort__comm_print(FILE *fp, struct hist_entry *self)
 755 {
 756         return fprintf(fp, " %16s", self->thread->comm ?: "<unknown>");
 757 }
 758
 759 static struct sort_entry sort_comm = {
 760         .cmp    = sort__comm_cmp,
 761         .print  = sort__comm_print,
 762 };
 763
 764 static int64_t
 765 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 766 {
 767         struct dso *dso_l = left->dso;
 768         struct dso *dso_r = right->dso;
 769
 770         if (!dso_l || !dso_r) {
 771                 if (!dso_l && !dso_r)
 772                         return 0;
 773                 else if (!dso_l)
 774                         return -1;
 775                 else
 776                         return 1;
 777         }
 778
 779         return strcmp(dso_l->name, dso_r->name);
 780 }
 781
 782 static size_t
 783 sort__dso_print(FILE *fp, struct hist_entry *self)
 784 {
 785         return fprintf(fp, " %64s", self->dso ? self->dso->name : "<unknown>");
 786 }
 787
 788 static struct sort_entry sort_dso = {
 789         .cmp    = sort__dso_cmp,
 790         .print  = sort__dso_print,
 791 };
 792
 793 static int64_t
 794 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 795 {
 796         uint64_t ip_l, ip_r;
 797
 798         if (left->sym == right->sym)
 799                 return 0;
 800
 801         ip_l = left->sym ? left->sym->start : left->ip;
 802         ip_r = right->sym ? right->sym->start : right->ip;
 803
 804         return (int64_t)(ip_r - ip_l);
 805 }
 806
 807 static size_t sort__sym_print_header(FILE *fp)
 808 {
 809         size_t ret = 0;
 810
 811         ret += fprintf(fp, "#\n");
 812         ret += fprintf(fp, "# Overhead          Command       File: Symbol\n");
 813         ret += fprintf(fp, "# ........          .......       ............\n");
 814         ret += fprintf(fp, "#\n");
 815
 816         return ret;
 817 }
 818
 819 static size_t
 820 sort__sym_print(FILE *fp, struct hist_entry *self)
 821 {
 822         size_t ret = 0;
 823
 824         ret += fprintf(fp, "  [%c] ", self->level);
 825
 826         if (verbose)
 827                 ret += fprintf(fp, " %#018llx", (unsigned long long)self->ip);
 828
 829         if (self->level != '.')
 830                 ret += fprintf(fp, " kernel: %s",
 831                                self->sym ? self->sym->name : "<unknown>");
 832         else
 833                 ret += fprintf(fp, " %s: %s",
 834                                self->dso ? self->dso->name : "<unknown>",
 835                                self->sym ? self->sym->name : "<unknown>");
 836
 837         return ret;
 838 }
 839
 840 static struct sort_entry sort_sym = {
 841         .cmp            = sort__sym_cmp,
 842         .print_header   = sort__sym_print_header,
 843         .print          = sort__sym_print,
 844 };
 845
 846 struct sort_dimension {
 847         char *name;
 848         struct sort_entry *entry;
 849         int taken;
 850 };
 851
 852 static struct sort_dimension sort_dimensions[] = {
 853         { .name = "pid",        .entry = &sort_thread,  },
 854         { .name = "comm",       .entry = &sort_comm,    },
 855         { .name = "dso",        .entry = &sort_dso,     },
 856         { .name = "symbol",     .entry = &sort_sym,     },
 857 };
 858
 859 static LIST_HEAD(hist_entry__sort_list);
 860
 861 static int sort_dimension__add(char *tok)
 862 {
 863         int i;
 864
 865         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
 866                 struct sort_dimension *sd = &sort_dimensions[i];
 867
 868                 if (sd->taken)
 869                         continue;
 870
 871                 if (strcmp(tok, sd->name))
 872                         continue;
 873
 874                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
 875                 sd->taken = 1;
 876                 return 0;
 877         }
 878
 879         return -ESRCH;
 880 }
 881
 882 static void setup_sorting(void)
 883 {
 884         char *tmp, *tok, *str = strdup(sort_order);
 885
 886         for (tok = strtok_r(str, ", ", &tmp);
 887                         tok; tok = strtok_r(NULL, ", ", &tmp))
 888                 sort_dimension__add(tok);
 889
 890         free(str);
 891 }
 892
 893 static int64_t
 894 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 895 {
 896         struct sort_entry *se;
 897         int64_t cmp = 0;
 898
 899         list_for_each_entry(se, &hist_entry__sort_list, list) {
 900                 cmp = se->cmp(left, right);
 901                 if (cmp)
 902                         break;
 903         }
 904
 905         return cmp;
 906 }
 907
 908 static size_t
 909 hist_entry__fprintf(FILE *fp, struct hist_entry *self, uint64_t total_samples)
 910 {
 911         struct sort_entry *se;
 912         size_t ret;
 913
 914         if (total_samples) {
 915                 ret = fprintf(fp, "    %5.2f%%",
 916                                 (self->count * 100.0) / total_samples);
 917         } else
 918                 ret = fprintf(fp, "%12d ", self->count);
 919
 920         list_for_each_entry(se, &hist_entry__sort_list, list)
 921                 ret += se->print(fp, self);
 922
 923         ret += fprintf(fp, "\n");
 924
 925         return ret;
 926 }
 927
 928 /*
 929  * collect histogram counts
 930  */
 931
 932 static int
 933 hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
 934                 struct symbol *sym, uint64_t ip, char level)
 935 {
 936         struct rb_node **p = &hist.rb_node;
 937         struct rb_node *parent = NULL;
 938         struct hist_entry *he;
 939         struct hist_entry entry = {
 940                 .thread = thread,
 941                 .map    = map,
 942                 .dso    = dso,
 943                 .sym    = sym,
 944                 .ip     = ip,
 945                 .level  = level,
 946                 .count  = 1,
 947         };
 948         int cmp;
 949
 950         while (*p != NULL) {
 951                 parent = *p;
 952                 he = rb_entry(parent, struct hist_entry, rb_node);
 953
 954                 cmp = hist_entry__cmp(&entry, he);
 955
 956                 if (!cmp) {
 957                         he->count++;
 958                         return 0;
 959                 }
 960
 961                 if (cmp < 0)
 962                         p = &(*p)->rb_left;
 963                 else
 964                         p = &(*p)->rb_right;
 965         }
 966
 967         he = malloc(sizeof(*he));
 968         if (!he)
 969                 return -ENOMEM;
 970         *he = entry;
 971         rb_link_node(&he->rb_node, parent, p);
 972         rb_insert_color(&he->rb_node, &hist);
 973
 974         return 0;
 975 }
 976
 977 /*
 978  * reverse the map, sort on count.
 979  */
 980
 981 static struct rb_root output_hists;
 982
 983 static void output__insert_entry(struct hist_entry *he)
 984 {
 985         struct rb_node **p = &output_hists.rb_node;
 986         struct rb_node *parent = NULL;
 987         struct hist_entry *iter;
 988
 989         while (*p != NULL) {
 990                 parent = *p;
 991                 iter = rb_entry(parent, struct hist_entry, rb_node);
 992
 993                 if (he->count > iter->count)
 994                         p = &(*p)->rb_left;
 995                 else
 996                         p = &(*p)->rb_right;
 997         }
 998
 999         rb_link_node(&he->rb_node, parent, p);
1000         rb_insert_color(&he->rb_node, &output_hists);
1001 }
1002
1003 static void output__resort(void)
1004 {
1005         struct rb_node *next = rb_first(&hist);
1006         struct hist_entry *n;
1007
1008         while (next) {
1009                 n = rb_entry(next, struct hist_entry, rb_node);
1010                 next = rb_next(&n->rb_node);
1011
1012                 rb_erase(&n->rb_node, &hist);
1013                 output__insert_entry(n);
1014         }
1015 }
1016
1017 static size_t output__fprintf(FILE *fp, uint64_t total_samples)
1018 {
1019         struct hist_entry *pos;
1020         struct sort_entry *se;
1021         struct rb_node *nd;
1022         size_t ret = 0;
1023
1024         list_for_each_entry(se, &hist_entry__sort_list, list) {
1025                 if (se->print_header)
1026                         ret += se->print_header(fp);
1027         }
1028
1029         for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
1030                 pos = rb_entry(nd, struct hist_entry, rb_node);
1031                 ret += hist_entry__fprintf(fp, pos, total_samples);
1032         }
1033
1034         return ret;
1035 }
1036
1037
1038 static int __cmd_report(void)
1039 {
1040         unsigned long offset = 0;
1041         unsigned long head = 0;
1042         struct stat stat;
1043         char *buf;
1044         event_t *event;
1045         int ret, rc = EXIT_FAILURE;
1046         uint32_t size;
1047         unsigned long total = 0, total_mmap = 0, total_comm = 0, total_unknown = 0;
1048
1049         input = open(input_name, O_RDONLY);
1050         if (input < 0) {
1051                 perror("failed to open file");
1052                 exit(-1);
1053         }
1054
1055         ret = fstat(input, &stat);
1056         if (ret < 0) {
1057                 perror("failed to stat file");
1058                 exit(-1);
1059         }
1060
1061         if (!stat.st_size) {
1062                 fprintf(stderr, "zero-sized file, nothing to do!\n");
1063                 exit(0);
1064         }
1065
1066         if (load_kernel() < 0) {
1067                 perror("failed to open kallsyms");
1068                 return EXIT_FAILURE;
1069         }
1070
1071 remap:
1072         buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
1073                            MAP_SHARED, input, offset);
1074         if (buf == MAP_FAILED) {
1075                 perror("failed to mmap file");
1076                 exit(-1);
1077         }
1078
1079 more:
1080         event = (event_t *)(buf + head);
1081
1082         size = event->header.size;
1083         if (!size)
1084                 size = 8;
1085
1086         if (head + event->header.size >= page_size * mmap_window) {
1087                 unsigned long shift = page_size * (head / page_size);
1088                 int ret;
1089
1090                 ret = munmap(buf, page_size * mmap_window);
1091                 assert(ret == 0);
1092
1093                 offset += shift;
1094                 head -= shift;
1095                 goto remap;
1096         }
1097
1098         size = event->header.size;
1099         if (!size)
1100                 goto broken_event;
1101
1102         if (event->header.misc & PERF_EVENT_MISC_OVERFLOW) {
1103                 char level;
1104                 int show = 0;
1105                 struct dso *dso = NULL;
1106                 struct thread *thread = threads__findnew(event->ip.pid);
1107                 uint64_t ip = event->ip.ip;
1108                 struct map *map = NULL;
1109
1110                 if (dump_trace) {
1111                         fprintf(stderr, "%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
1112                                 (void *)(offset + head),
1113                                 (void *)(long)(event->header.size),
1114                                 event->header.misc,
1115                                 event->ip.pid,
1116                                 (void *)(long)ip);
1117                 }
1118
1119                 if (thread == NULL) {
1120                         fprintf(stderr, "problem processing %d event, skipping it.\n",
1121                                 event->header.type);
1122                         goto broken_event;
1123                 }
1124
1125                 if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
1126                         show = SHOW_KERNEL;
1127                         level = 'k';
1128
1129                         dso = kernel_dso;
1130
1131                 } else if (event->header.misc & PERF_EVENT_MISC_USER) {
1132
1133                         show = SHOW_USER;
1134                         level = '.';
1135
1136                         map = thread__find_map(thread, ip);
1137                         if (map != NULL) {
1138                                 dso = map->dso;
1139                                 ip -= map->start + map->pgoff;
1140                         }
1141
1142                 } else {
1143                         show = SHOW_HV;
1144                         level = 'H';
1145                 }
1146
1147                 if (show & show_mask) {
1148                         struct symbol *sym = dso__find_symbol(dso, ip);
1149
1150                         if (hist_entry__add(thread, map, dso, sym, ip, level)) {
1151                                 fprintf(stderr,
1152                 "problem incrementing symbol count, skipping event\n");
1153                                 goto broken_event;
1154                         }
1155                 }
1156                 total++;
1157         } else switch (event->header.type) {
1158         case PERF_EVENT_MMAP: {
1159                 struct thread *thread = threads__findnew(event->mmap.pid);
1160                 struct map *map = map__new(&event->mmap);
1161
1162                 if (dump_trace) {
1163                         fprintf(stderr, "%p [%p]: PERF_EVENT_MMAP: [%p(%p) @ %p]: %s\n",
1164                                 (void *)(offset + head),
1165                                 (void *)(long)(event->header.size),
1166                                 (void *)(long)event->mmap.start,
1167                                 (void *)(long)event->mmap.len,
1168                                 (void *)(long)event->mmap.pgoff,
1169                                 event->mmap.filename);
1170                 }
1171                 if (thread == NULL || map == NULL) {
1172                         fprintf(stderr, "problem processing PERF_EVENT_MMAP, skipping event.\n");
1173                         goto broken_event;
1174                 }
1175                 thread__insert_map(thread, map);
1176                 total_mmap++;
1177                 break;
1178         }
1179         case PERF_EVENT_COMM: {
1180                 struct thread *thread = threads__findnew(event->comm.pid);
1181
1182                 if (dump_trace) {
1183                         fprintf(stderr, "%p [%p]: PERF_EVENT_COMM: %s:%d\n",
1184                                 (void *)(offset + head),
1185                                 (void *)(long)(event->header.size),
1186                                 event->comm.comm, event->comm.pid);
1187                 }
1188                 if (thread == NULL ||
1189                     thread__set_comm(thread, event->comm.comm)) {
1190                         fprintf(stderr, "problem processing PERF_EVENT_COMM, skipping event.\n");
1191                         goto broken_event;
1192                 }
1193                 total_comm++;
1194                 break;
1195         }
1196         default: {
1197 broken_event:
1198                 if (dump_trace)
1199                         fprintf(stderr, "%p [%p]: skipping unknown header type: %d\n",
1200                                         (void *)(offset + head),
1201                                         (void *)(long)(event->header.size),
1202                                         event->header.type);
1203
1204                 total_unknown++;
1205
1206                 /*
1207                  * assume we lost track of the stream, check alignment, and
1208                  * increment a single u64 in the hope to catch on again 'soon'.
1209                  */
1210
1211                 if (unlikely(head & 7))
1212                         head &= ~7ULL;
1213
1214                 size = 8;
1215         }
1216         }
1217
1218         head += size;
1219
1220         if (offset + head < stat.st_size)
1221                 goto more;
1222
1223         rc = EXIT_SUCCESS;
1224         close(input);
1225
1226         if (dump_trace) {
1227                 fprintf(stderr, "      IP events: %10ld\n", total);
1228                 fprintf(stderr, "    mmap events: %10ld\n", total_mmap);
1229                 fprintf(stderr, "    comm events: %10ld\n", total_comm);
1230                 fprintf(stderr, " unknown events: %10ld\n", total_unknown);
1231
1232                 return 0;
1233         }
1234
1235         if (verbose >= 2)
1236                 dsos__fprintf(stdout);
1237
1238         output__resort();
1239         output__fprintf(stdout, total);
1240
1241         return rc;
1242 }
1243
1244 static const char * const report_usage[] = {
1245         "perf report [<options>] <command>",
1246         NULL
1247 };
1248
1249 static const struct option options[] = {
1250         OPT_STRING('i', "input", &input_name, "file",
1251                     "input file name"),
1252         OPT_BOOLEAN('v', "verbose", &verbose,
1253                     "be more verbose (show symbol address, etc)"),
1254         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1255                     "dump raw trace in ASCII"),
1256         OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
1257         OPT_STRING('s', "sort", &sort_order, "foo", "bar"),
1258         OPT_END()
1259 };
1260
1261 int cmd_report(int argc, const char **argv, const char *prefix)
1262 {
1263         elf_version(EV_CURRENT);
1264
1265         page_size = getpagesize();
1266
1267         parse_options(argc, argv, options, report_usage, 0);
1268
1269         setup_sorting();
1270
1271         setup_pager();
1272
1273         return __cmd_report();
1274 }