tools/perf/util/srcline.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <inttypes.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include <linux/kernel.h>
   8
   9 #include "util/dso.h"
  10 #include "util/util.h"
  11 #include "util/debug.h"
  12 #include "util/callchain.h"
  13 #include "srcline.h"
  14 #include "string2.h"
  15 #include "symbol.h"
  16
  17 bool srcline_full_filename;
  18
  19 static const char *dso__name(struct dso *dso)
  20 {
  21         const char *dso_name;
  22
  23         if (dso->symsrc_filename)
  24                 dso_name = dso->symsrc_filename;
  25         else
  26                 dso_name = dso->long_name;
  27
  28         if (dso_name[0] == '[')
  29                 return NULL;
  30
  31         if (!strncmp(dso_name, "/tmp/perf-", 10))
  32                 return NULL;
  33
  34         return dso_name;
  35 }
  36
  37 static int inline_list__append(struct symbol *symbol, char *srcline,
  38                                struct inline_node *node)
  39 {
  40         struct inline_list *ilist;
  41
  42         ilist = zalloc(sizeof(*ilist));
  43         if (ilist == NULL)
  44                 return -1;
  45
  46         ilist->symbol = symbol;
  47         ilist->srcline = srcline;
  48
  49         if (callchain_param.order == ORDER_CALLEE)
  50                 list_add_tail(&ilist->list, &node->val);
  51         else
  52                 list_add(&ilist->list, &node->val);
  53
  54         return 0;
  55 }
  56
  57 /* basename version that takes a const input string */
  58 static const char *gnu_basename(const char *path)
  59 {
  60         const char *base = strrchr(path, '/');
  61
  62         return base ? base + 1 : path;
  63 }
  64
  65 static char *srcline_from_fileline(const char *file, unsigned int line)
  66 {
  67         char *srcline;
  68
  69         if (!file)
  70                 return NULL;
  71
  72         if (!srcline_full_filename)
  73                 file = gnu_basename(file);
  74
  75         if (asprintf(&srcline, "%s:%u", file, line) < 0)
  76                 return NULL;
  77
  78         return srcline;
  79 }
  80
  81 static struct symbol *new_inline_sym(struct dso *dso,
  82                                      struct symbol *base_sym,
  83                                      const char *funcname)
  84 {
  85         struct symbol *inline_sym;
  86         char *demangled = NULL;
  87
  88         if (dso) {
  89                 demangled = dso__demangle_sym(dso, 0, funcname);
  90                 if (demangled)
  91                         funcname = demangled;
  92         }
  93
  94         if (base_sym && strcmp(funcname, base_sym->name) == 0) {
  95                 /* reuse the real, existing symbol */
  96                 inline_sym = base_sym;
  97                 /* ensure that we don't alias an inlined symbol, which could
  98                  * lead to double frees in inline_node__delete
  99                  */
 100                 assert(!base_sym->inlined);
 101         } else {
 102                 /* create a fake symbol for the inline frame */
 103                 inline_sym = symbol__new(base_sym ? base_sym->start : 0,
 104                                          base_sym ? base_sym->end : 0,
 105                                          base_sym ? base_sym->binding : 0,
 106                                          base_sym ? base_sym->type : 0,
 107                                          funcname);
 108                 if (inline_sym)
 109                         inline_sym->inlined = 1;
 110         }
 111
 112         free(demangled);
 113
 114         return inline_sym;
 115 }
 116
 117 #ifdef HAVE_LIBBFD_SUPPORT
 118
 119 /*
 120  * Implement addr2line using libbfd.
 121  */
 122 #define PACKAGE "perf"
 123 #include <bfd.h>
 124
 125 struct a2l_data {
 126         const char      *input;
 127         u64             addr;
 128
 129         bool            found;
 130         const char      *filename;
 131         const char      *funcname;
 132         unsigned        line;
 133
 134         bfd             *abfd;
 135         asymbol         **syms;
 136 };
 137
 138 static int bfd_error(const char *string)
 139 {
 140         const char *errmsg;
 141
 142         errmsg = bfd_errmsg(bfd_get_error());
 143         fflush(stdout);
 144
 145         if (string)
 146                 pr_debug("%s: %s\n", string, errmsg);
 147         else
 148                 pr_debug("%s\n", errmsg);
 149
 150         return -1;
 151 }
 152
 153 static int slurp_symtab(bfd *abfd, struct a2l_data *a2l)
 154 {
 155         long storage;
 156         long symcount;
 157         asymbol **syms;
 158         bfd_boolean dynamic = FALSE;
 159
 160         if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0)
 161                 return bfd_error(bfd_get_filename(abfd));
 162
 163         storage = bfd_get_symtab_upper_bound(abfd);
 164         if (storage == 0L) {
 165                 storage = bfd_get_dynamic_symtab_upper_bound(abfd);
 166                 dynamic = TRUE;
 167         }
 168         if (storage < 0L)
 169                 return bfd_error(bfd_get_filename(abfd));
 170
 171         syms = malloc(storage);
 172         if (dynamic)
 173                 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
 174         else
 175                 symcount = bfd_canonicalize_symtab(abfd, syms);
 176
 177         if (symcount < 0) {
 178                 free(syms);
 179                 return bfd_error(bfd_get_filename(abfd));
 180         }
 181
 182         a2l->syms = syms;
 183         return 0;
 184 }
 185
 186 static void find_address_in_section(bfd *abfd, asection *section, void *data)
 187 {
 188         bfd_vma pc, vma;
 189         bfd_size_type size;
 190         struct a2l_data *a2l = data;
 191
 192         if (a2l->found)
 193                 return;
 194
 195         if ((bfd_get_section_flags(abfd, section) & SEC_ALLOC) == 0)
 196                 return;
 197
 198         pc = a2l->addr;
 199         vma = bfd_get_section_vma(abfd, section);
 200         size = bfd_get_section_size(section);
 201
 202         if (pc < vma || pc >= vma + size)
 203                 return;
 204
 205         a2l->found = bfd_find_nearest_line(abfd, section, a2l->syms, pc - vma,
 206                                            &a2l->filename, &a2l->funcname,
 207                                            &a2l->line);
 208
 209         if (a2l->filename && !strlen(a2l->filename))
 210                 a2l->filename = NULL;
 211 }
 212
 213 static struct a2l_data *addr2line_init(const char *path)
 214 {
 215         bfd *abfd;
 216         struct a2l_data *a2l = NULL;
 217
 218         abfd = bfd_openr(path, NULL);
 219         if (abfd == NULL)
 220                 return NULL;
 221
 222         if (!bfd_check_format(abfd, bfd_object))
 223                 goto out;
 224
 225         a2l = zalloc(sizeof(*a2l));
 226         if (a2l == NULL)
 227                 goto out;
 228
 229         a2l->abfd = abfd;
 230         a2l->input = strdup(path);
 231         if (a2l->input == NULL)
 232                 goto out;
 233
 234         if (slurp_symtab(abfd, a2l))
 235                 goto out;
 236
 237         return a2l;
 238
 239 out:
 240         if (a2l) {
 241                 zfree((char **)&a2l->input);
 242                 free(a2l);
 243         }
 244         bfd_close(abfd);
 245         return NULL;
 246 }
 247
 248 static void addr2line_cleanup(struct a2l_data *a2l)
 249 {
 250         if (a2l->abfd)
 251                 bfd_close(a2l->abfd);
 252         zfree((char **)&a2l->input);
 253         zfree(&a2l->syms);
 254         free(a2l);
 255 }
 256
 257 #define MAX_INLINE_NEST 1024
 258
 259 static int inline_list__append_dso_a2l(struct dso *dso,
 260                                        struct inline_node *node,
 261                                        struct symbol *sym)
 262 {
 263         struct a2l_data *a2l = dso->a2l;
 264         struct symbol *inline_sym = new_inline_sym(dso, sym, a2l->funcname);
 265         char *srcline = NULL;
 266
 267         if (a2l->filename)
 268                 srcline = srcline_from_fileline(a2l->filename, a2l->line);
 269
 270         return inline_list__append(inline_sym, srcline, node);
 271 }
 272
 273 static int addr2line(const char *dso_name, u64 addr,
 274                      char **file, unsigned int *line, struct dso *dso,
 275                      bool unwind_inlines, struct inline_node *node,
 276                      struct symbol *sym)
 277 {
 278         int ret = 0;
 279         struct a2l_data *a2l = dso->a2l;
 280
 281         if (!a2l) {
 282                 dso->a2l = addr2line_init(dso_name);
 283                 a2l = dso->a2l;
 284         }
 285
 286         if (a2l == NULL) {
 287                 pr_warning("addr2line_init failed for %s\n", dso_name);
 288                 return 0;
 289         }
 290
 291         a2l->addr = addr;
 292         a2l->found = false;
 293
 294         bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
 295
 296         if (!a2l->found)
 297                 return 0;
 298
 299         if (unwind_inlines) {
 300                 int cnt = 0;
 301
 302                 if (node && inline_list__append_dso_a2l(dso, node, sym))
 303                         return 0;
 304
 305                 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
 306                                              &a2l->funcname, &a2l->line) &&
 307                        cnt++ < MAX_INLINE_NEST) {
 308
 309                         if (a2l->filename && !strlen(a2l->filename))
 310                                 a2l->filename = NULL;
 311
 312                         if (node != NULL) {
 313                                 if (inline_list__append_dso_a2l(dso, node, sym))
 314                                         return 0;
 315                                 // found at least one inline frame
 316                                 ret = 1;
 317                         }
 318                 }
 319         }
 320
 321         if (file) {
 322                 *file = a2l->filename ? strdup(a2l->filename) : NULL;
 323                 ret = *file ? 1 : 0;
 324         }
 325
 326         if (line)
 327                 *line = a2l->line;
 328
 329         return ret;
 330 }
 331
 332 void dso__free_a2l(struct dso *dso)
 333 {
 334         struct a2l_data *a2l = dso->a2l;
 335
 336         if (!a2l)
 337                 return;
 338
 339         addr2line_cleanup(a2l);
 340
 341         dso->a2l = NULL;
 342 }
 343
 344 static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
 345                                         struct dso *dso, struct symbol *sym)
 346 {
 347         struct inline_node *node;
 348
 349         node = zalloc(sizeof(*node));
 350         if (node == NULL) {
 351                 perror("not enough memory for the inline node");
 352                 return NULL;
 353         }
 354
 355         INIT_LIST_HEAD(&node->val);
 356         node->addr = addr;
 357
 358         addr2line(dso_name, addr, NULL, NULL, dso, true, node, sym);
 359         return node;
 360 }
 361
 362 #else /* HAVE_LIBBFD_SUPPORT */
 363
 364 static int filename_split(char *filename, unsigned int *line_nr)
 365 {
 366         char *sep;
 367
 368         sep = strchr(filename, '\n');
 369         if (sep)
 370                 *sep = '\0';
 371
 372         if (!strcmp(filename, "??:0"))
 373                 return 0;
 374
 375         sep = strchr(filename, ':');
 376         if (sep) {
 377                 *sep++ = '\0';
 378                 *line_nr = strtoul(sep, NULL, 0);
 379                 return 1;
 380         }
 381
 382         return 0;
 383 }
 384
 385 static int addr2line(const char *dso_name, u64 addr,
 386                      char **file, unsigned int *line_nr,
 387                      struct dso *dso __maybe_unused,
 388                      bool unwind_inlines __maybe_unused,
 389                      struct inline_node *node __maybe_unused,
 390                      struct symbol *sym __maybe_unused)
 391 {
 392         FILE *fp;
 393         char cmd[PATH_MAX];
 394         char *filename = NULL;
 395         size_t len;
 396         int ret = 0;
 397
 398         scnprintf(cmd, sizeof(cmd), "addr2line -e %s %016"PRIx64,
 399                   dso_name, addr);
 400
 401         fp = popen(cmd, "r");
 402         if (fp == NULL) {
 403                 pr_warning("popen failed for %s\n", dso_name);
 404                 return 0;
 405         }
 406
 407         if (getline(&filename, &len, fp) < 0 || !len) {
 408                 pr_warning("addr2line has no output for %s\n", dso_name);
 409                 goto out;
 410         }
 411
 412         ret = filename_split(filename, line_nr);
 413         if (ret != 1) {
 414                 free(filename);
 415                 goto out;
 416         }
 417
 418         *file = filename;
 419
 420 out:
 421         pclose(fp);
 422         return ret;
 423 }
 424
 425 void dso__free_a2l(struct dso *dso __maybe_unused)
 426 {
 427 }
 428
 429 static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
 430                                         struct dso *dso __maybe_unused,
 431                                         struct symbol *sym)
 432 {
 433         FILE *fp;
 434         char cmd[PATH_MAX];
 435         struct inline_node *node;
 436         char *filename = NULL;
 437         char *funcname = NULL;
 438         size_t filelen, funclen;
 439         unsigned int line_nr = 0;
 440
 441         scnprintf(cmd, sizeof(cmd), "addr2line -e %s -i -f %016"PRIx64,
 442                   dso_name, addr);
 443
 444         fp = popen(cmd, "r");
 445         if (fp == NULL) {
 446                 pr_err("popen failed for %s\n", dso_name);
 447                 return NULL;
 448         }
 449
 450         node = zalloc(sizeof(*node));
 451         if (node == NULL) {
 452                 perror("not enough memory for the inline node");
 453                 goto out;
 454         }
 455
 456         INIT_LIST_HEAD(&node->val);
 457         node->addr = addr;
 458
 459         /* addr2line -f generates two lines for each inlined functions */
 460         while (getline(&funcname, &funclen, fp) != -1) {
 461                 char *srcline;
 462                 struct symbol *inline_sym;
 463
 464                 rtrim(funcname);
 465
 466                 if (getline(&filename, &filelen, fp) == -1)
 467                         goto out;
 468
 469                 if (filename_split(filename, &line_nr) != 1)
 470                         goto out;
 471
 472                 srcline = srcline_from_fileline(filename, line_nr);
 473                 inline_sym = new_inline_sym(dso, sym, funcname);
 474
 475                 if (inline_list__append(inline_sym, srcline, node) != 0) {
 476                         free(srcline);
 477                         if (inline_sym && inline_sym->inlined)
 478                                 symbol__delete(inline_sym);
 479                         goto out;
 480                 }
 481         }
 482
 483 out:
 484         pclose(fp);
 485         free(filename);
 486         free(funcname);
 487
 488         return node;
 489 }
 490
 491 #endif /* HAVE_LIBBFD_SUPPORT */
 492
 493 /*
 494  * Number of addr2line failures (without success) before disabling it for that
 495  * dso.
 496  */
 497 #define A2L_FAIL_LIMIT 123
 498
 499 char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
 500                   bool show_sym, bool show_addr, bool unwind_inlines,
 501                   u64 ip)
 502 {
 503         char *file = NULL;
 504         unsigned line = 0;
 505         char *srcline;
 506         const char *dso_name;
 507
 508         if (!dso->has_srcline)
 509                 goto out;
 510
 511         dso_name = dso__name(dso);
 512         if (dso_name == NULL)
 513                 goto out;
 514
 515         if (!addr2line(dso_name, addr, &file, &line, dso,
 516                        unwind_inlines, NULL, sym))
 517                 goto out;
 518
 519         srcline = srcline_from_fileline(file, line);
 520         free(file);
 521
 522         if (!srcline)
 523                 goto out;
 524
 525         dso->a2l_fails = 0;
 526
 527         return srcline;
 528
 529 out:
 530         if (dso->a2l_fails && ++dso->a2l_fails > A2L_FAIL_LIMIT) {
 531                 dso->has_srcline = 0;
 532                 dso__free_a2l(dso);
 533         }
 534
 535         if (!show_addr)
 536                 return (show_sym && sym) ?
 537                             strndup(sym->name, sym->namelen) : NULL;
 538
 539         if (sym) {
 540                 if (asprintf(&srcline, "%s+%" PRIu64, show_sym ? sym->name : "",
 541                                         ip - sym->start) < 0)
 542                         return SRCLINE_UNKNOWN;
 543         } else if (asprintf(&srcline, "%s[%" PRIx64 "]", dso->short_name, addr) < 0)
 544                 return SRCLINE_UNKNOWN;
 545         return srcline;
 546 }
 547
 548 void free_srcline(char *srcline)
 549 {
 550         if (srcline && strcmp(srcline, SRCLINE_UNKNOWN) != 0)
 551                 free(srcline);
 552 }
 553
 554 char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
 555                   bool show_sym, bool show_addr, u64 ip)
 556 {
 557         return __get_srcline(dso, addr, sym, show_sym, show_addr, false, ip);
 558 }
 559
 560 struct srcline_node {
 561         u64                     addr;
 562         char                    *srcline;
 563         struct rb_node          rb_node;
 564 };
 565
 566 void srcline__tree_insert(struct rb_root *tree, u64 addr, char *srcline)
 567 {
 568         struct rb_node **p = &tree->rb_node;
 569         struct rb_node *parent = NULL;
 570         struct srcline_node *i, *node;
 571
 572         node = zalloc(sizeof(struct srcline_node));
 573         if (!node) {
 574                 perror("not enough memory for the srcline node");
 575                 return;
 576         }
 577
 578         node->addr = addr;
 579         node->srcline = srcline;
 580
 581         while (*p != NULL) {
 582                 parent = *p;
 583                 i = rb_entry(parent, struct srcline_node, rb_node);
 584                 if (addr < i->addr)
 585                         p = &(*p)->rb_left;
 586                 else
 587                         p = &(*p)->rb_right;
 588         }
 589         rb_link_node(&node->rb_node, parent, p);
 590         rb_insert_color(&node->rb_node, tree);
 591 }
 592
 593 char *srcline__tree_find(struct rb_root *tree, u64 addr)
 594 {
 595         struct rb_node *n = tree->rb_node;
 596
 597         while (n) {
 598                 struct srcline_node *i = rb_entry(n, struct srcline_node,
 599                                                   rb_node);
 600
 601                 if (addr < i->addr)
 602                         n = n->rb_left;
 603                 else if (addr > i->addr)
 604                         n = n->rb_right;
 605                 else
 606                         return i->srcline;
 607         }
 608
 609         return NULL;
 610 }
 611
 612 void srcline__tree_delete(struct rb_root *tree)
 613 {
 614         struct srcline_node *pos;
 615         struct rb_node *next = rb_first(tree);
 616
 617         while (next) {
 618                 pos = rb_entry(next, struct srcline_node, rb_node);
 619                 next = rb_next(&pos->rb_node);
 620                 rb_erase(&pos->rb_node, tree);
 621                 free_srcline(pos->srcline);
 622                 zfree(&pos);
 623         }
 624 }
 625
 626 struct inline_node *dso__parse_addr_inlines(struct dso *dso, u64 addr,
 627                                             struct symbol *sym)
 628 {
 629         const char *dso_name;
 630
 631         dso_name = dso__name(dso);
 632         if (dso_name == NULL)
 633                 return NULL;
 634
 635         return addr2inlines(dso_name, addr, dso, sym);
 636 }
 637
 638 void inline_node__delete(struct inline_node *node)
 639 {
 640         struct inline_list *ilist, *tmp;
 641
 642         list_for_each_entry_safe(ilist, tmp, &node->val, list) {
 643                 list_del_init(&ilist->list);
 644                 free_srcline(ilist->srcline);
 645                 /* only the inlined symbols are owned by the list */
 646                 if (ilist->symbol && ilist->symbol->inlined)
 647                         symbol__delete(ilist->symbol);
 648                 free(ilist);
 649         }
 650
 651         free(node);
 652 }
 653
 654 void inlines__tree_insert(struct rb_root *tree, struct inline_node *inlines)
 655 {
 656         struct rb_node **p = &tree->rb_node;
 657         struct rb_node *parent = NULL;
 658         const u64 addr = inlines->addr;
 659         struct inline_node *i;
 660
 661         while (*p != NULL) {
 662                 parent = *p;
 663                 i = rb_entry(parent, struct inline_node, rb_node);
 664                 if (addr < i->addr)
 665                         p = &(*p)->rb_left;
 666                 else
 667                         p = &(*p)->rb_right;
 668         }
 669         rb_link_node(&inlines->rb_node, parent, p);
 670         rb_insert_color(&inlines->rb_node, tree);
 671 }
 672
 673 struct inline_node *inlines__tree_find(struct rb_root *tree, u64 addr)
 674 {
 675         struct rb_node *n = tree->rb_node;
 676
 677         while (n) {
 678                 struct inline_node *i = rb_entry(n, struct inline_node,
 679                                                  rb_node);
 680
 681                 if (addr < i->addr)
 682                         n = n->rb_left;
 683                 else if (addr > i->addr)
 684                         n = n->rb_right;
 685                 else
 686                         return i;
 687         }
 688
 689         return NULL;
 690 }
 691
 692 void inlines__tree_delete(struct rb_root *tree)
 693 {
 694         struct inline_node *pos;
 695         struct rb_node *next = rb_first(tree);
 696
 697         while (next) {
 698                 pos = rb_entry(next, struct inline_node, rb_node);
 699                 next = rb_next(&pos->rb_node);
 700                 rb_erase(&pos->rb_node, tree);
 701                 inline_node__delete(pos);
 702         }
 703 }