1 // SPDX-License-Identifier: GPL-2.0 2 #include <inttypes.h> 3 #include <signal.h> 4 #include <stdio.h> 5 #include <stdlib.h> 6 #include <string.h> 7 #include <sys/types.h> 8 9 #include <linux/kernel.h> 10 #include <linux/string.h> 11 #include <linux/zalloc.h> 12 13 #include <api/io.h> 14 15 #include "util/dso.h" 16 #include "util/debug.h" 17 #include "util/callchain.h" 18 #include "util/symbol_conf.h" 19 #include "srcline.h" 20 #include "string2.h" 21 #include "symbol.h" 22 #include "subcmd/run-command.h" 23 24 /* If addr2line doesn't return data for 1 second then timeout. */ 25 int addr2line_timeout_ms = 1 * 1000; 26 bool srcline_full_filename; 27 28 char *srcline__unknown = (char *)"??:0"; 29 30 static const char *dso__name(struct dso *dso) 31 { 32 const char *dso_name; 33 34 if (dso->symsrc_filename) 35 dso_name = dso->symsrc_filename; 36 else 37 dso_name = dso->long_name; 38 39 if (dso_name[0] == '[') 40 return NULL; 41 42 if (!strncmp(dso_name, "/tmp/perf-", 10)) 43 return NULL; 44 45 return dso_name; 46 } 47 48 static int inline_list__append(struct symbol *symbol, char *srcline, 49 struct inline_node *node) 50 { 51 struct inline_list *ilist; 52 53 ilist = zalloc(sizeof(*ilist)); 54 if (ilist == NULL) 55 return -1; 56 57 ilist->symbol = symbol; 58 ilist->srcline = srcline; 59 60 if (callchain_param.order == ORDER_CALLEE) 61 list_add_tail(&ilist->list, &node->val); 62 else 63 list_add(&ilist->list, &node->val); 64 65 return 0; 66 } 67 68 /* basename version that takes a const input string */ 69 static const char *gnu_basename(const char *path) 70 { 71 const char *base = strrchr(path, '/'); 72 73 return base ? base + 1 : path; 74 } 75 76 static char *srcline_from_fileline(const char *file, unsigned int line) 77 { 78 char *srcline; 79 80 if (!file) 81 return NULL; 82 83 if (!srcline_full_filename) 84 file = gnu_basename(file); 85 86 if (asprintf(&srcline, "%s:%u", file, line) < 0) 87 return NULL; 88 89 return srcline; 90 } 91 92 static struct symbol *new_inline_sym(struct dso *dso, 93 struct symbol *base_sym, 94 const char *funcname) 95 { 96 struct symbol *inline_sym; 97 char *demangled = NULL; 98 99 if (!funcname) 100 funcname = "??"; 101 102 if (dso) { 103 demangled = dso__demangle_sym(dso, 0, funcname); 104 if (demangled) 105 funcname = demangled; 106 } 107 108 if (base_sym && strcmp(funcname, base_sym->name) == 0) { 109 /* reuse the real, existing symbol */ 110 inline_sym = base_sym; 111 /* ensure that we don't alias an inlined symbol, which could 112 * lead to double frees in inline_node__delete 113 */ 114 assert(!base_sym->inlined); 115 } else { 116 /* create a fake symbol for the inline frame */ 117 inline_sym = symbol__new(base_sym ? base_sym->start : 0, 118 base_sym ? (base_sym->end - base_sym->start) : 0, 119 base_sym ? base_sym->binding : 0, 120 base_sym ? base_sym->type : 0, 121 funcname); 122 if (inline_sym) 123 inline_sym->inlined = 1; 124 } 125 126 free(demangled); 127 128 return inline_sym; 129 } 130 131 #define MAX_INLINE_NEST 1024 132 133 #ifdef HAVE_LIBBFD_SUPPORT 134 135 /* 136 * Implement addr2line using libbfd. 137 */ 138 #define PACKAGE "perf" 139 #include <bfd.h> 140 141 struct a2l_data { 142 const char *input; 143 u64 addr; 144 145 bool found; 146 const char *filename; 147 const char *funcname; 148 unsigned line; 149 150 bfd *abfd; 151 asymbol **syms; 152 }; 153 154 static int bfd_error(const char *string) 155 { 156 const char *errmsg; 157 158 errmsg = bfd_errmsg(bfd_get_error()); 159 fflush(stdout); 160 161 if (string) 162 pr_debug("%s: %s\n", string, errmsg); 163 else 164 pr_debug("%s\n", errmsg); 165 166 return -1; 167 } 168 169 static int slurp_symtab(bfd *abfd, struct a2l_data *a2l) 170 { 171 long storage; 172 long symcount; 173 asymbol **syms; 174 bfd_boolean dynamic = FALSE; 175 176 if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0) 177 return bfd_error(bfd_get_filename(abfd)); 178 179 storage = bfd_get_symtab_upper_bound(abfd); 180 if (storage == 0L) { 181 storage = bfd_get_dynamic_symtab_upper_bound(abfd); 182 dynamic = TRUE; 183 } 184 if (storage < 0L) 185 return bfd_error(bfd_get_filename(abfd)); 186 187 syms = malloc(storage); 188 if (dynamic) 189 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms); 190 else 191 symcount = bfd_canonicalize_symtab(abfd, syms); 192 193 if (symcount < 0) { 194 free(syms); 195 return bfd_error(bfd_get_filename(abfd)); 196 } 197 198 a2l->syms = syms; 199 return 0; 200 } 201 202 static void find_address_in_section(bfd *abfd, asection *section, void *data) 203 { 204 bfd_vma pc, vma; 205 bfd_size_type size; 206 struct a2l_data *a2l = data; 207 flagword flags; 208 209 if (a2l->found) 210 return; 211 212 #ifdef bfd_get_section_flags 213 flags = bfd_get_section_flags(abfd, section); 214 #else 215 flags = bfd_section_flags(section); 216 #endif 217 if ((flags & SEC_ALLOC) == 0) 218 return; 219 220 pc = a2l->addr; 221 #ifdef bfd_get_section_vma 222 vma = bfd_get_section_vma(abfd, section); 223 #else 224 vma = bfd_section_vma(section); 225 #endif 226 #ifdef bfd_get_section_size 227 size = bfd_get_section_size(section); 228 #else 229 size = bfd_section_size(section); 230 #endif 231 232 if (pc < vma || pc >= vma + size) 233 return; 234 235 a2l->found = bfd_find_nearest_line(abfd, section, a2l->syms, pc - vma, 236 &a2l->filename, &a2l->funcname, 237 &a2l->line); 238 239 if (a2l->filename && !strlen(a2l->filename)) 240 a2l->filename = NULL; 241 } 242 243 static struct a2l_data *addr2line_init(const char *path) 244 { 245 bfd *abfd; 246 struct a2l_data *a2l = NULL; 247 248 abfd = bfd_openr(path, NULL); 249 if (abfd == NULL) 250 return NULL; 251 252 if (!bfd_check_format(abfd, bfd_object)) 253 goto out; 254 255 a2l = zalloc(sizeof(*a2l)); 256 if (a2l == NULL) 257 goto out; 258 259 a2l->abfd = abfd; 260 a2l->input = strdup(path); 261 if (a2l->input == NULL) 262 goto out; 263 264 if (slurp_symtab(abfd, a2l)) 265 goto out; 266 267 return a2l; 268 269 out: 270 if (a2l) { 271 zfree((char **)&a2l->input); 272 free(a2l); 273 } 274 bfd_close(abfd); 275 return NULL; 276 } 277 278 static void addr2line_cleanup(struct a2l_data *a2l) 279 { 280 if (a2l->abfd) 281 bfd_close(a2l->abfd); 282 zfree((char **)&a2l->input); 283 zfree(&a2l->syms); 284 free(a2l); 285 } 286 287 static int inline_list__append_dso_a2l(struct dso *dso, 288 struct inline_node *node, 289 struct symbol *sym) 290 { 291 struct a2l_data *a2l = dso->a2l; 292 struct symbol *inline_sym = new_inline_sym(dso, sym, a2l->funcname); 293 char *srcline = NULL; 294 295 if (a2l->filename) 296 srcline = srcline_from_fileline(a2l->filename, a2l->line); 297 298 return inline_list__append(inline_sym, srcline, node); 299 } 300 301 static int addr2line(const char *dso_name, u64 addr, 302 char **file, unsigned int *line, struct dso *dso, 303 bool unwind_inlines, struct inline_node *node, 304 struct symbol *sym) 305 { 306 int ret = 0; 307 struct a2l_data *a2l = dso->a2l; 308 309 if (!a2l) { 310 dso->a2l = addr2line_init(dso_name); 311 a2l = dso->a2l; 312 } 313 314 if (a2l == NULL) { 315 if (!symbol_conf.disable_add2line_warn) 316 pr_warning("addr2line_init failed for %s\n", dso_name); 317 return 0; 318 } 319 320 a2l->addr = addr; 321 a2l->found = false; 322 323 bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l); 324 325 if (!a2l->found) 326 return 0; 327 328 if (unwind_inlines) { 329 int cnt = 0; 330 331 if (node && inline_list__append_dso_a2l(dso, node, sym)) 332 return 0; 333 334 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename, 335 &a2l->funcname, &a2l->line) && 336 cnt++ < MAX_INLINE_NEST) { 337 338 if (a2l->filename && !strlen(a2l->filename)) 339 a2l->filename = NULL; 340 341 if (node != NULL) { 342 if (inline_list__append_dso_a2l(dso, node, sym)) 343 return 0; 344 // found at least one inline frame 345 ret = 1; 346 } 347 } 348 } 349 350 if (file) { 351 *file = a2l->filename ? strdup(a2l->filename) : NULL; 352 ret = *file ? 1 : 0; 353 } 354 355 if (line) 356 *line = a2l->line; 357 358 return ret; 359 } 360 361 void dso__free_a2l(struct dso *dso) 362 { 363 struct a2l_data *a2l = dso->a2l; 364 365 if (!a2l) 366 return; 367 368 addr2line_cleanup(a2l); 369 370 dso->a2l = NULL; 371 } 372 373 #else /* HAVE_LIBBFD_SUPPORT */ 374 375 static int filename_split(char *filename, unsigned int *line_nr) 376 { 377 char *sep; 378 379 sep = strchr(filename, '\n'); 380 if (sep) 381 *sep = '\0'; 382 383 if (!strcmp(filename, "??:0")) 384 return 0; 385 386 sep = strchr(filename, ':'); 387 if (sep) { 388 *sep++ = '\0'; 389 *line_nr = strtoul(sep, NULL, 0); 390 return 1; 391 } 392 pr_debug("addr2line missing ':' in filename split\n"); 393 return 0; 394 } 395 396 static void addr2line_subprocess_cleanup(struct child_process *a2l) 397 { 398 if (a2l->pid != -1) { 399 kill(a2l->pid, SIGKILL); 400 finish_command(a2l); /* ignore result, we don't care */ 401 a2l->pid = -1; 402 } 403 404 free(a2l); 405 } 406 407 static struct child_process *addr2line_subprocess_init(const char *addr2line_path, 408 const char *binary_path) 409 { 410 const char *argv[] = { 411 addr2line_path ?: "addr2line", 412 "-e", binary_path, 413 "-a", "-i", "-f", NULL 414 }; 415 struct child_process *a2l = zalloc(sizeof(*a2l)); 416 int start_command_status = 0; 417 418 if (a2l == NULL) { 419 pr_err("Failed to allocate memory for addr2line"); 420 return NULL; 421 } 422 423 a2l->pid = -1; 424 a2l->in = -1; 425 a2l->out = -1; 426 a2l->no_stderr = 1; 427 428 a2l->argv = argv; 429 start_command_status = start_command(a2l); 430 a2l->argv = NULL; /* it's not used after start_command; avoid dangling pointers */ 431 432 if (start_command_status != 0) { 433 pr_warning("could not start addr2line (%s) for %s: start_command return code %d\n", 434 addr2line_path, binary_path, start_command_status); 435 addr2line_subprocess_cleanup(a2l); 436 return NULL; 437 } 438 439 return a2l; 440 } 441 442 enum a2l_style { 443 BROKEN, 444 GNU_BINUTILS, 445 LLVM, 446 }; 447 448 static enum a2l_style addr2line_configure(struct child_process *a2l, const char *dso_name) 449 { 450 static bool cached; 451 static enum a2l_style style; 452 453 if (!cached) { 454 char buf[128]; 455 struct io io; 456 int ch; 457 int lines; 458 459 if (write(a2l->in, ",\n", 2) != 2) 460 return BROKEN; 461 462 io__init(&io, a2l->out, buf, sizeof(buf)); 463 ch = io__get_char(&io); 464 if (ch == ',') { 465 style = LLVM; 466 cached = true; 467 lines = 1; 468 pr_debug("Detected LLVM addr2line style\n"); 469 } else if (ch == '0') { 470 style = GNU_BINUTILS; 471 cached = true; 472 lines = 3; 473 pr_debug("Detected binutils addr2line style\n"); 474 } else { 475 if (!symbol_conf.disable_add2line_warn) { 476 char *output = NULL; 477 size_t output_len; 478 479 io__getline(&io, &output, &output_len); 480 pr_warning("%s %s: addr2line configuration failed\n", 481 __func__, dso_name); 482 pr_warning("\t%c%s", ch, output); 483 } 484 pr_debug("Unknown/broken addr2line style\n"); 485 return BROKEN; 486 } 487 while (lines) { 488 ch = io__get_char(&io); 489 if (ch <= 0) 490 break; 491 if (ch == '\n') 492 lines--; 493 } 494 /* Ignore SIGPIPE in the event addr2line exits. */ 495 signal(SIGPIPE, SIG_IGN); 496 } 497 return style; 498 } 499 500 static int read_addr2line_record(struct io *io, 501 enum a2l_style style, 502 const char *dso_name, 503 u64 addr, 504 bool first, 505 char **function, 506 char **filename, 507 unsigned int *line_nr) 508 { 509 /* 510 * Returns: 511 * -1 ==> error 512 * 0 ==> sentinel (or other ill-formed) record read 513 * 1 ==> a genuine record read 514 */ 515 char *line = NULL; 516 size_t line_len = 0; 517 unsigned int dummy_line_nr = 0; 518 int ret = -1; 519 520 if (function != NULL) 521 zfree(function); 522 523 if (filename != NULL) 524 zfree(filename); 525 526 if (line_nr != NULL) 527 *line_nr = 0; 528 529 /* 530 * Read the first line. Without an error this will be: 531 * - for the first line an address like 0x1234, 532 * - the binutils sentinel 0x0000000000000000, 533 * - the llvm-addr2line the sentinel ',' character, 534 * - the function name line for an inlined function. 535 */ 536 if (io__getline(io, &line, &line_len) < 0 || !line_len) 537 goto error; 538 539 pr_debug("%s %s: addr2line read address for sentinel: %s", __func__, dso_name, line); 540 if (style == LLVM && line_len == 2 && line[0] == ',') { 541 /* Found the llvm-addr2line sentinel character. */ 542 zfree(&line); 543 return 0; 544 } else if (style == GNU_BINUTILS && (!first || addr != 0)) { 545 int zero_count = 0, non_zero_count = 0; 546 /* 547 * Check for binutils sentinel ignoring it for the case the 548 * requested address is 0. 549 */ 550 551 /* A given address should always start 0x. */ 552 if (line_len >= 2 || line[0] != '0' || line[1] != 'x') { 553 for (size_t i = 2; i < line_len; i++) { 554 if (line[i] == '0') 555 zero_count++; 556 else if (line[i] != '\n') 557 non_zero_count++; 558 } 559 if (!non_zero_count) { 560 int ch; 561 562 if (first && !zero_count) { 563 /* Line was erroneous just '0x'. */ 564 goto error; 565 } 566 /* 567 * Line was 0x0..0, the sentinel for binutils. Remove 568 * the function and filename lines. 569 */ 570 zfree(&line); 571 do { 572 ch = io__get_char(io); 573 } while (ch > 0 && ch != '\n'); 574 do { 575 ch = io__get_char(io); 576 } while (ch > 0 && ch != '\n'); 577 return 0; 578 } 579 } 580 } 581 /* Read the second function name line (if inline data then this is the first line). */ 582 if (first && (io__getline(io, &line, &line_len) < 0 || !line_len)) 583 goto error; 584 585 pr_debug("%s %s: addr2line read line: %s", __func__, dso_name, line); 586 if (function != NULL) 587 *function = strdup(strim(line)); 588 589 zfree(&line); 590 line_len = 0; 591 592 /* Read the third filename and line number line. */ 593 if (io__getline(io, &line, &line_len) < 0 || !line_len) 594 goto error; 595 596 pr_debug("%s %s: addr2line filename:number : %s", __func__, dso_name, line); 597 if (filename_split(line, line_nr == NULL ? &dummy_line_nr : line_nr) == 0 && 598 style == GNU_BINUTILS) { 599 ret = 0; 600 goto error; 601 } 602 603 if (filename != NULL) 604 *filename = strdup(line); 605 606 zfree(&line); 607 line_len = 0; 608 609 return 1; 610 611 error: 612 free(line); 613 if (function != NULL) 614 zfree(function); 615 if (filename != NULL) 616 zfree(filename); 617 return ret; 618 } 619 620 static int inline_list__append_record(struct dso *dso, 621 struct inline_node *node, 622 struct symbol *sym, 623 const char *function, 624 const char *filename, 625 unsigned int line_nr) 626 { 627 struct symbol *inline_sym = new_inline_sym(dso, sym, function); 628 629 return inline_list__append(inline_sym, srcline_from_fileline(filename, line_nr), node); 630 } 631 632 static int addr2line(const char *dso_name, u64 addr, 633 char **file, unsigned int *line_nr, 634 struct dso *dso, 635 bool unwind_inlines, 636 struct inline_node *node, 637 struct symbol *sym __maybe_unused) 638 { 639 struct child_process *a2l = dso->a2l; 640 char *record_function = NULL; 641 char *record_filename = NULL; 642 unsigned int record_line_nr = 0; 643 int record_status = -1; 644 int ret = 0; 645 size_t inline_count = 0; 646 int len; 647 char buf[128]; 648 ssize_t written; 649 struct io io = { .eof = false }; 650 enum a2l_style a2l_style; 651 652 if (!a2l) { 653 if (!filename__has_section(dso_name, ".debug_line")) 654 goto out; 655 656 dso->a2l = addr2line_subprocess_init(symbol_conf.addr2line_path, dso_name); 657 a2l = dso->a2l; 658 } 659 660 if (a2l == NULL) { 661 if (!symbol_conf.disable_add2line_warn) 662 pr_warning("%s %s: addr2line_subprocess_init failed\n", __func__, dso_name); 663 goto out; 664 } 665 a2l_style = addr2line_configure(a2l, dso_name); 666 if (a2l_style == BROKEN) 667 goto out; 668 669 /* 670 * Send our request and then *deliberately* send something that can't be 671 * interpreted as a valid address to ask addr2line about (namely, 672 * ","). This causes addr2line to first write out the answer to our 673 * request, in an unbounded/unknown number of records, and then to write 674 * out the lines "0x0...0", "??" and "??:0", for GNU binutils, or "," 675 * for llvm-addr2line, so that we can detect when it has finished giving 676 * us anything useful. 677 */ 678 len = snprintf(buf, sizeof(buf), "%016"PRIx64"\n,\n", addr); 679 written = len > 0 ? write(a2l->in, buf, len) : -1; 680 if (written != len) { 681 if (!symbol_conf.disable_add2line_warn) 682 pr_warning("%s %s: could not send request\n", __func__, dso_name); 683 goto out; 684 } 685 io__init(&io, a2l->out, buf, sizeof(buf)); 686 io.timeout_ms = addr2line_timeout_ms; 687 switch (read_addr2line_record(&io, a2l_style, dso_name, addr, /*first=*/true, 688 &record_function, &record_filename, &record_line_nr)) { 689 case -1: 690 if (!symbol_conf.disable_add2line_warn) 691 pr_warning("%s %s: could not read first record\n", __func__, dso_name); 692 goto out; 693 case 0: 694 /* 695 * The first record was invalid, so return failure, but first 696 * read another record, since we sent a sentinel ',' for the 697 * sake of detected the last inlined function. Treat this as the 698 * first of a record as the ',' generates a new start with GNU 699 * binutils, also force a non-zero address as we're no longer 700 * reading that record. 701 */ 702 switch (read_addr2line_record(&io, a2l_style, dso_name, 703 /*addr=*/1, /*first=*/true, 704 NULL, NULL, NULL)) { 705 case -1: 706 if (!symbol_conf.disable_add2line_warn) 707 pr_warning("%s %s: could not read sentinel record\n", 708 __func__, dso_name); 709 break; 710 case 0: 711 /* The sentinel as expected. */ 712 break; 713 default: 714 if (!symbol_conf.disable_add2line_warn) 715 pr_warning("%s %s: unexpected record instead of sentinel", 716 __func__, dso_name); 717 break; 718 } 719 goto out; 720 default: 721 /* First record as expected. */ 722 break; 723 } 724 725 if (file) { 726 *file = strdup(record_filename); 727 ret = 1; 728 } 729 if (line_nr) 730 *line_nr = record_line_nr; 731 732 if (unwind_inlines) { 733 if (node && inline_list__append_record(dso, node, sym, 734 record_function, 735 record_filename, 736 record_line_nr)) { 737 ret = 0; 738 goto out; 739 } 740 } 741 742 /* 743 * We have to read the records even if we don't care about the inline 744 * info. This isn't the first record and force the address to non-zero 745 * as we're reading records beyond the first. 746 */ 747 while ((record_status = read_addr2line_record(&io, 748 a2l_style, 749 dso_name, 750 /*addr=*/1, 751 /*first=*/false, 752 &record_function, 753 &record_filename, 754 &record_line_nr)) == 1) { 755 if (unwind_inlines && node && inline_count++ < MAX_INLINE_NEST) { 756 if (inline_list__append_record(dso, node, sym, 757 record_function, 758 record_filename, 759 record_line_nr)) { 760 ret = 0; 761 goto out; 762 } 763 ret = 1; /* found at least one inline frame */ 764 } 765 } 766 767 out: 768 free(record_function); 769 free(record_filename); 770 if (io.eof) { 771 dso->a2l = NULL; 772 addr2line_subprocess_cleanup(a2l); 773 } 774 return ret; 775 } 776 777 void dso__free_a2l(struct dso *dso) 778 { 779 struct child_process *a2l = dso->a2l; 780 781 if (!a2l) 782 return; 783 784 addr2line_subprocess_cleanup(a2l); 785 786 dso->a2l = NULL; 787 } 788 789 #endif /* HAVE_LIBBFD_SUPPORT */ 790 791 static struct inline_node *addr2inlines(const char *dso_name, u64 addr, 792 struct dso *dso, struct symbol *sym) 793 { 794 struct inline_node *node; 795 796 node = zalloc(sizeof(*node)); 797 if (node == NULL) { 798 perror("not enough memory for the inline node"); 799 return NULL; 800 } 801 802 INIT_LIST_HEAD(&node->val); 803 node->addr = addr; 804 805 addr2line(dso_name, addr, NULL, NULL, dso, true, node, sym); 806 return node; 807 } 808 809 /* 810 * Number of addr2line failures (without success) before disabling it for that 811 * dso. 812 */ 813 #define A2L_FAIL_LIMIT 123 814 815 char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym, 816 bool show_sym, bool show_addr, bool unwind_inlines, 817 u64 ip) 818 { 819 char *file = NULL; 820 unsigned line = 0; 821 char *srcline; 822 const char *dso_name; 823 824 if (!dso->has_srcline) 825 goto out; 826 827 dso_name = dso__name(dso); 828 if (dso_name == NULL) 829 goto out; 830 831 if (!addr2line(dso_name, addr, &file, &line, dso, 832 unwind_inlines, NULL, sym)) 833 goto out; 834 835 srcline = srcline_from_fileline(file, line); 836 free(file); 837 838 if (!srcline) 839 goto out; 840 841 dso->a2l_fails = 0; 842 843 return srcline; 844 845 out: 846 if (dso->a2l_fails && ++dso->a2l_fails > A2L_FAIL_LIMIT) { 847 dso->has_srcline = 0; 848 dso__free_a2l(dso); 849 } 850 851 if (!show_addr) 852 return (show_sym && sym) ? 853 strndup(sym->name, sym->namelen) : SRCLINE_UNKNOWN; 854 855 if (sym) { 856 if (asprintf(&srcline, "%s+%" PRIu64, show_sym ? sym->name : "", 857 ip - sym->start) < 0) 858 return SRCLINE_UNKNOWN; 859 } else if (asprintf(&srcline, "%s[%" PRIx64 "]", dso->short_name, addr) < 0) 860 return SRCLINE_UNKNOWN; 861 return srcline; 862 } 863 864 /* Returns filename and fills in line number in line */ 865 char *get_srcline_split(struct dso *dso, u64 addr, unsigned *line) 866 { 867 char *file = NULL; 868 const char *dso_name; 869 870 if (!dso->has_srcline) 871 goto out; 872 873 dso_name = dso__name(dso); 874 if (dso_name == NULL) 875 goto out; 876 877 if (!addr2line(dso_name, addr, &file, line, dso, true, NULL, NULL)) 878 goto out; 879 880 dso->a2l_fails = 0; 881 return file; 882 883 out: 884 if (dso->a2l_fails && ++dso->a2l_fails > A2L_FAIL_LIMIT) { 885 dso->has_srcline = 0; 886 dso__free_a2l(dso); 887 } 888 889 return NULL; 890 } 891 892 void zfree_srcline(char **srcline) 893 { 894 if (*srcline == NULL) 895 return; 896 897 if (*srcline != SRCLINE_UNKNOWN) 898 free(*srcline); 899 900 *srcline = NULL; 901 } 902 903 char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym, 904 bool show_sym, bool show_addr, u64 ip) 905 { 906 return __get_srcline(dso, addr, sym, show_sym, show_addr, false, ip); 907 } 908 909 struct srcline_node { 910 u64 addr; 911 char *srcline; 912 struct rb_node rb_node; 913 }; 914 915 void srcline__tree_insert(struct rb_root_cached *tree, u64 addr, char *srcline) 916 { 917 struct rb_node **p = &tree->rb_root.rb_node; 918 struct rb_node *parent = NULL; 919 struct srcline_node *i, *node; 920 bool leftmost = true; 921 922 node = zalloc(sizeof(struct srcline_node)); 923 if (!node) { 924 perror("not enough memory for the srcline node"); 925 return; 926 } 927 928 node->addr = addr; 929 node->srcline = srcline; 930 931 while (*p != NULL) { 932 parent = *p; 933 i = rb_entry(parent, struct srcline_node, rb_node); 934 if (addr < i->addr) 935 p = &(*p)->rb_left; 936 else { 937 p = &(*p)->rb_right; 938 leftmost = false; 939 } 940 } 941 rb_link_node(&node->rb_node, parent, p); 942 rb_insert_color_cached(&node->rb_node, tree, leftmost); 943 } 944 945 char *srcline__tree_find(struct rb_root_cached *tree, u64 addr) 946 { 947 struct rb_node *n = tree->rb_root.rb_node; 948 949 while (n) { 950 struct srcline_node *i = rb_entry(n, struct srcline_node, 951 rb_node); 952 953 if (addr < i->addr) 954 n = n->rb_left; 955 else if (addr > i->addr) 956 n = n->rb_right; 957 else 958 return i->srcline; 959 } 960 961 return NULL; 962 } 963 964 void srcline__tree_delete(struct rb_root_cached *tree) 965 { 966 struct srcline_node *pos; 967 struct rb_node *next = rb_first_cached(tree); 968 969 while (next) { 970 pos = rb_entry(next, struct srcline_node, rb_node); 971 next = rb_next(&pos->rb_node); 972 rb_erase_cached(&pos->rb_node, tree); 973 zfree_srcline(&pos->srcline); 974 zfree(&pos); 975 } 976 } 977 978 struct inline_node *dso__parse_addr_inlines(struct dso *dso, u64 addr, 979 struct symbol *sym) 980 { 981 const char *dso_name; 982 983 dso_name = dso__name(dso); 984 if (dso_name == NULL) 985 return NULL; 986 987 return addr2inlines(dso_name, addr, dso, sym); 988 } 989 990 void inline_node__delete(struct inline_node *node) 991 { 992 struct inline_list *ilist, *tmp; 993 994 list_for_each_entry_safe(ilist, tmp, &node->val, list) { 995 list_del_init(&ilist->list); 996 zfree_srcline(&ilist->srcline); 997 /* only the inlined symbols are owned by the list */ 998 if (ilist->symbol && ilist->symbol->inlined) 999 symbol__delete(ilist->symbol); 1000 free(ilist); 1001 } 1002 1003 free(node); 1004 } 1005 1006 void inlines__tree_insert(struct rb_root_cached *tree, 1007 struct inline_node *inlines) 1008 { 1009 struct rb_node **p = &tree->rb_root.rb_node; 1010 struct rb_node *parent = NULL; 1011 const u64 addr = inlines->addr; 1012 struct inline_node *i; 1013 bool leftmost = true; 1014 1015 while (*p != NULL) { 1016 parent = *p; 1017 i = rb_entry(parent, struct inline_node, rb_node); 1018 if (addr < i->addr) 1019 p = &(*p)->rb_left; 1020 else { 1021 p = &(*p)->rb_right; 1022 leftmost = false; 1023 } 1024 } 1025 rb_link_node(&inlines->rb_node, parent, p); 1026 rb_insert_color_cached(&inlines->rb_node, tree, leftmost); 1027 } 1028 1029 struct inline_node *inlines__tree_find(struct rb_root_cached *tree, u64 addr) 1030 { 1031 struct rb_node *n = tree->rb_root.rb_node; 1032 1033 while (n) { 1034 struct inline_node *i = rb_entry(n, struct inline_node, 1035 rb_node); 1036 1037 if (addr < i->addr) 1038 n = n->rb_left; 1039 else if (addr > i->addr) 1040 n = n->rb_right; 1041 else 1042 return i; 1043 } 1044 1045 return NULL; 1046 } 1047 1048 void inlines__tree_delete(struct rb_root_cached *tree) 1049 { 1050 struct inline_node *pos; 1051 struct rb_node *next = rb_first_cached(tree); 1052 1053 while (next) { 1054 pos = rb_entry(next, struct inline_node, rb_node); 1055 next = rb_next(&pos->rb_node); 1056 rb_erase_cached(&pos->rb_node, tree); 1057 inline_node__delete(pos); 1058 } 1059 } 1060