tools/perf/builtin-annotate.c

   1 /*
   2  * builtin-annotate.c
   3  *
   4  * Builtin annotate command: Analyze the perf.data input file,
   5  * look up and read DSOs and symbol information and display
   6  * a histogram of results, along various sorting keys.
   7  */
   8 #include "builtin.h"
   9
  10 #include "util/util.h"
  11
  12 #include "util/color.h"
  13 #include <linux/list.h>
  14 #include "util/cache.h"
  15 #include <linux/rbtree.h>
  16 #include "util/symbol.h"
  17 #include "util/string.h"
  18
  19 #include "perf.h"
  20 #include "util/debug.h"
  21
  22 #include "util/event.h"
  23 #include "util/parse-options.h"
  24 #include "util/parse-events.h"
  25 #include "util/thread.h"
  26 #include "util/sort.h"
  27 #include "util/hist.h"
  28 #include "util/session.h"
  29
  30 static char             const *input_name = "perf.data";
  31
  32 static int              force;
  33
  34 static int              full_paths;
  35
  36 static int              print_line;
  37
  38 struct sym_hist {
  39         u64             sum;
  40         u64             ip[0];
  41 };
  42
  43 struct sym_ext {
  44         struct rb_node  node;
  45         double          percent;
  46         char            *path;
  47 };
  48
  49 struct sym_priv {
  50         struct sym_hist *hist;
  51         struct sym_ext  *ext;
  52 };
  53
  54 static struct symbol_conf symbol_conf = {
  55         .priv_size        = sizeof(struct sym_priv),
  56         .try_vmlinux_path = true,
  57 };
  58
  59 static const char *sym_hist_filter;
  60
  61 static int symbol_filter(struct map *map __used, struct symbol *sym)
  62 {
  63         if (sym_hist_filter == NULL ||
  64             strcmp(sym->name, sym_hist_filter) == 0) {
  65                 struct sym_priv *priv = symbol__priv(sym);
  66                 const int size = (sizeof(*priv->hist) +
  67                                   (sym->end - sym->start) * sizeof(u64));
  68
  69                 priv->hist = malloc(size);
  70                 if (priv->hist)
  71                         memset(priv->hist, 0, size);
  72                 return 0;
  73         }
  74         /*
  75          * FIXME: We should really filter it out, as we don't want to go thru symbols
  76          * we're not interested, and if a DSO ends up with no symbols, delete it too,
  77          * but right now the kernel loading routines in symbol.c bail out if no symbols
  78          * are found, fix it later.
  79          */
  80         return 0;
  81 }
  82
  83 /*
  84  * collect histogram counts
  85  */
  86 static void hist_hit(struct hist_entry *he, u64 ip)
  87 {
  88         unsigned int sym_size, offset;
  89         struct symbol *sym = he->sym;
  90         struct sym_priv *priv;
  91         struct sym_hist *h;
  92
  93         he->count++;
  94
  95         if (!sym || !he->map)
  96                 return;
  97
  98         priv = symbol__priv(sym);
  99         if (!priv->hist)
 100                 return;
 101
 102         sym_size = sym->end - sym->start;
 103         offset = ip - sym->start;
 104
 105         if (verbose)
 106                 fprintf(stderr, "%s: ip=%Lx\n", __func__,
 107                         he->map->unmap_ip(he->map, ip));
 108
 109         if (offset >= sym_size)
 110                 return;
 111
 112         h = priv->hist;
 113         h->sum++;
 114         h->ip[offset]++;
 115
 116         if (verbose >= 3)
 117                 printf("%p %s: count++ [ip: %p, %08Lx] => %Ld\n",
 118                         (void *)(unsigned long)he->sym->start,
 119                         he->sym->name,
 120                         (void *)(unsigned long)ip, ip - he->sym->start,
 121                         h->ip[offset]);
 122 }
 123
 124 static int hist_entry__add(struct addr_location *al, u64 count)
 125 {
 126         bool hit;
 127         struct hist_entry *he = __hist_entry__add(al, NULL, count, &hit);
 128         if (he == NULL)
 129                 return -ENOMEM;
 130         hist_hit(he, al->addr);
 131         return 0;
 132 }
 133
 134 static int process_sample_event(event_t *event, struct perf_session *session __used)
 135 {
 136         struct addr_location al;
 137
 138         dump_printf("(IP, %d): %d: %p\n", event->header.misc,
 139                     event->ip.pid, (void *)(long)event->ip.ip);
 140
 141         if (event__preprocess_sample(event, &al, symbol_filter) < 0) {
 142                 fprintf(stderr, "problem processing %d event, skipping it.\n",
 143                         event->header.type);
 144                 return -1;
 145         }
 146
 147         if (hist_entry__add(&al, 1)) {
 148                 fprintf(stderr, "problem incrementing symbol count, "
 149                                 "skipping event\n");
 150                 return -1;
 151         }
 152
 153         return 0;
 154 }
 155
 156 static int parse_line(FILE *file, struct hist_entry *he, u64 len)
 157 {
 158         struct symbol *sym = he->sym;
 159         char *line = NULL, *tmp, *tmp2;
 160         static const char *prev_line;
 161         static const char *prev_color;
 162         unsigned int offset;
 163         size_t line_len;
 164         u64 start;
 165         s64 line_ip;
 166         int ret;
 167         char *c;
 168
 169         if (getline(&line, &line_len, file) < 0)
 170                 return -1;
 171         if (!line)
 172                 return -1;
 173
 174         c = strchr(line, '\n');
 175         if (c)
 176                 *c = 0;
 177
 178         line_ip = -1;
 179         offset = 0;
 180         ret = -2;
 181
 182         /*
 183          * Strip leading spaces:
 184          */
 185         tmp = line;
 186         while (*tmp) {
 187                 if (*tmp != ' ')
 188                         break;
 189                 tmp++;
 190         }
 191
 192         if (*tmp) {
 193                 /*
 194                  * Parse hexa addresses followed by ':'
 195                  */
 196                 line_ip = strtoull(tmp, &tmp2, 16);
 197                 if (*tmp2 != ':')
 198                         line_ip = -1;
 199         }
 200
 201         start = he->map->unmap_ip(he->map, sym->start);
 202
 203         if (line_ip != -1) {
 204                 const char *path = NULL;
 205                 unsigned int hits = 0;
 206                 double percent = 0.0;
 207                 const char *color;
 208                 struct sym_priv *priv = symbol__priv(sym);
 209                 struct sym_ext *sym_ext = priv->ext;
 210                 struct sym_hist *h = priv->hist;
 211
 212                 offset = line_ip - start;
 213                 if (offset < len)
 214                         hits = h->ip[offset];
 215
 216                 if (offset < len && sym_ext) {
 217                         path = sym_ext[offset].path;
 218                         percent = sym_ext[offset].percent;
 219                 } else if (h->sum)
 220                         percent = 100.0 * hits / h->sum;
 221
 222                 color = get_percent_color(percent);
 223
 224                 /*
 225                  * Also color the filename and line if needed, with
 226                  * the same color than the percentage. Don't print it
 227                  * twice for close colored ip with the same filename:line
 228                  */
 229                 if (path) {
 230                         if (!prev_line || strcmp(prev_line, path)
 231                                        || color != prev_color) {
 232                                 color_fprintf(stdout, color, " %s", path);
 233                                 prev_line = path;
 234                                 prev_color = color;
 235                         }
 236                 }
 237
 238                 color_fprintf(stdout, color, " %7.2f", percent);
 239                 printf(" :      ");
 240                 color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
 241         } else {
 242                 if (!*line)
 243                         printf("         :\n");
 244                 else
 245                         printf("         :      %s\n", line);
 246         }
 247
 248         return 0;
 249 }
 250
 251 static struct rb_root root_sym_ext;
 252
 253 static void insert_source_line(struct sym_ext *sym_ext)
 254 {
 255         struct sym_ext *iter;
 256         struct rb_node **p = &root_sym_ext.rb_node;
 257         struct rb_node *parent = NULL;
 258
 259         while (*p != NULL) {
 260                 parent = *p;
 261                 iter = rb_entry(parent, struct sym_ext, node);
 262
 263                 if (sym_ext->percent > iter->percent)
 264                         p = &(*p)->rb_left;
 265                 else
 266                         p = &(*p)->rb_right;
 267         }
 268
 269         rb_link_node(&sym_ext->node, parent, p);
 270         rb_insert_color(&sym_ext->node, &root_sym_ext);
 271 }
 272
 273 static void free_source_line(struct hist_entry *he, int len)
 274 {
 275         struct sym_priv *priv = symbol__priv(he->sym);
 276         struct sym_ext *sym_ext = priv->ext;
 277         int i;
 278
 279         if (!sym_ext)
 280                 return;
 281
 282         for (i = 0; i < len; i++)
 283                 free(sym_ext[i].path);
 284         free(sym_ext);
 285
 286         priv->ext = NULL;
 287         root_sym_ext = RB_ROOT;
 288 }
 289
 290 /* Get the filename:line for the colored entries */
 291 static void
 292 get_source_line(struct hist_entry *he, int len, const char *filename)
 293 {
 294         struct symbol *sym = he->sym;
 295         u64 start;
 296         int i;
 297         char cmd[PATH_MAX * 2];
 298         struct sym_ext *sym_ext;
 299         struct sym_priv *priv = symbol__priv(sym);
 300         struct sym_hist *h = priv->hist;
 301
 302         if (!h->sum)
 303                 return;
 304
 305         sym_ext = priv->ext = calloc(len, sizeof(struct sym_ext));
 306         if (!priv->ext)
 307                 return;
 308
 309         start = he->map->unmap_ip(he->map, sym->start);
 310
 311         for (i = 0; i < len; i++) {
 312                 char *path = NULL;
 313                 size_t line_len;
 314                 u64 offset;
 315                 FILE *fp;
 316
 317                 sym_ext[i].percent = 100.0 * h->ip[i] / h->sum;
 318                 if (sym_ext[i].percent <= 0.5)
 319                         continue;
 320
 321                 offset = start + i;
 322                 sprintf(cmd, "addr2line -e %s %016llx", filename, offset);
 323                 fp = popen(cmd, "r");
 324                 if (!fp)
 325                         continue;
 326
 327                 if (getline(&path, &line_len, fp) < 0 || !line_len)
 328                         goto next;
 329
 330                 sym_ext[i].path = malloc(sizeof(char) * line_len + 1);
 331                 if (!sym_ext[i].path)
 332                         goto next;
 333
 334                 strcpy(sym_ext[i].path, path);
 335                 insert_source_line(&sym_ext[i]);
 336
 337         next:
 338                 pclose(fp);
 339         }
 340 }
 341
 342 static void print_summary(const char *filename)
 343 {
 344         struct sym_ext *sym_ext;
 345         struct rb_node *node;
 346
 347         printf("\nSorted summary for file %s\n", filename);
 348         printf("----------------------------------------------\n\n");
 349
 350         if (RB_EMPTY_ROOT(&root_sym_ext)) {
 351                 printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
 352                 return;
 353         }
 354
 355         node = rb_first(&root_sym_ext);
 356         while (node) {
 357                 double percent;
 358                 const char *color;
 359                 char *path;
 360
 361                 sym_ext = rb_entry(node, struct sym_ext, node);
 362                 percent = sym_ext->percent;
 363                 color = get_percent_color(percent);
 364                 path = sym_ext->path;
 365
 366                 color_fprintf(stdout, color, " %7.2f %s", percent, path);
 367                 node = rb_next(node);
 368         }
 369 }
 370
 371 static void annotate_sym(struct hist_entry *he)
 372 {
 373         struct map *map = he->map;
 374         struct dso *dso = map->dso;
 375         struct symbol *sym = he->sym;
 376         const char *filename = dso->long_name, *d_filename;
 377         u64 len;
 378         char command[PATH_MAX*2];
 379         FILE *file;
 380
 381         if (!filename)
 382                 return;
 383
 384         if (verbose)
 385                 fprintf(stderr, "%s: filename=%s, sym=%s, start=%Lx, end=%Lx\n",
 386                         __func__, filename, sym->name,
 387                         map->unmap_ip(map, sym->start),
 388                         map->unmap_ip(map, sym->end));
 389
 390         if (full_paths)
 391                 d_filename = filename;
 392         else
 393                 d_filename = basename(filename);
 394
 395         len = sym->end - sym->start;
 396
 397         if (print_line) {
 398                 get_source_line(he, len, filename);
 399                 print_summary(filename);
 400         }
 401
 402         printf("\n\n------------------------------------------------\n");
 403         printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
 404         printf("------------------------------------------------\n");
 405
 406         if (verbose >= 2)
 407                 printf("annotating [%p] %30s : [%p] %30s\n",
 408                        dso, dso->long_name, sym, sym->name);
 409
 410         sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
 411                 map->unmap_ip(map, sym->start), map->unmap_ip(map, sym->end),
 412                 filename, filename);
 413
 414         if (verbose >= 3)
 415                 printf("doing: %s\n", command);
 416
 417         file = popen(command, "r");
 418         if (!file)
 419                 return;
 420
 421         while (!feof(file)) {
 422                 if (parse_line(file, he, len) < 0)
 423                         break;
 424         }
 425
 426         pclose(file);
 427         if (print_line)
 428                 free_source_line(he, len);
 429 }
 430
 431 static void find_annotations(void)
 432 {
 433         struct rb_node *nd;
 434
 435         for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
 436                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
 437                 struct sym_priv *priv;
 438
 439                 if (he->sym == NULL)
 440                         continue;
 441
 442                 priv = symbol__priv(he->sym);
 443                 if (priv->hist == NULL)
 444                         continue;
 445
 446                 annotate_sym(he);
 447                 /*
 448                  * Since we have a hist_entry per IP for the same symbol, free
 449                  * he->sym->hist to signal we already processed this symbol.
 450                  */
 451                 free(priv->hist);
 452                 priv->hist = NULL;
 453         }
 454 }
 455
 456 static struct perf_event_ops event_ops = {
 457         .process_sample_event   = process_sample_event,
 458         .process_mmap_event     = event__process_mmap,
 459         .process_comm_event     = event__process_comm,
 460         .process_fork_event     = event__process_task,
 461 };
 462
 463 static int __cmd_annotate(void)
 464 {
 465         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
 466                                                          force);
 467         int ret;
 468
 469         if (session == NULL)
 470                 return -ENOMEM;
 471
 472         ret = perf_session__process_events(session, &event_ops, 0,
 473                                            &event__cwdlen, &event__cwd);
 474         if (ret)
 475                 goto out_delete;
 476
 477         if (dump_trace) {
 478                 event__print_totals();
 479                 goto out_delete;
 480         }
 481
 482         if (verbose > 3)
 483                 threads__fprintf(stdout);
 484
 485         if (verbose > 2)
 486                 dsos__fprintf(stdout);
 487
 488         collapse__resort();
 489         output__resort(event__total[0]);
 490
 491         find_annotations();
 492 out_delete:
 493         perf_session__delete(session);
 494
 495         return ret;
 496 }
 497
 498 static const char * const annotate_usage[] = {
 499         "perf annotate [<options>] <command>",
 500         NULL
 501 };
 502
 503 static const struct option options[] = {
 504         OPT_STRING('i', "input", &input_name, "file",
 505                     "input file name"),
 506         OPT_STRING('s', "symbol", &sym_hist_filter, "symbol",
 507                     "symbol to annotate"),
 508         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 509         OPT_BOOLEAN('v', "verbose", &verbose,
 510                     "be more verbose (show symbol address, etc)"),
 511         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 512                     "dump raw trace in ASCII"),
 513         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 514                    "file", "vmlinux pathname"),
 515         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
 516                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
 517         OPT_BOOLEAN('l', "print-line", &print_line,
 518                     "print matching source lines (may be slow)"),
 519         OPT_BOOLEAN('P', "full-paths", &full_paths,
 520                     "Don't shorten the displayed pathnames"),
 521         OPT_END()
 522 };
 523
 524 static void setup_sorting(void)
 525 {
 526         char *tmp, *tok, *str = strdup(sort_order);
 527
 528         for (tok = strtok_r(str, ", ", &tmp);
 529                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
 530                 if (sort_dimension__add(tok) < 0) {
 531                         error("Unknown --sort key: `%s'", tok);
 532                         usage_with_options(annotate_usage, options);
 533                 }
 534         }
 535
 536         free(str);
 537 }
 538
 539 int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 540 {
 541         if (symbol__init(&symbol_conf) < 0)
 542                 return -1;
 543
 544         argc = parse_options(argc, argv, options, annotate_usage, 0);
 545
 546         setup_sorting();
 547
 548         if (argc) {
 549                 /*
 550                  * Special case: if there's an argument left then assume tha
 551                  * it's a symbol filter:
 552                  */
 553                 if (argc > 1)
 554                         usage_with_options(annotate_usage, options);
 555
 556                 sym_hist_filter = argv[0];
 557         }
 558
 559         setup_pager();
 560
 561         if (field_sep && *field_sep == '.') {
 562                 fputs("'.' is the only non valid --field-separator argument\n",
 563                                 stderr);
 564                 exit(129);
 565         }
 566
 567         return __cmd_annotate();
 568 }