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