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