Documentation/perf_counter/builtin-report.c

   1 #include "util/util.h"
   2
   3 #include <libelf.h>
   4 #include <gelf.h>
   5 #include <elf.h>
   6
   7 #include "util/list.h"
   8 #include "util/rbtree.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 = "output.perf";
  20 static int              input;
  21 static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
  22
  23 static unsigned long    page_size;
  24 static unsigned long    mmap_window = 32;
  25
  26 const char *perf_event_names[] = {
  27         [PERF_EVENT_MMAP]   = " PERF_EVENT_MMAP",
  28         [PERF_EVENT_MUNMAP] = " PERF_EVENT_MUNMAP",
  29         [PERF_EVENT_COMM]   = " PERF_EVENT_COMM",
  30 };
  31
  32 struct ip_event {
  33         struct perf_event_header header;
  34         __u64 ip;
  35         __u32 pid, tid;
  36 };
  37 struct mmap_event {
  38         struct perf_event_header header;
  39         __u32 pid, tid;
  40         __u64 start;
  41         __u64 len;
  42         __u64 pgoff;
  43         char filename[PATH_MAX];
  44 };
  45 struct comm_event {
  46         struct perf_event_header header;
  47         __u32 pid,tid;
  48         char comm[16];
  49 };
  50
  51 typedef union event_union {
  52         struct perf_event_header header;
  53         struct ip_event ip;
  54         struct mmap_event mmap;
  55         struct comm_event comm;
  56 } event_t;
  57
  58 struct symbol {
  59         struct rb_node rb_node;
  60         uint64_t       start;
  61         uint64_t       end;
  62         char           name[0];
  63 };
  64
  65 static struct symbol *symbol__new(uint64_t start, uint64_t len, const char *name)
  66 {
  67         struct symbol *self = malloc(sizeof(*self) + strlen(name) + 1);
  68
  69         if (self != NULL) {
  70                 self->start = start;
  71                 self->end   = start + len;
  72                 strcpy(self->name, name);
  73         }
  74
  75         return self;
  76 }
  77
  78 static void symbol__delete(struct symbol *self)
  79 {
  80         free(self);
  81 }
  82
  83 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
  84 {
  85         return fprintf(fp, " %lx-%lx %s\n",
  86                        self->start, self->end, self->name);
  87 }
  88
  89 struct dso {
  90         struct list_head node;
  91         struct rb_root   syms;
  92         char             name[0];
  93 };
  94
  95 static struct dso *dso__new(const char *name)
  96 {
  97         struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
  98
  99         if (self != NULL) {
 100                 strcpy(self->name, name);
 101                 self->syms = RB_ROOT;
 102         }
 103
 104         return self;
 105 }
 106
 107 static void dso__delete_symbols(struct dso *self)
 108 {
 109         struct symbol *pos;
 110         struct rb_node *next = rb_first(&self->syms);
 111
 112         while (next) {
 113                 pos = rb_entry(next, struct symbol, rb_node);
 114                 next = rb_next(&pos->rb_node);
 115                 symbol__delete(pos);
 116         }
 117 }
 118
 119 static void dso__delete(struct dso *self)
 120 {
 121         dso__delete_symbols(self);
 122         free(self);
 123 }
 124
 125 static void dso__insert_symbol(struct dso *self, struct symbol *sym)
 126 {
 127         struct rb_node **p = &self->syms.rb_node;
 128         struct rb_node *parent = NULL;
 129         const uint64_t ip = sym->start;
 130         struct symbol *s;
 131
 132         while (*p != NULL) {
 133                 parent = *p;
 134                 s = rb_entry(parent, struct symbol, rb_node);
 135                 if (ip < s->start)
 136                         p = &(*p)->rb_left;
 137                 else
 138                         p = &(*p)->rb_right;
 139         }
 140         rb_link_node(&sym->rb_node, parent, p);
 141         rb_insert_color(&sym->rb_node, &self->syms);
 142 }
 143
 144 static struct symbol *dso__find_symbol(struct dso *self, uint64_t ip)
 145 {
 146         if (self == NULL)
 147                 return NULL;
 148
 149         struct rb_node *n = self->syms.rb_node;
 150
 151         while (n) {
 152                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 153
 154                 if (ip < s->start)
 155                         n = n->rb_left;
 156                 else if (ip > s->end)
 157                         n = n->rb_right;
 158                 else
 159                         return s;
 160         }
 161
 162         return NULL;
 163 }
 164
 165 /**
 166  * elf_symtab__for_each_symbol - iterate thru all the symbols
 167  *
 168  * @self: struct elf_symtab instance to iterate
 169  * @index: uint32_t index
 170  * @sym: GElf_Sym iterator
 171  */
 172 #define elf_symtab__for_each_symbol(syms, nr_syms, index, sym) \
 173         for (index = 0, gelf_getsym(syms, index, &sym);\
 174              index < nr_syms; \
 175              index++, gelf_getsym(syms, index, &sym))
 176
 177 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 178 {
 179         return GELF_ST_TYPE(sym->st_info);
 180 }
 181
 182 static inline int elf_sym__is_function(const GElf_Sym *sym)
 183 {
 184         return elf_sym__type(sym) == STT_FUNC &&
 185                sym->st_name != 0 &&
 186                sym->st_shndx != SHN_UNDEF;
 187 }
 188
 189 static inline const char *elf_sym__name(const GElf_Sym *sym,
 190                                         const Elf_Data *symstrs)
 191 {
 192         return symstrs->d_buf + sym->st_name;
 193 }
 194
 195 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 196                                     GElf_Shdr *shp, const char *name,
 197                                     size_t *index)
 198 {
 199         Elf_Scn *sec = NULL;
 200         size_t cnt = 1;
 201
 202         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 203                 char *str;
 204
 205                 gelf_getshdr(sec, shp);
 206                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 207                 if (!strcmp(name, str)) {
 208                         if (index)
 209                                 *index = cnt;
 210                         break;
 211                 }
 212                 ++cnt;
 213         }
 214
 215         return sec;
 216 }
 217
 218 static int dso__load(struct dso *self)
 219 {
 220         int fd = open(self->name, O_RDONLY), err = -1;
 221
 222         if (fd == -1)
 223                 return -1;
 224
 225         Elf *elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
 226         if (elf == NULL) {
 227                 fprintf(stderr, "%s: cannot read %s ELF file.\n",
 228                         __func__, self->name);
 229                 goto out_close;
 230         }
 231
 232         GElf_Ehdr ehdr;
 233         if (gelf_getehdr(elf, &ehdr) == NULL) {
 234                 fprintf(stderr, "%s: cannot get elf header.\n", __func__);
 235                 goto out_elf_end;
 236         }
 237
 238         GElf_Shdr shdr;
 239         Elf_Scn *sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 240         if (sec == NULL)
 241                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 242
 243         if (sec == NULL)
 244                 goto out_elf_end;
 245
 246         Elf_Data *syms = elf_getdata(sec, NULL);
 247         if (syms == NULL)
 248                 goto out_elf_end;
 249
 250         sec = elf_getscn(elf, shdr.sh_link);
 251         if (sec == NULL)
 252                 goto out_elf_end;
 253
 254         Elf_Data *symstrs = elf_getdata(sec, NULL);
 255         if (symstrs == NULL)
 256                 goto out_elf_end;
 257
 258         const uint32_t nr_syms = shdr.sh_size / shdr.sh_entsize;
 259
 260         GElf_Sym sym;
 261         uint32_t index;
 262         elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
 263                 struct symbol *f;
 264
 265                 if (!elf_sym__is_function(&sym))
 266                         continue;
 267
 268                 sec = elf_getscn(elf, sym.st_shndx);
 269                 if (!sec)
 270                         goto out_elf_end;
 271
 272                 gelf_getshdr(sec, &shdr);
 273                 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 274
 275                 f = symbol__new(sym.st_value, sym.st_size,
 276                                 elf_sym__name(&sym, symstrs));
 277                 if (!f)
 278                         goto out_elf_end;
 279
 280                 dso__insert_symbol(self, f);
 281         }
 282
 283         err = 0;
 284 out_elf_end:
 285         elf_end(elf);
 286 out_close:
 287         close(fd);
 288         return err;
 289 }
 290
 291 static size_t dso__fprintf(struct dso *self, FILE *fp)
 292 {
 293         size_t ret = fprintf(fp, "dso: %s\n", self->name);
 294
 295         struct rb_node *nd;
 296         for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
 297                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 298                 ret += symbol__fprintf(pos, fp);
 299         }
 300
 301         return ret;
 302 }
 303
 304 static LIST_HEAD(dsos);
 305 static struct dso *kernel_dso;
 306
 307 static void dsos__add(struct dso *dso)
 308 {
 309         list_add_tail(&dso->node, &dsos);
 310 }
 311
 312 static struct dso *dsos__find(const char *name)
 313 {
 314         struct dso *pos;
 315
 316         list_for_each_entry(pos, &dsos, node)
 317                 if (strcmp(pos->name, name) == 0)
 318                         return pos;
 319         return NULL;
 320 }
 321
 322 static struct dso *dsos__findnew(const char *name)
 323 {
 324         struct dso *dso = dsos__find(name);
 325
 326         if (dso == NULL) {
 327                 dso = dso__new(name);
 328                 if (dso != NULL && dso__load(dso) < 0)
 329                         goto out_delete_dso;
 330
 331                 dsos__add(dso);
 332         }
 333
 334         return dso;
 335
 336 out_delete_dso:
 337         dso__delete(dso);
 338         return NULL;
 339 }
 340
 341 void dsos__fprintf(FILE *fp)
 342 {
 343         struct dso *pos;
 344
 345         list_for_each_entry(pos, &dsos, node)
 346                 dso__fprintf(pos, fp);
 347 }
 348
 349 static int load_kallsyms(void)
 350 {
 351         kernel_dso = dso__new("[kernel]");
 352         if (kernel_dso == NULL)
 353                 return -1;
 354
 355         FILE *file = fopen("/proc/kallsyms", "r");
 356
 357         if (file == NULL)
 358                 goto out_delete_dso;
 359
 360         char *line = NULL;
 361         size_t n;
 362
 363         if (getline(&line, &n, file) < 0 || !line)
 364                 goto out_delete_dso;
 365
 366         unsigned long long previous_start;
 367         char c, previous_symbf[4096];
 368         if (sscanf(line, "%llx %c %s", &previous_start, &c, previous_symbf) != 3)
 369                 goto out_delete_line;
 370
 371         while (!feof(file)) {
 372                 unsigned long long start;
 373                 char symbf[4096];
 374
 375                 if (getline(&line, &n, file) < 0)
 376                         break;
 377
 378                 if (!line)
 379                         goto out_delete_dso;
 380
 381                 if (sscanf(line, "%llx %c %s", &start, &c, symbf) == 3) {
 382                         if (start > previous_start) {
 383                                 struct symbol *sym = symbol__new(previous_start,
 384                                                                  start - previous_start,
 385                                                                  previous_symbf);
 386
 387                                 if (sym == NULL)
 388                                         goto out_delete_dso;
 389
 390                                 dso__insert_symbol(kernel_dso, sym);
 391                                 previous_start = start;
 392                                 strcpy(previous_symbf, symbf);
 393                         }
 394                 }
 395         }
 396
 397         dsos__add(kernel_dso);
 398         free(line);
 399         fclose(file);
 400         return 0;
 401
 402 out_delete_line:
 403         free(line);
 404 out_delete_dso:
 405         dso__delete(kernel_dso);
 406         return -1;
 407 }
 408
 409 struct map {
 410         struct list_head node;
 411         uint64_t         start;
 412         uint64_t         end;
 413         uint64_t         pgoff;
 414         struct dso       *dso;
 415 };
 416
 417 static struct map *map__new(struct mmap_event *event)
 418 {
 419         struct map *self = malloc(sizeof(*self));
 420
 421         if (self != NULL) {
 422                 self->start = event->start;
 423                 self->end   = event->start + event->len;
 424                 self->pgoff = event->pgoff;
 425
 426                 self->dso = dsos__findnew(event->filename);
 427                 if (self->dso == NULL)
 428                         goto out_delete;
 429         }
 430         return self;
 431 out_delete:
 432         free(self);
 433         return NULL;
 434 }
 435
 436 static size_t map__fprintf(struct map *self, FILE *fp)
 437 {
 438         return fprintf(fp, " %lx-%lx %lx %s\n",
 439                        self->start, self->end, self->pgoff, self->dso->name);
 440 }
 441
 442 struct symhist {
 443         struct rb_node   rb_node;
 444         struct dso       *dso;
 445         struct symbol    *sym;
 446         uint64_t         ip;
 447         uint32_t         count;
 448         char             level;
 449 };
 450
 451 static struct symhist *symhist__new(struct symbol *sym, uint64_t ip,
 452                                     struct dso *dso, char level)
 453 {
 454         struct symhist *self = malloc(sizeof(*self));
 455
 456         if (self != NULL) {
 457                 self->sym   = sym;
 458                 self->ip    = ip;
 459                 self->dso   = dso;
 460                 self->level = level;
 461                 self->count = 1;
 462         }
 463
 464         return self;
 465 }
 466
 467 void symhist__delete(struct symhist *self)
 468 {
 469         free(self);
 470 }
 471
 472 static void symhist__inc(struct symhist *self)
 473 {
 474         ++self->count;
 475 }
 476
 477 static size_t symhist__fprintf(struct symhist *self, FILE *fp)
 478 {
 479         size_t ret = fprintf(fp, "%#llx [%c] ", (unsigned long long)self->ip, self->level);
 480
 481         if (self->level != '.')
 482                 ret += fprintf(fp, "%s", self->sym ? self->sym->name: "<unknown>");
 483         else
 484                 ret += fprintf(fp, "%s: %s",
 485                                self->dso ? self->dso->name : "<unknown>",
 486                                self->sym ? self->sym->name : "<unknown>");
 487         return ret + fprintf(fp, ": %u\n", self->count);
 488 }
 489
 490 struct thread {
 491         struct rb_node   rb_node;
 492         struct list_head maps;
 493         struct rb_root   symhists;
 494         pid_t            pid;
 495         char             *comm;
 496 };
 497
 498 static struct thread *thread__new(pid_t pid)
 499 {
 500         struct thread *self = malloc(sizeof(*self));
 501
 502         if (self != NULL) {
 503                 self->pid = pid;
 504                 self->comm = NULL;
 505                 INIT_LIST_HEAD(&self->maps);
 506                 self->symhists = RB_ROOT;
 507         }
 508
 509         return self;
 510 }
 511
 512 static int thread__symbol_incnew(struct thread *self, struct symbol *sym,
 513                                  uint64_t ip, struct dso *dso, char level)
 514 {
 515         struct rb_node **p = &self->symhists.rb_node;
 516         struct rb_node *parent = NULL;
 517         struct symhist *sh;
 518
 519         while (*p != NULL) {
 520                 parent = *p;
 521                 sh = rb_entry(parent, struct symhist, rb_node);
 522
 523                 if (sh->sym == sym || ip == sh->ip) {
 524                         symhist__inc(sh);
 525                         return 0;
 526                 }
 527
 528                 /* Handle unresolved symbols too */
 529                 const uint64_t start = !sh->sym ? sh->ip : sh->sym->start;
 530
 531                 if (ip < start)
 532                         p = &(*p)->rb_left;
 533                 else
 534                         p = &(*p)->rb_right;
 535         }
 536
 537         sh = symhist__new(sym, ip, dso, level);
 538         if (sh == NULL)
 539                 return -ENOMEM;
 540         rb_link_node(&sh->rb_node, parent, p);
 541         rb_insert_color(&sh->rb_node, &self->symhists);
 542         return 0;
 543 }
 544
 545 static int thread__set_comm(struct thread *self, const char *comm)
 546 {
 547         self->comm = strdup(comm);
 548         return self->comm ? 0 : -ENOMEM;
 549 }
 550
 551 size_t thread__maps_fprintf(struct thread *self, FILE *fp)
 552 {
 553         struct map *pos;
 554         size_t ret = 0;
 555
 556         list_for_each_entry(pos, &self->maps, node)
 557                 ret += map__fprintf(pos, fp);
 558
 559         return ret;
 560 }
 561
 562 static size_t thread__fprintf(struct thread *self, FILE *fp)
 563 {
 564         int ret = fprintf(fp, "thread: %d %s\n", self->pid, self->comm);
 565         struct rb_node *nd;
 566
 567         for (nd = rb_first(&self->symhists); nd; nd = rb_next(nd)) {
 568                 struct symhist *pos = rb_entry(nd, struct symhist, rb_node);
 569                 ret += symhist__fprintf(pos, fp);
 570         }
 571
 572         return ret;
 573 }
 574
 575 static struct rb_root threads = RB_ROOT;
 576
 577 static struct thread *threads__findnew(pid_t pid)
 578 {
 579         struct rb_node **p = &threads.rb_node;
 580         struct rb_node *parent = NULL;
 581         struct thread *th;
 582
 583         while (*p != NULL) {
 584                 parent = *p;
 585                 th = rb_entry(parent, struct thread, rb_node);
 586
 587                 if (th->pid == pid)
 588                         return th;
 589
 590                 if (pid < th->pid)
 591                         p = &(*p)->rb_left;
 592                 else
 593                         p = &(*p)->rb_right;
 594         }
 595
 596         th = thread__new(pid);
 597         if (th != NULL) {
 598                 rb_link_node(&th->rb_node, parent, p);
 599                 rb_insert_color(&th->rb_node, &threads);
 600         }
 601         return th;
 602 }
 603
 604 static void thread__insert_map(struct thread *self, struct map *map)
 605 {
 606         list_add_tail(&map->node, &self->maps);
 607 }
 608
 609 static struct map *thread__find_map(struct thread *self, uint64_t ip)
 610 {
 611         if (self == NULL)
 612                 return NULL;
 613
 614         struct map *pos;
 615
 616         list_for_each_entry(pos, &self->maps, node)
 617                 if (ip >= pos->start && ip <= pos->end)
 618                         return pos;
 619
 620         return NULL;
 621 }
 622
 623 static void threads__fprintf(FILE *fp)
 624 {
 625         struct rb_node *nd;
 626         for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
 627                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 628                 thread__fprintf(pos, fp);
 629         }
 630 }
 631
 632 static int __cmd_report(void)
 633 {
 634         unsigned long offset = 0;
 635         unsigned long head = 0;
 636         struct stat stat;
 637         char *buf;
 638         event_t *event;
 639         int ret, rc = EXIT_FAILURE;
 640         unsigned long total = 0;
 641
 642         input = open(input_name, O_RDONLY);
 643         if (input < 0) {
 644                 perror("failed to open file");
 645                 exit(-1);
 646         }
 647
 648         ret = fstat(input, &stat);
 649         if (ret < 0) {
 650                 perror("failed to stat file");
 651                 exit(-1);
 652         }
 653
 654         if (!stat.st_size) {
 655                 fprintf(stderr, "zero-sized file, nothing to do!\n");
 656                 exit(0);
 657         }
 658
 659         if (load_kallsyms() < 0) {
 660                 perror("failed to open kallsyms");
 661                 return EXIT_FAILURE;
 662         }
 663
 664 remap:
 665         buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
 666                            MAP_SHARED, input, offset);
 667         if (buf == MAP_FAILED) {
 668                 perror("failed to mmap file");
 669                 exit(-1);
 670         }
 671
 672 more:
 673         event = (event_t *)(buf + head);
 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
 688         if (!event->header.size) {
 689                 fprintf(stderr, "zero-sized event at file offset %ld\n", offset + head);
 690                 fprintf(stderr, "skipping %ld bytes of events.\n", stat.st_size - offset - head);
 691                 goto done;
 692         }
 693
 694         head += event->header.size;
 695
 696         if (event->header.misc & PERF_EVENT_MISC_OVERFLOW) {
 697                 char level;
 698                 int show = 0;
 699                 struct dso *dso = NULL;
 700                 struct thread *thread = threads__findnew(event->ip.pid);
 701                 uint64_t ip = event->ip.ip;
 702
 703                 if (thread == NULL) {
 704                         fprintf(stderr, "problem processing %d event, bailing out\n",
 705                                 event->header.type);
 706                         goto done;
 707                 }
 708
 709                 if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
 710                         show = SHOW_KERNEL;
 711                         level = 'k';
 712                         dso = kernel_dso;
 713                 } else if (event->header.misc & PERF_EVENT_MISC_USER) {
 714                         show = SHOW_USER;
 715                         level = '.';
 716                         struct map *map = thread__find_map(thread, ip);
 717                         if (map != NULL) {
 718                                 dso = map->dso;
 719                                 ip -= map->start + map->pgoff;
 720                         }
 721                 } else {
 722                         show = SHOW_HV;
 723                         level = 'H';
 724                 }
 725
 726                 if (show & show_mask) {
 727                         struct symbol *sym = dso__find_symbol(dso, ip);
 728
 729                         if (thread__symbol_incnew(thread, sym, ip, dso, level)) {
 730                                 fprintf(stderr, "problem incrementing symbol count, bailing out\n");
 731                                 goto done;
 732                         }
 733                 }
 734                 total++;
 735         } else switch (event->header.type) {
 736         case PERF_EVENT_MMAP: {
 737                 struct thread *thread = threads__findnew(event->mmap.pid);
 738                 struct map *map = map__new(&event->mmap);
 739
 740                 if (thread == NULL || map == NULL) {
 741                         fprintf(stderr, "problem processing PERF_EVENT_MMAP, bailing out\n");
 742                         goto done;
 743                 }
 744                 thread__insert_map(thread, map);
 745                 break;
 746         }
 747         case PERF_EVENT_COMM: {
 748                 struct thread *thread = threads__findnew(event->comm.pid);
 749
 750                 if (thread == NULL ||
 751                     thread__set_comm(thread, event->comm.comm)) {
 752                         fprintf(stderr, "problem processing PERF_EVENT_COMM, bailing out\n");
 753                         goto done;
 754                 }
 755                 break;
 756         }
 757         }
 758
 759         if (offset + head < stat.st_size)
 760                 goto more;
 761
 762         rc = EXIT_SUCCESS;
 763 done:
 764         close(input);
 765         //dsos__fprintf(stdout);
 766         threads__fprintf(stdout);
 767 #if 0
 768         std::map<std::string, int>::iterator hi = hist.begin();
 769
 770         while (hi != hist.end()) {
 771                 rev_hist.insert(std::pair<int, std::string>(hi->second, hi->first));
 772                 hist.erase(hi++);
 773         }
 774
 775         std::multimap<int, std::string>::const_iterator ri = rev_hist.begin();
 776
 777         while (ri != rev_hist.end()) {
 778                 printf(" %5.2f %s\n", (100.0 * ri->first)/total, ri->second.c_str());
 779                 ri++;
 780         }
 781 #endif
 782         return rc;
 783 }
 784
 785 static const char * const report_usage[] = {
 786         "perf report [<options>] <command>",
 787         NULL
 788 };
 789
 790 static const struct option options[] = {
 791         OPT_STRING('i', "input", &input_name, "file",
 792                     "input file name"),
 793         OPT_END()
 794 };
 795
 796 int cmd_report(int argc, const char **argv, const char *prefix)
 797 {
 798         elf_version(EV_CURRENT);
 799
 800         page_size = getpagesize();
 801
 802         parse_options(argc, argv, options, report_usage, 0);
 803
 804         return __cmd_report();
 805 }