1 // SPDX-License-Identifier: GPL-2.0 2 #include "libbfd.h" 3 #include "annotate.h" 4 #include "bpf-event.h" 5 #include "bpf-utils.h" 6 #include "debug.h" 7 #include "dso.h" 8 #include "env.h" 9 #include "map.h" 10 #include "srcline.h" 11 #include "symbol.h" 12 #include "symbol_conf.h" 13 #include "util.h" 14 #include <tools/dis-asm-compat.h> 15 #ifdef HAVE_LIBBPF_SUPPORT 16 #include <bpf/bpf.h> 17 #include <bpf/btf.h> 18 #endif 19 #include <fcntl.h> 20 #include <stdio.h> 21 #include <stdlib.h> 22 #define PACKAGE "perf" 23 #include <bfd.h> 24 25 /* 26 * Implement addr2line using libbfd. 27 */ 28 struct a2l_data { 29 const char *input; 30 u64 addr; 31 32 bool found; 33 const char *filename; 34 const char *funcname; 35 unsigned int line; 36 37 bfd *abfd; 38 asymbol **syms; 39 }; 40 41 static bool perf_bfd_lock(void *bfd_mutex) 42 { 43 mutex_lock(bfd_mutex); 44 return true; 45 } 46 47 static bool perf_bfd_unlock(void *bfd_mutex) 48 { 49 mutex_unlock(bfd_mutex); 50 return true; 51 } 52 53 static void perf_bfd_init(void) 54 { 55 static struct mutex bfd_mutex; 56 57 mutex_init_recursive(&bfd_mutex); 58 59 if (bfd_init() != BFD_INIT_MAGIC) { 60 pr_err("Error initializing libbfd\n"); 61 return; 62 } 63 if (!bfd_thread_init(perf_bfd_lock, perf_bfd_unlock, &bfd_mutex)) 64 pr_err("Error initializing libbfd threading\n"); 65 } 66 67 static void ensure_bfd_init(void) 68 { 69 static pthread_once_t bfd_init_once = PTHREAD_ONCE_INIT; 70 71 pthread_once(&bfd_init_once, perf_bfd_init); 72 } 73 74 static int bfd_error(const char *string) 75 { 76 const char *errmsg; 77 78 errmsg = bfd_errmsg(bfd_get_error()); 79 fflush(stdout); 80 81 if (string) 82 pr_debug("%s: %s\n", string, errmsg); 83 else 84 pr_debug("%s\n", errmsg); 85 86 return -1; 87 } 88 89 static int slurp_symtab(bfd *abfd, struct a2l_data *a2l) 90 { 91 long storage; 92 long symcount; 93 asymbol **syms; 94 bfd_boolean dynamic = FALSE; 95 96 if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0) 97 return bfd_error(bfd_get_filename(abfd)); 98 99 storage = bfd_get_symtab_upper_bound(abfd); 100 if (storage == 0L) { 101 storage = bfd_get_dynamic_symtab_upper_bound(abfd); 102 dynamic = TRUE; 103 } 104 if (storage < 0L) 105 return bfd_error(bfd_get_filename(abfd)); 106 107 syms = malloc(storage); 108 if (dynamic) 109 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms); 110 else 111 symcount = bfd_canonicalize_symtab(abfd, syms); 112 113 if (symcount < 0) { 114 free(syms); 115 return bfd_error(bfd_get_filename(abfd)); 116 } 117 118 a2l->syms = syms; 119 return 0; 120 } 121 122 static void find_address_in_section(bfd *abfd, asection *section, void *data) 123 { 124 bfd_vma pc, vma; 125 bfd_size_type size; 126 struct a2l_data *a2l = data; 127 flagword flags; 128 129 if (a2l->found) 130 return; 131 132 #ifdef bfd_get_section_flags 133 flags = bfd_get_section_flags(abfd, section); 134 #else 135 flags = bfd_section_flags(section); 136 #endif 137 if ((flags & SEC_ALLOC) == 0) 138 return; 139 140 pc = a2l->addr; 141 #ifdef bfd_get_section_vma 142 vma = bfd_get_section_vma(abfd, section); 143 #else 144 vma = bfd_section_vma(section); 145 #endif 146 #ifdef bfd_get_section_size 147 size = bfd_get_section_size(section); 148 #else 149 size = bfd_section_size(section); 150 #endif 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 ensure_bfd_init(); 169 abfd = bfd_openr(path, NULL); 170 if (abfd == NULL) 171 return NULL; 172 173 if (!bfd_check_format(abfd, bfd_object)) 174 goto out; 175 176 a2l = zalloc(sizeof(*a2l)); 177 if (a2l == NULL) 178 goto out; 179 180 a2l->abfd = abfd; 181 a2l->input = strdup(path); 182 if (a2l->input == NULL) 183 goto out; 184 185 if (slurp_symtab(abfd, a2l)) 186 goto out; 187 188 return a2l; 189 190 out: 191 if (a2l) { 192 zfree((char **)&a2l->input); 193 free(a2l); 194 } 195 bfd_close(abfd); 196 return NULL; 197 } 198 199 static void addr2line_cleanup(struct a2l_data *a2l) 200 { 201 if (a2l->abfd) 202 bfd_close(a2l->abfd); 203 zfree((char **)&a2l->input); 204 zfree(&a2l->syms); 205 free(a2l); 206 } 207 208 static int inline_list__append_dso_a2l(struct dso *dso, 209 struct inline_node *node, 210 struct symbol *sym) 211 { 212 struct a2l_data *a2l = dso__a2l(dso); 213 struct symbol *inline_sym = new_inline_sym(dso, sym, a2l->funcname); 214 char *srcline = NULL; 215 216 if (a2l->filename) 217 srcline = srcline_from_fileline(a2l->filename, a2l->line); 218 219 return inline_list__append(inline_sym, srcline, node); 220 } 221 222 int libbfd__addr2line(const char *dso_name, u64 addr, 223 char **file, unsigned int *line, struct dso *dso, 224 bool unwind_inlines, struct inline_node *node, 225 struct symbol *sym) 226 { 227 int ret = 0; 228 struct a2l_data *a2l = dso__a2l(dso); 229 230 if (!a2l) { 231 a2l = addr2line_init(dso_name); 232 dso__set_a2l(dso, a2l); 233 } 234 235 if (a2l == NULL) { 236 if (!symbol_conf.disable_add2line_warn) 237 pr_warning("addr2line_init failed for %s\n", dso_name); 238 return 0; 239 } 240 241 a2l->addr = addr; 242 a2l->found = false; 243 244 bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l); 245 246 if (!a2l->found) 247 return 0; 248 249 if (unwind_inlines) { 250 int cnt = 0; 251 252 if (node && inline_list__append_dso_a2l(dso, node, sym)) 253 return 0; 254 255 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename, 256 &a2l->funcname, &a2l->line) && 257 cnt++ < MAX_INLINE_NEST) { 258 259 if (a2l->filename && !strlen(a2l->filename)) 260 a2l->filename = NULL; 261 262 if (node != NULL) { 263 if (inline_list__append_dso_a2l(dso, node, sym)) 264 return 0; 265 // found at least one inline frame 266 ret = 1; 267 } 268 } 269 } 270 271 if (file) { 272 *file = a2l->filename ? strdup(a2l->filename) : NULL; 273 ret = *file ? 1 : 0; 274 } 275 276 if (line) 277 *line = a2l->line; 278 279 return ret; 280 } 281 282 void dso__free_a2l_libbfd(struct dso *dso) 283 { 284 struct a2l_data *a2l = dso__a2l(dso); 285 286 if (!a2l) 287 return; 288 289 addr2line_cleanup(a2l); 290 291 dso__set_a2l(dso, NULL); 292 } 293 294 static int bfd_symbols__cmpvalue(const void *a, const void *b) 295 { 296 const asymbol *as = *(const asymbol **)a, *bs = *(const asymbol **)b; 297 298 if (bfd_asymbol_value(as) != bfd_asymbol_value(bs)) 299 return bfd_asymbol_value(as) - bfd_asymbol_value(bs); 300 301 return bfd_asymbol_name(as)[0] - bfd_asymbol_name(bs)[0]; 302 } 303 304 static int bfd2elf_binding(asymbol *symbol) 305 { 306 if (symbol->flags & BSF_WEAK) 307 return STB_WEAK; 308 if (symbol->flags & BSF_GLOBAL) 309 return STB_GLOBAL; 310 if (symbol->flags & BSF_LOCAL) 311 return STB_LOCAL; 312 return -1; 313 } 314 315 int dso__load_bfd_symbols(struct dso *dso, const char *debugfile) 316 { 317 int err = -1; 318 long symbols_size, symbols_count, i; 319 asection *section; 320 asymbol **symbols, *sym; 321 struct symbol *symbol; 322 bfd *abfd; 323 u64 start, len; 324 325 ensure_bfd_init(); 326 abfd = bfd_openr(debugfile, NULL); 327 if (!abfd) 328 return -1; 329 330 if (!bfd_check_format(abfd, bfd_object)) { 331 pr_debug2("%s: cannot read %s bfd file.\n", __func__, 332 dso__long_name(dso)); 333 goto out_close; 334 } 335 336 if (bfd_get_flavour(abfd) == bfd_target_elf_flavour) 337 goto out_close; 338 339 symbols_size = bfd_get_symtab_upper_bound(abfd); 340 if (symbols_size == 0) { 341 bfd_close(abfd); 342 return 0; 343 } 344 345 if (symbols_size < 0) 346 goto out_close; 347 348 symbols = malloc(symbols_size); 349 if (!symbols) 350 goto out_close; 351 352 symbols_count = bfd_canonicalize_symtab(abfd, symbols); 353 if (symbols_count < 0) 354 goto out_free; 355 356 section = bfd_get_section_by_name(abfd, ".text"); 357 if (section) { 358 for (i = 0; i < symbols_count; ++i) { 359 if (!strcmp(bfd_asymbol_name(symbols[i]), "__ImageBase") || 360 !strcmp(bfd_asymbol_name(symbols[i]), "__image_base__")) 361 break; 362 } 363 if (i < symbols_count) { 364 /* PE symbols can only have 4 bytes, so use .text high bits */ 365 u64 text_offset = (section->vma - (u32)section->vma) 366 + (u32)bfd_asymbol_value(symbols[i]); 367 dso__set_text_offset(dso, text_offset); 368 dso__set_text_end(dso, (section->vma - text_offset) + section->size); 369 } else { 370 dso__set_text_offset(dso, section->vma - section->filepos); 371 dso__set_text_end(dso, section->filepos + section->size); 372 } 373 } 374 375 qsort(symbols, symbols_count, sizeof(asymbol *), bfd_symbols__cmpvalue); 376 377 #ifdef bfd_get_section 378 #define bfd_asymbol_section bfd_get_section 379 #endif 380 for (i = 0; i < symbols_count; ++i) { 381 sym = symbols[i]; 382 section = bfd_asymbol_section(sym); 383 if (bfd2elf_binding(sym) < 0) 384 continue; 385 386 while (i + 1 < symbols_count && 387 bfd_asymbol_section(symbols[i + 1]) == section && 388 bfd2elf_binding(symbols[i + 1]) < 0) 389 i++; 390 391 if (i + 1 < symbols_count && 392 bfd_asymbol_section(symbols[i + 1]) == section) 393 len = symbols[i + 1]->value - sym->value; 394 else 395 len = section->size - sym->value; 396 397 start = bfd_asymbol_value(sym) - dso__text_offset(dso); 398 symbol = symbol__new(start, len, bfd2elf_binding(sym), STT_FUNC, 399 bfd_asymbol_name(sym)); 400 if (!symbol) 401 goto out_free; 402 403 symbols__insert(dso__symbols(dso), symbol); 404 } 405 #ifdef bfd_get_section 406 #undef bfd_asymbol_section 407 #endif 408 409 symbols__fixup_end(dso__symbols(dso), false); 410 symbols__fixup_duplicate(dso__symbols(dso)); 411 dso__set_adjust_symbols(dso, true); 412 413 err = 0; 414 out_free: 415 free(symbols); 416 out_close: 417 bfd_close(abfd); 418 return err; 419 } 420 421 int libbfd__read_build_id(const char *filename, struct build_id *bid, bool block) 422 { 423 size_t size = sizeof(bid->data); 424 int err = -1, fd; 425 bfd *abfd; 426 427 fd = open(filename, block ? O_RDONLY : (O_RDONLY | O_NONBLOCK)); 428 if (fd < 0) 429 return -1; 430 431 ensure_bfd_init(); 432 abfd = bfd_fdopenr(filename, /*target=*/NULL, fd); 433 if (!abfd) 434 return -1; 435 436 if (!bfd_check_format(abfd, bfd_object)) { 437 pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename); 438 goto out_close; 439 } 440 441 if (!abfd->build_id || abfd->build_id->size > size) 442 goto out_close; 443 444 memcpy(bid->data, abfd->build_id->data, abfd->build_id->size); 445 memset(bid->data + abfd->build_id->size, 0, size - abfd->build_id->size); 446 err = bid->size = abfd->build_id->size; 447 448 out_close: 449 bfd_close(abfd); 450 return err; 451 } 452 453 int libbfd_filename__read_debuglink(const char *filename, char *debuglink, 454 size_t size) 455 { 456 int err = -1; 457 asection *section; 458 bfd *abfd; 459 460 ensure_bfd_init(); 461 abfd = bfd_openr(filename, NULL); 462 if (!abfd) 463 return -1; 464 465 if (!bfd_check_format(abfd, bfd_object)) { 466 pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename); 467 goto out_close; 468 } 469 470 section = bfd_get_section_by_name(abfd, ".gnu_debuglink"); 471 if (!section) 472 goto out_close; 473 474 if (section->size > size) 475 goto out_close; 476 477 if (!bfd_get_section_contents(abfd, section, debuglink, 0, 478 section->size)) 479 goto out_close; 480 481 err = 0; 482 483 out_close: 484 bfd_close(abfd); 485 return err; 486 } 487 488 int symbol__disassemble_bpf_libbfd(struct symbol *sym __maybe_unused, 489 struct annotate_args *args __maybe_unused) 490 { 491 #ifdef HAVE_LIBBPF_SUPPORT 492 struct annotation *notes = symbol__annotation(sym); 493 struct bpf_prog_linfo *prog_linfo = NULL; 494 struct bpf_prog_info_node *info_node; 495 int len = sym->end - sym->start; 496 disassembler_ftype disassemble; 497 struct map *map = args->ms.map; 498 struct perf_bpil *info_linear; 499 struct disassemble_info info; 500 struct dso *dso = map__dso(map); 501 int pc = 0, count, sub_id; 502 struct btf *btf = NULL; 503 char tpath[PATH_MAX]; 504 size_t buf_size; 505 int nr_skip = 0; 506 char *buf; 507 bfd *bfdf; 508 int ret; 509 FILE *s; 510 511 if (dso__binary_type(dso) != DSO_BINARY_TYPE__BPF_PROG_INFO) 512 return SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE; 513 514 pr_debug("%s: handling sym %s addr %" PRIx64 " len %" PRIx64 "\n", __func__, 515 sym->name, sym->start, sym->end - sym->start); 516 517 memset(tpath, 0, sizeof(tpath)); 518 perf_exe(tpath, sizeof(tpath)); 519 520 ensure_bfd_init(); 521 bfdf = bfd_openr(tpath, NULL); 522 if (bfdf == NULL) 523 abort(); 524 525 if (!bfd_check_format(bfdf, bfd_object)) 526 abort(); 527 528 s = open_memstream(&buf, &buf_size); 529 if (!s) { 530 ret = errno; 531 goto out; 532 } 533 init_disassemble_info_compat(&info, s, 534 (fprintf_ftype) fprintf, 535 fprintf_styled); 536 info.arch = bfd_get_arch(bfdf); 537 info.mach = bfd_get_mach(bfdf); 538 539 info_node = perf_env__find_bpf_prog_info(dso__bpf_prog(dso)->env, 540 dso__bpf_prog(dso)->id); 541 if (!info_node) { 542 ret = SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF; 543 goto out; 544 } 545 info_linear = info_node->info_linear; 546 sub_id = dso__bpf_prog(dso)->sub_id; 547 548 info.buffer = (void *)(uintptr_t)(info_linear->info.jited_prog_insns); 549 info.buffer_length = info_linear->info.jited_prog_len; 550 551 if (info_linear->info.nr_line_info) 552 prog_linfo = bpf_prog_linfo__new(&info_linear->info); 553 554 if (info_linear->info.btf_id) { 555 struct btf_node *node; 556 557 node = perf_env__find_btf(dso__bpf_prog(dso)->env, 558 info_linear->info.btf_id); 559 if (node) 560 btf = btf__new((__u8 *)(node->data), 561 node->data_size); 562 } 563 564 disassemble_init_for_target(&info); 565 566 #ifdef DISASM_FOUR_ARGS_SIGNATURE 567 disassemble = disassembler(info.arch, 568 bfd_big_endian(bfdf), 569 info.mach, 570 bfdf); 571 #else 572 disassemble = disassembler(bfdf); 573 #endif 574 if (disassemble == NULL) 575 abort(); 576 577 fflush(s); 578 do { 579 const struct bpf_line_info *linfo = NULL; 580 struct disasm_line *dl; 581 size_t prev_buf_size; 582 const char *srcline; 583 u64 addr; 584 585 addr = pc + ((u64 *)(uintptr_t)(info_linear->info.jited_ksyms))[sub_id]; 586 count = disassemble(pc, &info); 587 588 if (prog_linfo) 589 linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo, 590 addr, sub_id, 591 nr_skip); 592 593 if (linfo && btf) { 594 srcline = btf__name_by_offset(btf, linfo->line_off); 595 nr_skip++; 596 } else 597 srcline = NULL; 598 599 fprintf(s, "\n"); 600 prev_buf_size = buf_size; 601 fflush(s); 602 603 if (!annotate_opts.hide_src_code && srcline) { 604 args->offset = -1; 605 args->line = strdup(srcline); 606 args->line_nr = 0; 607 args->fileloc = NULL; 608 args->ms.sym = sym; 609 dl = disasm_line__new(args); 610 if (dl) { 611 annotation_line__add(&dl->al, 612 ¬es->src->source); 613 } 614 } 615 616 args->offset = pc; 617 args->line = buf + prev_buf_size; 618 args->line_nr = 0; 619 args->fileloc = NULL; 620 args->ms.sym = sym; 621 dl = disasm_line__new(args); 622 if (dl) 623 annotation_line__add(&dl->al, ¬es->src->source); 624 625 pc += count; 626 } while (count > 0 && pc < len); 627 628 ret = 0; 629 out: 630 free(prog_linfo); 631 btf__free(btf); 632 fclose(s); 633 bfd_close(bfdf); 634 return ret; 635 #else 636 return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF; 637 #endif 638 } 639