1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps. 4 * 5 * Lots of this code have been borrowed or heavily inspired from parts of 6 * the libunwind 0.99 code which are (amongst other contributors I may have 7 * forgotten): 8 * 9 * Copyright (C) 2002-2007 Hewlett-Packard Co 10 * Contributed by David Mosberger-Tang <davidm@hpl.hp.com> 11 * 12 * And the bugs have been added by: 13 * 14 * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com> 15 * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com> 16 * 17 */ 18 19 #include <elf.h> 20 #include <errno.h> 21 #include <gelf.h> 22 #include <fcntl.h> 23 #include <inttypes.h> 24 #include <string.h> 25 #include <unistd.h> 26 #include <sys/mman.h> 27 #include <linux/list.h> 28 #ifndef REMOTE_UNWIND_LIBUNWIND 29 #include <libunwind.h> 30 #include <libunwind-ptrace.h> 31 #endif 32 #include "callchain.h" 33 #include "thread.h" 34 #include "session.h" 35 #include "perf_regs.h" 36 #include "unwind.h" 37 #include "symbol.h" 38 #include "util.h" 39 #include "debug.h" 40 #include "asm/bug.h" 41 #include "dso.h" 42 43 extern int 44 UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as, 45 unw_word_t ip, 46 unw_dyn_info_t *di, 47 unw_proc_info_t *pi, 48 int need_unwind_info, void *arg); 49 50 #define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table) 51 52 extern int 53 UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug, 54 unw_word_t ip, 55 unw_word_t segbase, 56 const char *obj_name, unw_word_t start, 57 unw_word_t end); 58 59 #define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame) 60 61 #define DW_EH_PE_FORMAT_MASK 0x0f /* format of the encoded value */ 62 #define DW_EH_PE_APPL_MASK 0x70 /* how the value is to be applied */ 63 64 /* Pointer-encoding formats: */ 65 #define DW_EH_PE_omit 0xff 66 #define DW_EH_PE_ptr 0x00 /* pointer-sized unsigned value */ 67 #define DW_EH_PE_udata4 0x03 /* unsigned 32-bit value */ 68 #define DW_EH_PE_udata8 0x04 /* unsigned 64-bit value */ 69 #define DW_EH_PE_sdata4 0x0b /* signed 32-bit value */ 70 #define DW_EH_PE_sdata8 0x0c /* signed 64-bit value */ 71 72 /* Pointer-encoding application: */ 73 #define DW_EH_PE_absptr 0x00 /* absolute value */ 74 #define DW_EH_PE_pcrel 0x10 /* rel. to addr. of encoded value */ 75 76 /* 77 * The following are not documented by LSB v1.3, yet they are used by 78 * GCC, presumably they aren't documented by LSB since they aren't 79 * used on Linux: 80 */ 81 #define DW_EH_PE_funcrel 0x40 /* start-of-procedure-relative */ 82 #define DW_EH_PE_aligned 0x50 /* aligned pointer */ 83 84 /* Flags intentionaly not handled, since they're not needed: 85 * #define DW_EH_PE_indirect 0x80 86 * #define DW_EH_PE_uleb128 0x01 87 * #define DW_EH_PE_udata2 0x02 88 * #define DW_EH_PE_sleb128 0x09 89 * #define DW_EH_PE_sdata2 0x0a 90 * #define DW_EH_PE_textrel 0x20 91 * #define DW_EH_PE_datarel 0x30 92 */ 93 94 struct unwind_info { 95 struct perf_sample *sample; 96 struct machine *machine; 97 struct thread *thread; 98 }; 99 100 #define dw_read(ptr, type, end) ({ \ 101 type *__p = (type *) ptr; \ 102 type __v; \ 103 if ((__p + 1) > (type *) end) \ 104 return -EINVAL; \ 105 __v = *__p++; \ 106 ptr = (typeof(ptr)) __p; \ 107 __v; \ 108 }) 109 110 static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val, 111 u8 encoding) 112 { 113 u8 *cur = *p; 114 *val = 0; 115 116 switch (encoding) { 117 case DW_EH_PE_omit: 118 *val = 0; 119 goto out; 120 case DW_EH_PE_ptr: 121 *val = dw_read(cur, unsigned long, end); 122 goto out; 123 default: 124 break; 125 } 126 127 switch (encoding & DW_EH_PE_APPL_MASK) { 128 case DW_EH_PE_absptr: 129 break; 130 case DW_EH_PE_pcrel: 131 *val = (unsigned long) cur; 132 break; 133 default: 134 return -EINVAL; 135 } 136 137 if ((encoding & 0x07) == 0x00) 138 encoding |= DW_EH_PE_udata4; 139 140 switch (encoding & DW_EH_PE_FORMAT_MASK) { 141 case DW_EH_PE_sdata4: 142 *val += dw_read(cur, s32, end); 143 break; 144 case DW_EH_PE_udata4: 145 *val += dw_read(cur, u32, end); 146 break; 147 case DW_EH_PE_sdata8: 148 *val += dw_read(cur, s64, end); 149 break; 150 case DW_EH_PE_udata8: 151 *val += dw_read(cur, u64, end); 152 break; 153 default: 154 return -EINVAL; 155 } 156 157 out: 158 *p = cur; 159 return 0; 160 } 161 162 #define dw_read_encoded_value(ptr, end, enc) ({ \ 163 u64 __v; \ 164 if (__dw_read_encoded_value(&ptr, end, &__v, enc)) { \ 165 return -EINVAL; \ 166 } \ 167 __v; \ 168 }) 169 170 static u64 elf_section_offset(int fd, const char *name) 171 { 172 Elf *elf; 173 GElf_Ehdr ehdr; 174 GElf_Shdr shdr; 175 u64 offset = 0; 176 177 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 178 if (elf == NULL) 179 return 0; 180 181 do { 182 if (gelf_getehdr(elf, &ehdr) == NULL) 183 break; 184 185 if (!elf_section_by_name(elf, &ehdr, &shdr, name, NULL)) 186 break; 187 188 offset = shdr.sh_offset; 189 } while (0); 190 191 elf_end(elf); 192 return offset; 193 } 194 195 #ifndef NO_LIBUNWIND_DEBUG_FRAME 196 static int elf_is_exec(int fd, const char *name) 197 { 198 Elf *elf; 199 GElf_Ehdr ehdr; 200 int retval = 0; 201 202 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 203 if (elf == NULL) 204 return 0; 205 if (gelf_getehdr(elf, &ehdr) == NULL) 206 goto out; 207 208 retval = (ehdr.e_type == ET_EXEC); 209 210 out: 211 elf_end(elf); 212 pr_debug("unwind: elf_is_exec(%s): %d\n", name, retval); 213 return retval; 214 } 215 #endif 216 217 struct table_entry { 218 u32 start_ip_offset; 219 u32 fde_offset; 220 }; 221 222 struct eh_frame_hdr { 223 unsigned char version; 224 unsigned char eh_frame_ptr_enc; 225 unsigned char fde_count_enc; 226 unsigned char table_enc; 227 228 /* 229 * The rest of the header is variable-length and consists of the 230 * following members: 231 * 232 * encoded_t eh_frame_ptr; 233 * encoded_t fde_count; 234 */ 235 236 /* A single encoded pointer should not be more than 8 bytes. */ 237 u64 enc[2]; 238 239 /* 240 * struct { 241 * encoded_t start_ip; 242 * encoded_t fde_addr; 243 * } binary_search_table[fde_count]; 244 */ 245 char data[0]; 246 } __packed; 247 248 static int unwind_spec_ehframe(struct dso *dso, struct machine *machine, 249 u64 offset, u64 *table_data, u64 *segbase, 250 u64 *fde_count) 251 { 252 struct eh_frame_hdr hdr; 253 u8 *enc = (u8 *) &hdr.enc; 254 u8 *end = (u8 *) &hdr.data; 255 ssize_t r; 256 257 r = dso__data_read_offset(dso, machine, offset, 258 (u8 *) &hdr, sizeof(hdr)); 259 if (r != sizeof(hdr)) 260 return -EINVAL; 261 262 /* We dont need eh_frame_ptr, just skip it. */ 263 dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc); 264 265 *fde_count = dw_read_encoded_value(enc, end, hdr.fde_count_enc); 266 *segbase = offset; 267 *table_data = (enc - (u8 *) &hdr) + offset; 268 return 0; 269 } 270 271 static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine, 272 u64 *table_data, u64 *segbase, 273 u64 *fde_count) 274 { 275 int ret = -EINVAL, fd; 276 u64 offset = dso->data.eh_frame_hdr_offset; 277 278 if (offset == 0) { 279 fd = dso__data_get_fd(dso, machine); 280 if (fd < 0) 281 return -EINVAL; 282 283 /* Check the .eh_frame section for unwinding info */ 284 offset = elf_section_offset(fd, ".eh_frame_hdr"); 285 dso->data.eh_frame_hdr_offset = offset; 286 dso__data_put_fd(dso); 287 } 288 289 if (offset) 290 ret = unwind_spec_ehframe(dso, machine, offset, 291 table_data, segbase, 292 fde_count); 293 294 return ret; 295 } 296 297 #ifndef NO_LIBUNWIND_DEBUG_FRAME 298 static int read_unwind_spec_debug_frame(struct dso *dso, 299 struct machine *machine, u64 *offset) 300 { 301 int fd; 302 u64 ofs = dso->data.debug_frame_offset; 303 304 /* debug_frame can reside in: 305 * - dso 306 * - debug pointed by symsrc_filename 307 * - gnu_debuglink, which doesn't necessary 308 * has to be pointed by symsrc_filename 309 */ 310 if (ofs == 0) { 311 fd = dso__data_get_fd(dso, machine); 312 if (fd >= 0) { 313 ofs = elf_section_offset(fd, ".debug_frame"); 314 dso__data_put_fd(dso); 315 } 316 317 if (ofs <= 0) { 318 fd = open(dso->symsrc_filename, O_RDONLY); 319 if (fd >= 0) { 320 ofs = elf_section_offset(fd, ".debug_frame"); 321 close(fd); 322 } 323 } 324 325 if (ofs <= 0) { 326 char *debuglink = malloc(PATH_MAX); 327 int ret = 0; 328 329 ret = dso__read_binary_type_filename( 330 dso, DSO_BINARY_TYPE__DEBUGLINK, 331 machine->root_dir, debuglink, PATH_MAX); 332 if (!ret) { 333 fd = open(debuglink, O_RDONLY); 334 if (fd >= 0) { 335 ofs = elf_section_offset(fd, 336 ".debug_frame"); 337 close(fd); 338 } 339 } 340 if (ofs > 0) { 341 if (dso->symsrc_filename != NULL) { 342 pr_warning( 343 "%s: overwrite symsrc(%s,%s)\n", 344 __func__, 345 dso->symsrc_filename, 346 debuglink); 347 free(dso->symsrc_filename); 348 } 349 dso->symsrc_filename = debuglink; 350 } else { 351 free(debuglink); 352 } 353 } 354 355 dso->data.debug_frame_offset = ofs; 356 } 357 358 *offset = ofs; 359 if (*offset) 360 return 0; 361 362 return -EINVAL; 363 } 364 #endif 365 366 static struct map *find_map(unw_word_t ip, struct unwind_info *ui) 367 { 368 struct addr_location al; 369 370 if (!thread__find_map(ui->thread, PERF_RECORD_MISC_USER, ip, &al)) { 371 /* 372 * We've seen cases (softice) where DWARF unwinder went 373 * through non executable mmaps, which we need to lookup 374 * in MAP__VARIABLE tree. 375 */ 376 __thread__find_map(ui->thread, PERF_RECORD_MISC_USER, 377 MAP__VARIABLE, ip, &al); 378 } 379 return al.map; 380 } 381 382 static int 383 find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi, 384 int need_unwind_info, void *arg) 385 { 386 struct unwind_info *ui = arg; 387 struct map *map; 388 unw_dyn_info_t di; 389 u64 table_data, segbase, fde_count; 390 int ret = -EINVAL; 391 392 map = find_map(ip, ui); 393 if (!map || !map->dso) 394 return -EINVAL; 395 396 pr_debug("unwind: find_proc_info dso %s\n", map->dso->name); 397 398 /* Check the .eh_frame section for unwinding info */ 399 if (!read_unwind_spec_eh_frame(map->dso, ui->machine, 400 &table_data, &segbase, &fde_count)) { 401 memset(&di, 0, sizeof(di)); 402 di.format = UNW_INFO_FORMAT_REMOTE_TABLE; 403 di.start_ip = map->start; 404 di.end_ip = map->end; 405 di.u.rti.segbase = map->start + segbase - map->pgoff; 406 di.u.rti.table_data = map->start + table_data - map->pgoff; 407 di.u.rti.table_len = fde_count * sizeof(struct table_entry) 408 / sizeof(unw_word_t); 409 ret = dwarf_search_unwind_table(as, ip, &di, pi, 410 need_unwind_info, arg); 411 } 412 413 #ifndef NO_LIBUNWIND_DEBUG_FRAME 414 /* Check the .debug_frame section for unwinding info */ 415 if (ret < 0 && 416 !read_unwind_spec_debug_frame(map->dso, ui->machine, &segbase)) { 417 int fd = dso__data_get_fd(map->dso, ui->machine); 418 int is_exec = elf_is_exec(fd, map->dso->name); 419 unw_word_t base = is_exec ? 0 : map->start; 420 const char *symfile; 421 422 if (fd >= 0) 423 dso__data_put_fd(map->dso); 424 425 symfile = map->dso->symsrc_filename ?: map->dso->name; 426 427 memset(&di, 0, sizeof(di)); 428 if (dwarf_find_debug_frame(0, &di, ip, base, symfile, 429 map->start, map->end)) 430 return dwarf_search_unwind_table(as, ip, &di, pi, 431 need_unwind_info, arg); 432 } 433 #endif 434 435 return ret; 436 } 437 438 static int access_fpreg(unw_addr_space_t __maybe_unused as, 439 unw_regnum_t __maybe_unused num, 440 unw_fpreg_t __maybe_unused *val, 441 int __maybe_unused __write, 442 void __maybe_unused *arg) 443 { 444 pr_err("unwind: access_fpreg unsupported\n"); 445 return -UNW_EINVAL; 446 } 447 448 static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as, 449 unw_word_t __maybe_unused *dil_addr, 450 void __maybe_unused *arg) 451 { 452 return -UNW_ENOINFO; 453 } 454 455 static int resume(unw_addr_space_t __maybe_unused as, 456 unw_cursor_t __maybe_unused *cu, 457 void __maybe_unused *arg) 458 { 459 pr_err("unwind: resume unsupported\n"); 460 return -UNW_EINVAL; 461 } 462 463 static int 464 get_proc_name(unw_addr_space_t __maybe_unused as, 465 unw_word_t __maybe_unused addr, 466 char __maybe_unused *bufp, size_t __maybe_unused buf_len, 467 unw_word_t __maybe_unused *offp, void __maybe_unused *arg) 468 { 469 pr_err("unwind: get_proc_name unsupported\n"); 470 return -UNW_EINVAL; 471 } 472 473 static int access_dso_mem(struct unwind_info *ui, unw_word_t addr, 474 unw_word_t *data) 475 { 476 struct map *map; 477 ssize_t size; 478 479 map = find_map(addr, ui); 480 if (!map) { 481 pr_debug("unwind: no map for %lx\n", (unsigned long)addr); 482 return -1; 483 } 484 485 if (!map->dso) 486 return -1; 487 488 size = dso__data_read_addr(map->dso, map, ui->machine, 489 addr, (u8 *) data, sizeof(*data)); 490 491 return !(size == sizeof(*data)); 492 } 493 494 static int access_mem(unw_addr_space_t __maybe_unused as, 495 unw_word_t addr, unw_word_t *valp, 496 int __write, void *arg) 497 { 498 struct unwind_info *ui = arg; 499 struct stack_dump *stack = &ui->sample->user_stack; 500 u64 start, end; 501 int offset; 502 int ret; 503 504 /* Don't support write, probably not needed. */ 505 if (__write || !stack || !ui->sample->user_regs.regs) { 506 *valp = 0; 507 return 0; 508 } 509 510 ret = perf_reg_value(&start, &ui->sample->user_regs, 511 LIBUNWIND__ARCH_REG_SP); 512 if (ret) 513 return ret; 514 515 end = start + stack->size; 516 517 /* Check overflow. */ 518 if (addr + sizeof(unw_word_t) < addr) 519 return -EINVAL; 520 521 if (addr < start || addr + sizeof(unw_word_t) >= end) { 522 ret = access_dso_mem(ui, addr, valp); 523 if (ret) { 524 pr_debug("unwind: access_mem %p not inside range" 525 " 0x%" PRIx64 "-0x%" PRIx64 "\n", 526 (void *) (uintptr_t) addr, start, end); 527 *valp = 0; 528 return ret; 529 } 530 return 0; 531 } 532 533 offset = addr - start; 534 *valp = *(unw_word_t *)&stack->data[offset]; 535 pr_debug("unwind: access_mem addr %p val %lx, offset %d\n", 536 (void *) (uintptr_t) addr, (unsigned long)*valp, offset); 537 return 0; 538 } 539 540 static int access_reg(unw_addr_space_t __maybe_unused as, 541 unw_regnum_t regnum, unw_word_t *valp, 542 int __write, void *arg) 543 { 544 struct unwind_info *ui = arg; 545 int id, ret; 546 u64 val; 547 548 /* Don't support write, I suspect we don't need it. */ 549 if (__write) { 550 pr_err("unwind: access_reg w %d\n", regnum); 551 return 0; 552 } 553 554 if (!ui->sample->user_regs.regs) { 555 *valp = 0; 556 return 0; 557 } 558 559 id = LIBUNWIND__ARCH_REG_ID(regnum); 560 if (id < 0) 561 return -EINVAL; 562 563 ret = perf_reg_value(&val, &ui->sample->user_regs, id); 564 if (ret) { 565 pr_err("unwind: can't read reg %d\n", regnum); 566 return ret; 567 } 568 569 *valp = (unw_word_t) val; 570 pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp); 571 return 0; 572 } 573 574 static void put_unwind_info(unw_addr_space_t __maybe_unused as, 575 unw_proc_info_t *pi __maybe_unused, 576 void *arg __maybe_unused) 577 { 578 pr_debug("unwind: put_unwind_info called\n"); 579 } 580 581 static int entry(u64 ip, struct thread *thread, 582 unwind_entry_cb_t cb, void *arg) 583 { 584 struct unwind_entry e; 585 struct addr_location al; 586 587 e.sym = thread__find_symbol(thread, PERF_RECORD_MISC_USER, ip, &al); 588 e.ip = al.addr; 589 e.map = al.map; 590 591 pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n", 592 al.sym ? al.sym->name : "''", 593 ip, 594 al.map ? al.map->map_ip(al.map, ip) : (u64) 0); 595 596 return cb(&e, arg); 597 } 598 599 static void display_error(int err) 600 { 601 switch (err) { 602 case UNW_EINVAL: 603 pr_err("unwind: Only supports local.\n"); 604 break; 605 case UNW_EUNSPEC: 606 pr_err("unwind: Unspecified error.\n"); 607 break; 608 case UNW_EBADREG: 609 pr_err("unwind: Register unavailable.\n"); 610 break; 611 default: 612 break; 613 } 614 } 615 616 static unw_accessors_t accessors = { 617 .find_proc_info = find_proc_info, 618 .put_unwind_info = put_unwind_info, 619 .get_dyn_info_list_addr = get_dyn_info_list_addr, 620 .access_mem = access_mem, 621 .access_reg = access_reg, 622 .access_fpreg = access_fpreg, 623 .resume = resume, 624 .get_proc_name = get_proc_name, 625 }; 626 627 static int _unwind__prepare_access(struct thread *thread) 628 { 629 if (!dwarf_callchain_users) 630 return 0; 631 thread->addr_space = unw_create_addr_space(&accessors, 0); 632 if (!thread->addr_space) { 633 pr_err("unwind: Can't create unwind address space.\n"); 634 return -ENOMEM; 635 } 636 637 unw_set_caching_policy(thread->addr_space, UNW_CACHE_GLOBAL); 638 return 0; 639 } 640 641 static void _unwind__flush_access(struct thread *thread) 642 { 643 if (!dwarf_callchain_users) 644 return; 645 unw_flush_cache(thread->addr_space, 0, 0); 646 } 647 648 static void _unwind__finish_access(struct thread *thread) 649 { 650 if (!dwarf_callchain_users) 651 return; 652 unw_destroy_addr_space(thread->addr_space); 653 } 654 655 static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb, 656 void *arg, int max_stack) 657 { 658 u64 val; 659 unw_word_t ips[max_stack]; 660 unw_addr_space_t addr_space; 661 unw_cursor_t c; 662 int ret, i = 0; 663 664 ret = perf_reg_value(&val, &ui->sample->user_regs, 665 LIBUNWIND__ARCH_REG_IP); 666 if (ret) 667 return ret; 668 669 ips[i++] = (unw_word_t) val; 670 671 /* 672 * If we need more than one entry, do the DWARF 673 * unwind itself. 674 */ 675 if (max_stack - 1 > 0) { 676 WARN_ONCE(!ui->thread, "WARNING: ui->thread is NULL"); 677 addr_space = ui->thread->addr_space; 678 679 if (addr_space == NULL) 680 return -1; 681 682 ret = unw_init_remote(&c, addr_space, ui); 683 if (ret) 684 display_error(ret); 685 686 while (!ret && (unw_step(&c) > 0) && i < max_stack) { 687 unw_get_reg(&c, UNW_REG_IP, &ips[i]); 688 689 /* 690 * Decrement the IP for any non-activation frames. 691 * this is required to properly find the srcline 692 * for caller frames. 693 * See also the documentation for dwfl_frame_pc(), 694 * which this code tries to replicate. 695 */ 696 if (unw_is_signal_frame(&c) <= 0) 697 --ips[i]; 698 699 ++i; 700 } 701 702 max_stack = i; 703 } 704 705 /* 706 * Display what we got based on the order setup. 707 */ 708 for (i = 0; i < max_stack && !ret; i++) { 709 int j = i; 710 711 if (callchain_param.order == ORDER_CALLER) 712 j = max_stack - i - 1; 713 ret = ips[j] ? entry(ips[j], ui->thread, cb, arg) : 0; 714 } 715 716 return ret; 717 } 718 719 static int _unwind__get_entries(unwind_entry_cb_t cb, void *arg, 720 struct thread *thread, 721 struct perf_sample *data, int max_stack) 722 { 723 struct unwind_info ui = { 724 .sample = data, 725 .thread = thread, 726 .machine = thread->mg->machine, 727 }; 728 729 if (!data->user_regs.regs) 730 return -EINVAL; 731 732 if (max_stack <= 0) 733 return -EINVAL; 734 735 return get_entries(&ui, cb, arg, max_stack); 736 } 737 738 static struct unwind_libunwind_ops 739 _unwind_libunwind_ops = { 740 .prepare_access = _unwind__prepare_access, 741 .flush_access = _unwind__flush_access, 742 .finish_access = _unwind__finish_access, 743 .get_entries = _unwind__get_entries, 744 }; 745 746 #ifndef REMOTE_UNWIND_LIBUNWIND 747 struct unwind_libunwind_ops * 748 local_unwind_libunwind_ops = &_unwind_libunwind_ops; 749 #endif 750