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