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