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