tools/perf/util/srcline.c

   1 #include <inttypes.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include <linux/kernel.h>
   7
   8 #include "util/dso.h"
   9 #include "util/util.h"
  10 #include "util/debug.h"
  11 #include "util/callchain.h"
  12 #include "srcline.h"
  13
  14 #include "symbol.h"
  15
  16 bool srcline_full_filename;
  17
  18 static const char *dso__name(struct dso *dso)
  19 {
  20         const char *dso_name;
  21
  22         if (dso->symsrc_filename)
  23                 dso_name = dso->symsrc_filename;
  24         else
  25                 dso_name = dso->long_name;
  26
  27         if (dso_name[0] == '[')
  28                 return NULL;
  29
  30         if (!strncmp(dso_name, "/tmp/perf-", 10))
  31                 return NULL;
  32
  33         return dso_name;
  34 }
  35
  36 static int inline_list__append(char *filename, char *funcname, int line_nr,
  37                                struct inline_node *node, struct dso *dso)
  38 {
  39         struct inline_list *ilist;
  40         char *demangled;
  41
  42         ilist = zalloc(sizeof(*ilist));
  43         if (ilist == NULL)
  44                 return -1;
  45
  46         ilist->filename = filename;
  47         ilist->line_nr = line_nr;
  48
  49         if (dso != NULL) {
  50                 demangled = dso__demangle_sym(dso, 0, funcname);
  51                 if (demangled == NULL) {
  52                         ilist->funcname = funcname;
  53                 } else {
  54                         ilist->funcname = demangled;
  55                         free(funcname);
  56                 }
  57         }
  58
  59         list_add_tail(&ilist->list, &node->val);
  60
  61         return 0;
  62 }
  63
  64 #ifdef HAVE_LIBBFD_SUPPORT
  65
  66 /*
  67  * Implement addr2line using libbfd.
  68  */
  69 #define PACKAGE "perf"
  70 #include <bfd.h>
  71
  72 struct a2l_data {
  73         const char      *input;
  74         u64             addr;
  75
  76         bool            found;
  77         const char      *filename;
  78         const char      *funcname;
  79         unsigned        line;
  80
  81         bfd             *abfd;
  82         asymbol         **syms;
  83 };
  84
  85 static int bfd_error(const char *string)
  86 {
  87         const char *errmsg;
  88
  89         errmsg = bfd_errmsg(bfd_get_error());
  90         fflush(stdout);
  91
  92         if (string)
  93                 pr_debug("%s: %s\n", string, errmsg);
  94         else
  95                 pr_debug("%s\n", errmsg);
  96
  97         return -1;
  98 }
  99
 100 static int slurp_symtab(bfd *abfd, struct a2l_data *a2l)
 101 {
 102         long storage;
 103         long symcount;
 104         asymbol **syms;
 105         bfd_boolean dynamic = FALSE;
 106
 107         if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0)
 108                 return bfd_error(bfd_get_filename(abfd));
 109
 110         storage = bfd_get_symtab_upper_bound(abfd);
 111         if (storage == 0L) {
 112                 storage = bfd_get_dynamic_symtab_upper_bound(abfd);
 113                 dynamic = TRUE;
 114         }
 115         if (storage < 0L)
 116                 return bfd_error(bfd_get_filename(abfd));
 117
 118         syms = malloc(storage);
 119         if (dynamic)
 120                 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
 121         else
 122                 symcount = bfd_canonicalize_symtab(abfd, syms);
 123
 124         if (symcount < 0) {
 125                 free(syms);
 126                 return bfd_error(bfd_get_filename(abfd));
 127         }
 128
 129         a2l->syms = syms;
 130         return 0;
 131 }
 132
 133 static void find_address_in_section(bfd *abfd, asection *section, void *data)
 134 {
 135         bfd_vma pc, vma;
 136         bfd_size_type size;
 137         struct a2l_data *a2l = data;
 138
 139         if (a2l->found)
 140                 return;
 141
 142         if ((bfd_get_section_flags(abfd, section) & SEC_ALLOC) == 0)
 143                 return;
 144
 145         pc = a2l->addr;
 146         vma = bfd_get_section_vma(abfd, section);
 147         size = bfd_get_section_size(section);
 148
 149         if (pc < vma || pc >= vma + size)
 150                 return;
 151
 152         a2l->found = bfd_find_nearest_line(abfd, section, a2l->syms, pc - vma,
 153                                            &a2l->filename, &a2l->funcname,
 154                                            &a2l->line);
 155 }
 156
 157 static struct a2l_data *addr2line_init(const char *path)
 158 {
 159         bfd *abfd;
 160         struct a2l_data *a2l = NULL;
 161
 162         abfd = bfd_openr(path, NULL);
 163         if (abfd == NULL)
 164                 return NULL;
 165
 166         if (!bfd_check_format(abfd, bfd_object))
 167                 goto out;
 168
 169         a2l = zalloc(sizeof(*a2l));
 170         if (a2l == NULL)
 171                 goto out;
 172
 173         a2l->abfd = abfd;
 174         a2l->input = strdup(path);
 175         if (a2l->input == NULL)
 176                 goto out;
 177
 178         if (slurp_symtab(abfd, a2l))
 179                 goto out;
 180
 181         return a2l;
 182
 183 out:
 184         if (a2l) {
 185                 zfree((char **)&a2l->input);
 186                 free(a2l);
 187         }
 188         bfd_close(abfd);
 189         return NULL;
 190 }
 191
 192 static void addr2line_cleanup(struct a2l_data *a2l)
 193 {
 194         if (a2l->abfd)
 195                 bfd_close(a2l->abfd);
 196         zfree((char **)&a2l->input);
 197         zfree(&a2l->syms);
 198         free(a2l);
 199 }
 200
 201 #define MAX_INLINE_NEST 1024
 202
 203 static void inline_list__reverse(struct inline_node *node)
 204 {
 205         struct inline_list *ilist, *n;
 206
 207         list_for_each_entry_safe_reverse(ilist, n, &node->val, list)
 208                 list_move_tail(&ilist->list, &node->val);
 209 }
 210
 211 static int addr2line(const char *dso_name, u64 addr,
 212                      char **file, unsigned int *line, struct dso *dso,
 213                      bool unwind_inlines, struct inline_node *node)
 214 {
 215         int ret = 0;
 216         struct a2l_data *a2l = dso->a2l;
 217
 218         if (!a2l) {
 219                 dso->a2l = addr2line_init(dso_name);
 220                 a2l = dso->a2l;
 221         }
 222
 223         if (a2l == NULL) {
 224                 pr_warning("addr2line_init failed for %s\n", dso_name);
 225                 return 0;
 226         }
 227
 228         a2l->addr = addr;
 229         a2l->found = false;
 230
 231         bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
 232
 233         if (!a2l->found)
 234                 return 0;
 235
 236         if (unwind_inlines) {
 237                 int cnt = 0;
 238
 239                 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
 240                                              &a2l->funcname, &a2l->line) &&
 241                        cnt++ < MAX_INLINE_NEST) {
 242
 243                         if (node != NULL) {
 244                                 if (inline_list__append(strdup(a2l->filename),
 245                                                         strdup(a2l->funcname),
 246                                                         a2l->line, node,
 247                                                         dso) != 0)
 248                                         return 0;
 249                                 // found at least one inline frame
 250                                 ret = 1;
 251                         }
 252                 }
 253
 254                 if ((node != NULL) &&
 255                     (callchain_param.order != ORDER_CALLEE)) {
 256                         inline_list__reverse(node);
 257                 }
 258         }
 259
 260         if (file) {
 261                 *file = a2l->filename ? strdup(a2l->filename) : NULL;
 262                 ret = *file ? 1 : 0;
 263         }
 264
 265         if (line)
 266                 *line = a2l->line;
 267
 268         return ret;
 269 }
 270
 271 void dso__free_a2l(struct dso *dso)
 272 {
 273         struct a2l_data *a2l = dso->a2l;
 274
 275         if (!a2l)
 276                 return;
 277
 278         addr2line_cleanup(a2l);
 279
 280         dso->a2l = NULL;
 281 }
 282
 283 static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
 284         struct dso *dso)
 285 {
 286         struct inline_node *node;
 287
 288         node = zalloc(sizeof(*node));
 289         if (node == NULL) {
 290                 perror("not enough memory for the inline node");
 291                 return NULL;
 292         }
 293
 294         INIT_LIST_HEAD(&node->val);
 295         node->addr = addr;
 296
 297         if (!addr2line(dso_name, addr, NULL, NULL, dso, TRUE, node))
 298                 goto out_free_inline_node;
 299
 300         if (list_empty(&node->val))
 301                 goto out_free_inline_node;
 302
 303         return node;
 304
 305 out_free_inline_node:
 306         inline_node__delete(node);
 307         return NULL;
 308 }
 309
 310 #else /* HAVE_LIBBFD_SUPPORT */
 311
 312 static int filename_split(char *filename, unsigned int *line_nr)
 313 {
 314         char *sep;
 315
 316         sep = strchr(filename, '\n');
 317         if (sep)
 318                 *sep = '\0';
 319
 320         if (!strcmp(filename, "??:0"))
 321                 return 0;
 322
 323         sep = strchr(filename, ':');
 324         if (sep) {
 325                 *sep++ = '\0';
 326                 *line_nr = strtoul(sep, NULL, 0);
 327                 return 1;
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int addr2line(const char *dso_name, u64 addr,
 334                      char **file, unsigned int *line_nr,
 335                      struct dso *dso __maybe_unused,
 336                      bool unwind_inlines __maybe_unused,
 337                      struct inline_node *node __maybe_unused)
 338 {
 339         FILE *fp;
 340         char cmd[PATH_MAX];
 341         char *filename = NULL;
 342         size_t len;
 343         int ret = 0;
 344
 345         scnprintf(cmd, sizeof(cmd), "addr2line -e %s %016"PRIx64,
 346                   dso_name, addr);
 347
 348         fp = popen(cmd, "r");
 349         if (fp == NULL) {
 350                 pr_warning("popen failed for %s\n", dso_name);
 351                 return 0;
 352         }
 353
 354         if (getline(&filename, &len, fp) < 0 || !len) {
 355                 pr_warning("addr2line has no output for %s\n", dso_name);
 356                 goto out;
 357         }
 358
 359         ret = filename_split(filename, line_nr);
 360         if (ret != 1) {
 361                 free(filename);
 362                 goto out;
 363         }
 364
 365         *file = filename;
 366
 367 out:
 368         pclose(fp);
 369         return ret;
 370 }
 371
 372 void dso__free_a2l(struct dso *dso __maybe_unused)
 373 {
 374 }
 375
 376 static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
 377         struct dso *dso __maybe_unused)
 378 {
 379         FILE *fp;
 380         char cmd[PATH_MAX];
 381         struct inline_node *node;
 382         char *filename = NULL;
 383         size_t len;
 384         unsigned int line_nr = 0;
 385
 386         scnprintf(cmd, sizeof(cmd), "addr2line -e %s -i %016"PRIx64,
 387                   dso_name, addr);
 388
 389         fp = popen(cmd, "r");
 390         if (fp == NULL) {
 391                 pr_err("popen failed for %s\n", dso_name);
 392                 return NULL;
 393         }
 394
 395         node = zalloc(sizeof(*node));
 396         if (node == NULL) {
 397                 perror("not enough memory for the inline node");
 398                 goto out;
 399         }
 400
 401         INIT_LIST_HEAD(&node->val);
 402         node->addr = addr;
 403
 404         while (getline(&filename, &len, fp) != -1) {
 405                 if (filename_split(filename, &line_nr) != 1) {
 406                         free(filename);
 407                         goto out;
 408                 }
 409
 410                 if (inline_list__append(filename, NULL, line_nr, node,
 411                                         NULL) != 0)
 412                         goto out;
 413
 414                 filename = NULL;
 415         }
 416
 417 out:
 418         pclose(fp);
 419
 420         if (list_empty(&node->val)) {
 421                 inline_node__delete(node);
 422                 return NULL;
 423         }
 424
 425         return node;
 426 }
 427
 428 #endif /* HAVE_LIBBFD_SUPPORT */
 429
 430 /*
 431  * Number of addr2line failures (without success) before disabling it for that
 432  * dso.
 433  */
 434 #define A2L_FAIL_LIMIT 123
 435
 436 char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
 437                   bool show_sym, bool show_addr, bool unwind_inlines)
 438 {
 439         char *file = NULL;
 440         unsigned line = 0;
 441         char *srcline;
 442         const char *dso_name;
 443
 444         if (!dso->has_srcline)
 445                 goto out;
 446
 447         dso_name = dso__name(dso);
 448         if (dso_name == NULL)
 449                 goto out;
 450
 451         if (!addr2line(dso_name, addr, &file, &line, dso, unwind_inlines, NULL))
 452                 goto out;
 453
 454         if (asprintf(&srcline, "%s:%u",
 455                                 srcline_full_filename ? file : basename(file),
 456                                 line) < 0) {
 457                 free(file);
 458                 goto out;
 459         }
 460
 461         dso->a2l_fails = 0;
 462
 463         free(file);
 464         return srcline;
 465
 466 out:
 467         if (dso->a2l_fails && ++dso->a2l_fails > A2L_FAIL_LIMIT) {
 468                 dso->has_srcline = 0;
 469                 dso__free_a2l(dso);
 470         }
 471
 472         if (!show_addr)
 473                 return (show_sym && sym) ?
 474                             strndup(sym->name, sym->namelen) : NULL;
 475
 476         if (sym) {
 477                 if (asprintf(&srcline, "%s+%" PRIu64, show_sym ? sym->name : "",
 478                                         addr - sym->start) < 0)
 479                         return SRCLINE_UNKNOWN;
 480         } else if (asprintf(&srcline, "%s[%" PRIx64 "]", dso->short_name, addr) < 0)
 481                 return SRCLINE_UNKNOWN;
 482         return srcline;
 483 }
 484
 485 void free_srcline(char *srcline)
 486 {
 487         if (srcline && strcmp(srcline, SRCLINE_UNKNOWN) != 0)
 488                 free(srcline);
 489 }
 490
 491 char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
 492                   bool show_sym, bool show_addr)
 493 {
 494         return __get_srcline(dso, addr, sym, show_sym, show_addr, false);
 495 }
 496
 497 struct inline_node *dso__parse_addr_inlines(struct dso *dso, u64 addr)
 498 {
 499         const char *dso_name;
 500
 501         dso_name = dso__name(dso);
 502         if (dso_name == NULL)
 503                 return NULL;
 504
 505         return addr2inlines(dso_name, addr, dso);
 506 }
 507
 508 void inline_node__delete(struct inline_node *node)
 509 {
 510         struct inline_list *ilist, *tmp;
 511
 512         list_for_each_entry_safe(ilist, tmp, &node->val, list) {
 513                 list_del_init(&ilist->list);
 514                 zfree(&ilist->filename);
 515                 zfree(&ilist->funcname);
 516                 free(ilist);
 517         }
 518
 519         free(node);
 520 }