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