root/tools/perf/util/unwind-libunwind-local.c

DEFINITIONS

1. __dw_read_encoded_value
2. elf_section_offset
3. elf_is_exec
4. unwind_spec_ehframe
5. read_unwind_spec_eh_frame
6. read_unwind_spec_debug_frame
7. find_map
8. find_proc_info
9. access_fpreg
10. get_dyn_info_list_addr
11. resume
12. get_proc_name
13. access_dso_mem
14. access_mem
15. access_reg
16. put_unwind_info
17. entry
18. display_error
19. _unwind__prepare_access
20. _unwind__flush_access
21. _unwind__finish_access
22. get_entries
23. _unwind__get_entries

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