Documentation/perf_counter/builtin-report.c

   1 #include "util/util.h"
   2 #include "builtin.h"
   3
   4 #include "util/list.h"
   5 #include "util/cache.h"
   6 #include "util/rbtree.h"
   7 #include "util/symbol.h"
   8 #include "util/string.h"
   9
  10 #include "perf.h"
  11
  12 #include "util/parse-options.h"
  13 #include "util/parse-events.h"
  14
  15 #define SHOW_KERNEL     1
  16 #define SHOW_USER       2
  17 #define SHOW_HV         4
  18
  19 static char             const *input_name = "perf.data";
  20 static char             *vmlinux = NULL;
  21 static char             *sort_order = "pid,symbol";
  22 static int              input;
  23 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
  24
  25 static int              dump_trace = 0;
  26 static int              verbose;
  27 static int              full_paths;
  28
  29 static unsigned long    page_size;
  30 static unsigned long    mmap_window = 32;
  31
  32 const char *perf_event_names[] = {
  33         [PERF_EVENT_MMAP]   = " PERF_EVENT_MMAP",
  34         [PERF_EVENT_MUNMAP] = " PERF_EVENT_MUNMAP",
  35         [PERF_EVENT_COMM]   = " PERF_EVENT_COMM",
  36 };
  37
  38 struct ip_event {
  39         struct perf_event_header header;
  40         __u64 ip;
  41         __u32 pid, tid;
  42 };
  43 struct mmap_event {
  44         struct perf_event_header header;
  45         __u32 pid, tid;
  46         __u64 start;
  47         __u64 len;
  48         __u64 pgoff;
  49         char filename[PATH_MAX];
  50 };
  51 struct comm_event {
  52         struct perf_event_header header;
  53         __u32 pid,tid;
  54         char comm[16];
  55 };
  56
  57 typedef union event_union {
  58         struct perf_event_header header;
  59         struct ip_event ip;
  60         struct mmap_event mmap;
  61         struct comm_event comm;
  62 } event_t;
  63
  64 static LIST_HEAD(dsos);
  65 static struct dso *kernel_dso;
  66
  67 static void dsos__add(struct dso *dso)
  68 {
  69         list_add_tail(&dso->node, &dsos);
  70 }
  71
  72 static struct dso *dsos__find(const char *name)
  73 {
  74         struct dso *pos;
  75
  76         list_for_each_entry(pos, &dsos, node)
  77                 if (strcmp(pos->name, name) == 0)
  78                         return pos;
  79         return NULL;
  80 }
  81
  82 static struct dso *dsos__findnew(const char *name)
  83 {
  84         struct dso *dso = dsos__find(name);
  85         int nr;
  86
  87         if (dso == NULL) {
  88                 dso = dso__new(name, 0);
  89                 if (!dso)
  90                         goto out_delete_dso;
  91
  92                 nr = dso__load(dso, NULL);
  93                 if (nr < 0) {
  94                         fprintf(stderr, "Failed to open: %s\n", name);
  95                         goto out_delete_dso;
  96                 }
  97                 if (!nr) {
  98                         fprintf(stderr,
  99                 "Failed to find debug symbols for: %s, maybe install a debug package?\n",
 100                                         name);
 101                 }
 102
 103                 dsos__add(dso);
 104         }
 105
 106         return dso;
 107
 108 out_delete_dso:
 109         dso__delete(dso);
 110         return NULL;
 111 }
 112
 113 static void dsos__fprintf(FILE *fp)
 114 {
 115         struct dso *pos;
 116
 117         list_for_each_entry(pos, &dsos, node)
 118                 dso__fprintf(pos, fp);
 119 }
 120
 121 static int load_kernel(void)
 122 {
 123         int err;
 124
 125         kernel_dso = dso__new("[kernel]", 0);
 126         if (!kernel_dso)
 127                 return -1;
 128
 129         err = dso__load_kernel(kernel_dso, vmlinux, NULL);
 130         if (err) {
 131                 dso__delete(kernel_dso);
 132                 kernel_dso = NULL;
 133         } else
 134                 dsos__add(kernel_dso);
 135
 136         return err;
 137 }
 138
 139 static int strcommon(const char *pathname, const char *cwd, int cwdlen)
 140 {
 141         int n = 0;
 142
 143         while (pathname[n] == cwd[n] && n < cwdlen)
 144                 ++n;
 145
 146         return n;
 147 }
 148
 149 struct map {
 150         struct list_head node;
 151         uint64_t         start;
 152         uint64_t         end;
 153         uint64_t         pgoff;
 154         struct dso       *dso;
 155 };
 156
 157 static struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen)
 158 {
 159         struct map *self = malloc(sizeof(*self));
 160
 161         if (self != NULL) {
 162                 const char *filename = event->filename;
 163                 char newfilename[PATH_MAX];
 164
 165                 if (cwd) {
 166                         int n = strcommon(filename, cwd, cwdlen);
 167                         if (n == cwdlen) {
 168                                 snprintf(newfilename, sizeof(newfilename),
 169                                          ".%s", filename + n);
 170                                 filename = newfilename;
 171                         }
 172                 }
 173
 174                 self->start = event->start;
 175                 self->end   = event->start + event->len;
 176                 self->pgoff = event->pgoff;
 177
 178                 self->dso = dsos__findnew(filename);
 179                 if (self->dso == NULL)
 180                         goto out_delete;
 181         }
 182         return self;
 183 out_delete:
 184         free(self);
 185         return NULL;
 186 }
 187
 188 struct thread;
 189
 190 struct thread {
 191         struct rb_node   rb_node;
 192         struct list_head maps;
 193         pid_t            pid;
 194         char             *comm;
 195 };
 196
 197 static struct thread *thread__new(pid_t pid)
 198 {
 199         struct thread *self = malloc(sizeof(*self));
 200
 201         if (self != NULL) {
 202                 self->pid = pid;
 203                 self->comm = NULL;
 204                 INIT_LIST_HEAD(&self->maps);
 205         }
 206
 207         return self;
 208 }
 209
 210 static int thread__set_comm(struct thread *self, const char *comm)
 211 {
 212         self->comm = strdup(comm);
 213         return self->comm ? 0 : -ENOMEM;
 214 }
 215
 216 static struct rb_root threads;
 217
 218 static struct thread *threads__findnew(pid_t pid)
 219 {
 220         struct rb_node **p = &threads.rb_node;
 221         struct rb_node *parent = NULL;
 222         struct thread *th;
 223
 224         while (*p != NULL) {
 225                 parent = *p;
 226                 th = rb_entry(parent, struct thread, rb_node);
 227
 228                 if (th->pid == pid)
 229                         return th;
 230
 231                 if (pid < th->pid)
 232                         p = &(*p)->rb_left;
 233                 else
 234                         p = &(*p)->rb_right;
 235         }
 236
 237         th = thread__new(pid);
 238         if (th != NULL) {
 239                 rb_link_node(&th->rb_node, parent, p);
 240                 rb_insert_color(&th->rb_node, &threads);
 241         }
 242         return th;
 243 }
 244
 245 static void thread__insert_map(struct thread *self, struct map *map)
 246 {
 247         list_add_tail(&map->node, &self->maps);
 248 }
 249
 250 static struct map *thread__find_map(struct thread *self, uint64_t ip)
 251 {
 252         struct map *pos;
 253
 254         if (self == NULL)
 255                 return NULL;
 256
 257         list_for_each_entry(pos, &self->maps, node)
 258                 if (ip >= pos->start && ip <= pos->end)
 259                         return pos;
 260
 261         return NULL;
 262 }
 263
 264 /*
 265  * histogram, sorted on item, collects counts
 266  */
 267
 268 static struct rb_root hist;
 269
 270 struct hist_entry {
 271         struct rb_node   rb_node;
 272
 273         struct thread    *thread;
 274         struct map       *map;
 275         struct dso       *dso;
 276         struct symbol    *sym;
 277         uint64_t         ip;
 278         char             level;
 279
 280         uint32_t         count;
 281 };
 282
 283 /*
 284  * configurable sorting bits
 285  */
 286
 287 struct sort_entry {
 288         struct list_head list;
 289
 290         char *header;
 291
 292         int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
 293         size_t  (*print)(FILE *fp, struct hist_entry *);
 294 };
 295
 296 static int64_t
 297 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
 298 {
 299         return right->thread->pid - left->thread->pid;
 300 }
 301
 302 static size_t
 303 sort__thread_print(FILE *fp, struct hist_entry *self)
 304 {
 305         return fprintf(fp, " %16s:%5d", self->thread->comm ?: "", self->thread->pid);
 306 }
 307
 308 static struct sort_entry sort_thread = {
 309         .header = "         Command: Pid ",
 310         .cmp    = sort__thread_cmp,
 311         .print  = sort__thread_print,
 312 };
 313
 314 static int64_t
 315 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
 316 {
 317         char *comm_l = left->thread->comm;
 318         char *comm_r = right->thread->comm;
 319
 320         if (!comm_l || !comm_r) {
 321                 if (!comm_l && !comm_r)
 322                         return 0;
 323                 else if (!comm_l)
 324                         return -1;
 325                 else
 326                         return 1;
 327         }
 328
 329         return strcmp(comm_l, comm_r);
 330 }
 331
 332 static size_t
 333 sort__comm_print(FILE *fp, struct hist_entry *self)
 334 {
 335         return fprintf(fp, " %16s", self->thread->comm ?: "<unknown>");
 336 }
 337
 338 static struct sort_entry sort_comm = {
 339         .header = "         Command",
 340         .cmp    = sort__comm_cmp,
 341         .print  = sort__comm_print,
 342 };
 343
 344 static int64_t
 345 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 346 {
 347         struct dso *dso_l = left->dso;
 348         struct dso *dso_r = right->dso;
 349
 350         if (!dso_l || !dso_r) {
 351                 if (!dso_l && !dso_r)
 352                         return 0;
 353                 else if (!dso_l)
 354                         return -1;
 355                 else
 356                         return 1;
 357         }
 358
 359         return strcmp(dso_l->name, dso_r->name);
 360 }
 361
 362 static size_t
 363 sort__dso_print(FILE *fp, struct hist_entry *self)
 364 {
 365         return fprintf(fp, " %64s", self->dso ? self->dso->name : "<unknown>");
 366 }
 367
 368 static struct sort_entry sort_dso = {
 369         .header = "                                                    Shared Object",
 370         .cmp    = sort__dso_cmp,
 371         .print  = sort__dso_print,
 372 };
 373
 374 static int64_t
 375 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 376 {
 377         uint64_t ip_l, ip_r;
 378
 379         if (left->sym == right->sym)
 380                 return 0;
 381
 382         ip_l = left->sym ? left->sym->start : left->ip;
 383         ip_r = right->sym ? right->sym->start : right->ip;
 384
 385         return (int64_t)(ip_r - ip_l);
 386 }
 387
 388 static size_t
 389 sort__sym_print(FILE *fp, struct hist_entry *self)
 390 {
 391         size_t ret = 0;
 392
 393         if (verbose)
 394                 ret += fprintf(fp, " %#018llx", (unsigned long long)self->ip);
 395
 396         ret += fprintf(fp, " %s: %s",
 397                         self->dso ? self->dso->name : "<unknown>",
 398                         self->sym ? self->sym->name : "<unknown>");
 399
 400         return ret;
 401 }
 402
 403 static struct sort_entry sort_sym = {
 404         .header = "Shared Object: Symbol",
 405         .cmp    = sort__sym_cmp,
 406         .print  = sort__sym_print,
 407 };
 408
 409 struct sort_dimension {
 410         char *name;
 411         struct sort_entry *entry;
 412         int taken;
 413 };
 414
 415 static struct sort_dimension sort_dimensions[] = {
 416         { .name = "pid",        .entry = &sort_thread,  },
 417         { .name = "comm",       .entry = &sort_comm,    },
 418         { .name = "dso",        .entry = &sort_dso,     },
 419         { .name = "symbol",     .entry = &sort_sym,     },
 420 };
 421
 422 static LIST_HEAD(hist_entry__sort_list);
 423
 424 static int sort_dimension__add(char *tok)
 425 {
 426         int i;
 427
 428         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
 429                 struct sort_dimension *sd = &sort_dimensions[i];
 430
 431                 if (sd->taken)
 432                         continue;
 433
 434                 if (strcmp(tok, sd->name))
 435                         continue;
 436
 437                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
 438                 sd->taken = 1;
 439                 return 0;
 440         }
 441
 442         return -ESRCH;
 443 }
 444
 445 static void setup_sorting(void)
 446 {
 447         char *tmp, *tok, *str = strdup(sort_order);
 448
 449         for (tok = strtok_r(str, ", ", &tmp);
 450                         tok; tok = strtok_r(NULL, ", ", &tmp))
 451                 sort_dimension__add(tok);
 452
 453         free(str);
 454 }
 455
 456 static int64_t
 457 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 458 {
 459         struct sort_entry *se;
 460         int64_t cmp = 0;
 461
 462         list_for_each_entry(se, &hist_entry__sort_list, list) {
 463                 cmp = se->cmp(left, right);
 464                 if (cmp)
 465                         break;
 466         }
 467
 468         return cmp;
 469 }
 470
 471 static size_t
 472 hist_entry__fprintf(FILE *fp, struct hist_entry *self, uint64_t total_samples)
 473 {
 474         struct sort_entry *se;
 475         size_t ret;
 476
 477         if (total_samples) {
 478                 ret = fprintf(fp, "    %5.2f%%",
 479                                 (self->count * 100.0) / total_samples);
 480         } else
 481                 ret = fprintf(fp, "%12d ", self->count);
 482
 483         list_for_each_entry(se, &hist_entry__sort_list, list)
 484                 ret += se->print(fp, self);
 485
 486         ret += fprintf(fp, "\n");
 487
 488         return ret;
 489 }
 490
 491 /*
 492  * collect histogram counts
 493  */
 494
 495 static int
 496 hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
 497                 struct symbol *sym, uint64_t ip, char level)
 498 {
 499         struct rb_node **p = &hist.rb_node;
 500         struct rb_node *parent = NULL;
 501         struct hist_entry *he;
 502         struct hist_entry entry = {
 503                 .thread = thread,
 504                 .map    = map,
 505                 .dso    = dso,
 506                 .sym    = sym,
 507                 .ip     = ip,
 508                 .level  = level,
 509                 .count  = 1,
 510         };
 511         int cmp;
 512
 513         while (*p != NULL) {
 514                 parent = *p;
 515                 he = rb_entry(parent, struct hist_entry, rb_node);
 516
 517                 cmp = hist_entry__cmp(&entry, he);
 518
 519                 if (!cmp) {
 520                         he->count++;
 521                         return 0;
 522                 }
 523
 524                 if (cmp < 0)
 525                         p = &(*p)->rb_left;
 526                 else
 527                         p = &(*p)->rb_right;
 528         }
 529
 530         he = malloc(sizeof(*he));
 531         if (!he)
 532                 return -ENOMEM;
 533         *he = entry;
 534         rb_link_node(&he->rb_node, parent, p);
 535         rb_insert_color(&he->rb_node, &hist);
 536
 537         return 0;
 538 }
 539
 540 /*
 541  * reverse the map, sort on count.
 542  */
 543
 544 static struct rb_root output_hists;
 545
 546 static void output__insert_entry(struct hist_entry *he)
 547 {
 548         struct rb_node **p = &output_hists.rb_node;
 549         struct rb_node *parent = NULL;
 550         struct hist_entry *iter;
 551
 552         while (*p != NULL) {
 553                 parent = *p;
 554                 iter = rb_entry(parent, struct hist_entry, rb_node);
 555
 556                 if (he->count > iter->count)
 557                         p = &(*p)->rb_left;
 558                 else
 559                         p = &(*p)->rb_right;
 560         }
 561
 562         rb_link_node(&he->rb_node, parent, p);
 563         rb_insert_color(&he->rb_node, &output_hists);
 564 }
 565
 566 static void output__resort(void)
 567 {
 568         struct rb_node *next = rb_first(&hist);
 569         struct hist_entry *n;
 570
 571         while (next) {
 572                 n = rb_entry(next, struct hist_entry, rb_node);
 573                 next = rb_next(&n->rb_node);
 574
 575                 rb_erase(&n->rb_node, &hist);
 576                 output__insert_entry(n);
 577         }
 578 }
 579
 580 static size_t output__fprintf(FILE *fp, uint64_t total_samples)
 581 {
 582         struct hist_entry *pos;
 583         struct sort_entry *se;
 584         struct rb_node *nd;
 585         size_t ret = 0;
 586
 587         fprintf(fp, "#\n");
 588
 589         fprintf(fp, "# Overhead");
 590         list_for_each_entry(se, &hist_entry__sort_list, list)
 591                 fprintf(fp, " %s", se->header);
 592         fprintf(fp, "\n");
 593
 594         fprintf(fp, "# ........");
 595         list_for_each_entry(se, &hist_entry__sort_list, list) {
 596                 int i;
 597
 598                 fprintf(fp, " ");
 599                 for (i = 0; i < strlen(se->header); i++)
 600                         fprintf(fp, ".");
 601         }
 602         fprintf(fp, "\n");
 603
 604         fprintf(fp, "#\n");
 605
 606         for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
 607                 pos = rb_entry(nd, struct hist_entry, rb_node);
 608                 ret += hist_entry__fprintf(fp, pos, total_samples);
 609         }
 610
 611         return ret;
 612 }
 613
 614
 615 static int __cmd_report(void)
 616 {
 617         unsigned long offset = 0;
 618         unsigned long head = 0;
 619         struct stat stat;
 620         char *buf;
 621         event_t *event;
 622         int ret, rc = EXIT_FAILURE;
 623         uint32_t size;
 624         unsigned long total = 0, total_mmap = 0, total_comm = 0, total_unknown = 0;
 625         char cwd[PATH_MAX], *cwdp = cwd;
 626         int cwdlen;
 627
 628         input = open(input_name, O_RDONLY);
 629         if (input < 0) {
 630                 perror("failed to open file");
 631                 exit(-1);
 632         }
 633
 634         ret = fstat(input, &stat);
 635         if (ret < 0) {
 636                 perror("failed to stat file");
 637                 exit(-1);
 638         }
 639
 640         if (!stat.st_size) {
 641                 fprintf(stderr, "zero-sized file, nothing to do!\n");
 642                 exit(0);
 643         }
 644
 645         if (load_kernel() < 0) {
 646                 perror("failed to load kernel symbols");
 647                 return EXIT_FAILURE;
 648         }
 649
 650         if (!full_paths) {
 651                 if (getcwd(cwd, sizeof(cwd)) == NULL) {
 652                         perror("failed to get the current directory");
 653                         return EXIT_FAILURE;
 654                 }
 655                 cwdlen = strlen(cwd);
 656         } else {
 657                 cwdp = NULL;
 658                 cwdlen = 0;
 659         }
 660 remap:
 661         buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
 662                            MAP_SHARED, input, offset);
 663         if (buf == MAP_FAILED) {
 664                 perror("failed to mmap file");
 665                 exit(-1);
 666         }
 667
 668 more:
 669         event = (event_t *)(buf + head);
 670
 671         size = event->header.size;
 672         if (!size)
 673                 size = 8;
 674
 675         if (head + event->header.size >= page_size * mmap_window) {
 676                 unsigned long shift = page_size * (head / page_size);
 677                 int ret;
 678
 679                 ret = munmap(buf, page_size * mmap_window);
 680                 assert(ret == 0);
 681
 682                 offset += shift;
 683                 head -= shift;
 684                 goto remap;
 685         }
 686
 687         size = event->header.size;
 688         if (!size)
 689                 goto broken_event;
 690
 691         if (event->header.misc & PERF_EVENT_MISC_OVERFLOW) {
 692                 char level;
 693                 int show = 0;
 694                 struct dso *dso = NULL;
 695                 struct thread *thread = threads__findnew(event->ip.pid);
 696                 uint64_t ip = event->ip.ip;
 697                 struct map *map = NULL;
 698
 699                 if (dump_trace) {
 700                         fprintf(stderr, "%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
 701                                 (void *)(offset + head),
 702                                 (void *)(long)(event->header.size),
 703                                 event->header.misc,
 704                                 event->ip.pid,
 705                                 (void *)(long)ip);
 706                 }
 707
 708                 if (thread == NULL) {
 709                         fprintf(stderr, "problem processing %d event, skipping it.\n",
 710                                 event->header.type);
 711                         goto broken_event;
 712                 }
 713
 714                 if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
 715                         show = SHOW_KERNEL;
 716                         level = 'k';
 717
 718                         dso = kernel_dso;
 719
 720                 } else if (event->header.misc & PERF_EVENT_MISC_USER) {
 721
 722                         show = SHOW_USER;
 723                         level = '.';
 724
 725                         map = thread__find_map(thread, ip);
 726                         if (map != NULL) {
 727                                 dso = map->dso;
 728                                 ip -= map->start + map->pgoff;
 729                         }
 730
 731                 } else {
 732                         show = SHOW_HV;
 733                         level = 'H';
 734                 }
 735
 736                 if (show & show_mask) {
 737                         struct symbol *sym = dso__find_symbol(dso, ip);
 738
 739                         if (hist_entry__add(thread, map, dso, sym, ip, level)) {
 740                                 fprintf(stderr,
 741                 "problem incrementing symbol count, skipping event\n");
 742                                 goto broken_event;
 743                         }
 744                 }
 745                 total++;
 746         } else switch (event->header.type) {
 747         case PERF_EVENT_MMAP: {
 748                 struct thread *thread = threads__findnew(event->mmap.pid);
 749                 struct map *map = map__new(&event->mmap, cwdp, cwdlen);
 750
 751                 if (dump_trace) {
 752                         fprintf(stderr, "%p [%p]: PERF_EVENT_MMAP: [%p(%p) @ %p]: %s\n",
 753                                 (void *)(offset + head),
 754                                 (void *)(long)(event->header.size),
 755                                 (void *)(long)event->mmap.start,
 756                                 (void *)(long)event->mmap.len,
 757                                 (void *)(long)event->mmap.pgoff,
 758                                 event->mmap.filename);
 759                 }
 760                 if (thread == NULL || map == NULL) {
 761                         fprintf(stderr, "problem processing PERF_EVENT_MMAP, skipping event.\n");
 762                         goto broken_event;
 763                 }
 764                 thread__insert_map(thread, map);
 765                 total_mmap++;
 766                 break;
 767         }
 768         case PERF_EVENT_COMM: {
 769                 struct thread *thread = threads__findnew(event->comm.pid);
 770
 771                 if (dump_trace) {
 772                         fprintf(stderr, "%p [%p]: PERF_EVENT_COMM: %s:%d\n",
 773                                 (void *)(offset + head),
 774                                 (void *)(long)(event->header.size),
 775                                 event->comm.comm, event->comm.pid);
 776                 }
 777                 if (thread == NULL ||
 778                     thread__set_comm(thread, event->comm.comm)) {
 779                         fprintf(stderr, "problem processing PERF_EVENT_COMM, skipping event.\n");
 780                         goto broken_event;
 781                 }
 782                 total_comm++;
 783                 break;
 784         }
 785         default: {
 786 broken_event:
 787                 if (dump_trace)
 788                         fprintf(stderr, "%p [%p]: skipping unknown header type: %d\n",
 789                                         (void *)(offset + head),
 790                                         (void *)(long)(event->header.size),
 791                                         event->header.type);
 792
 793                 total_unknown++;
 794
 795                 /*
 796                  * assume we lost track of the stream, check alignment, and
 797                  * increment a single u64 in the hope to catch on again 'soon'.
 798                  */
 799
 800                 if (unlikely(head & 7))
 801                         head &= ~7ULL;
 802
 803                 size = 8;
 804         }
 805         }
 806
 807         head += size;
 808
 809         if (offset + head < stat.st_size)
 810                 goto more;
 811
 812         rc = EXIT_SUCCESS;
 813         close(input);
 814
 815         if (dump_trace) {
 816                 fprintf(stderr, "      IP events: %10ld\n", total);
 817                 fprintf(stderr, "    mmap events: %10ld\n", total_mmap);
 818                 fprintf(stderr, "    comm events: %10ld\n", total_comm);
 819                 fprintf(stderr, " unknown events: %10ld\n", total_unknown);
 820
 821                 return 0;
 822         }
 823
 824         if (verbose >= 2)
 825                 dsos__fprintf(stdout);
 826
 827         output__resort();
 828         output__fprintf(stdout, total);
 829
 830         return rc;
 831 }
 832
 833 static const char * const report_usage[] = {
 834         "perf report [<options>] <command>",
 835         NULL
 836 };
 837
 838 static const struct option options[] = {
 839         OPT_STRING('i', "input", &input_name, "file",
 840                     "input file name"),
 841         OPT_BOOLEAN('v', "verbose", &verbose,
 842                     "be more verbose (show symbol address, etc)"),
 843         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 844                     "dump raw trace in ASCII"),
 845         OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
 846         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 847                    "sort by key(s): pid, comm, dso, symbol. Default: pid,symbol"),
 848         OPT_BOOLEAN('P', "full-paths", &full_paths,
 849                     "Don't shorten the pathnames taking into account the cwd"),
 850         OPT_END()
 851 };
 852
 853 int cmd_report(int argc, const char **argv, const char *prefix)
 854 {
 855         symbol__init();
 856
 857         page_size = getpagesize();
 858
 859         parse_options(argc, argv, options, report_usage, 0);
 860
 861         setup_sorting();
 862
 863         setup_pager();
 864
 865         return __cmd_report();
 866 }