1#include <linux/compiler.h>
2#include <linux/types.h>
3#include <unistd.h>
4#include "tests.h"
5#include "debug.h"
6#include "machine.h"
7#include "event.h"
8#include "unwind.h"
9#include "perf_regs.h"
10#include "map.h"
11#include "thread.h"
12#include "callchain.h"
13
14/* For bsearch. We try to unwind functions in shared object. */
15#include <stdlib.h>
16
17static int mmap_handler(struct perf_tool *tool __maybe_unused,
18			union perf_event *event,
19			struct perf_sample *sample __maybe_unused,
20			struct machine *machine)
21{
22	return machine__process_mmap2_event(machine, event, NULL);
23}
24
25static int init_live_machine(struct machine *machine)
26{
27	union perf_event event;
28	pid_t pid = getpid();
29
30	return perf_event__synthesize_mmap_events(NULL, &event, pid, pid,
31						  mmap_handler, machine, true);
32}
33
34#define MAX_STACK 8
35
36static int unwind_entry(struct unwind_entry *entry, void *arg)
37{
38	unsigned long *cnt = (unsigned long *) arg;
39	char *symbol = entry->sym ? entry->sym->name : NULL;
40	static const char *funcs[MAX_STACK] = {
41		"test__arch_unwind_sample",
42		"unwind_thread",
43		"compare",
44		"bsearch",
45		"krava_3",
46		"krava_2",
47		"krava_1",
48		"test__dwarf_unwind"
49	};
50
51	if (*cnt >= MAX_STACK) {
52		pr_debug("failed: crossed the max stack value %d\n", MAX_STACK);
53		return -1;
54	}
55
56	if (!symbol) {
57		pr_debug("failed: got unresolved address 0x%" PRIx64 "\n",
58			 entry->ip);
59		return -1;
60	}
61
62	pr_debug("got: %s 0x%" PRIx64 "\n", symbol, entry->ip);
63	return strcmp((const char *) symbol, funcs[(*cnt)++]);
64}
65
66__attribute__ ((noinline))
67static int unwind_thread(struct thread *thread)
68{
69	struct perf_sample sample;
70	unsigned long cnt = 0;
71	int err = -1;
72
73	memset(&sample, 0, sizeof(sample));
74
75	if (test__arch_unwind_sample(&sample, thread)) {
76		pr_debug("failed to get unwind sample\n");
77		goto out;
78	}
79
80	err = unwind__get_entries(unwind_entry, &cnt, thread,
81				  &sample, MAX_STACK);
82	if (err)
83		pr_debug("unwind failed\n");
84	else if (cnt != MAX_STACK) {
85		pr_debug("got wrong number of stack entries %lu != %d\n",
86			 cnt, MAX_STACK);
87		err = -1;
88	}
89
90 out:
91	free(sample.user_stack.data);
92	free(sample.user_regs.regs);
93	return err;
94}
95
96static int global_unwind_retval = -INT_MAX;
97
98__attribute__ ((noinline))
99static int compare(void *p1, void *p2)
100{
101	/* Any possible value should be 'thread' */
102	struct thread *thread = *(struct thread **)p1;
103
104	if (global_unwind_retval == -INT_MAX)
105		global_unwind_retval = unwind_thread(thread);
106
107	return p1 - p2;
108}
109
110__attribute__ ((noinline))
111static int krava_3(struct thread *thread)
112{
113	struct thread *array[2] = {thread, thread};
114	void *fp = &bsearch;
115	/*
116	 * make _bsearch a volatile function pointer to
117	 * prevent potential optimization, which may expand
118	 * bsearch and call compare directly from this function,
119	 * instead of libc shared object.
120	 */
121	void *(*volatile _bsearch)(void *, void *, size_t,
122			size_t, int (*)(void *, void *));
123
124	_bsearch = fp;
125	_bsearch(array, &thread, 2, sizeof(struct thread **), compare);
126	return global_unwind_retval;
127}
128
129__attribute__ ((noinline))
130static int krava_2(struct thread *thread)
131{
132	return krava_3(thread);
133}
134
135__attribute__ ((noinline))
136static int krava_1(struct thread *thread)
137{
138	return krava_2(thread);
139}
140
141int test__dwarf_unwind(void)
142{
143	struct machines machines;
144	struct machine *machine;
145	struct thread *thread;
146	int err = -1;
147
148	machines__init(&machines);
149
150	machine = machines__find(&machines, HOST_KERNEL_ID);
151	if (!machine) {
152		pr_err("Could not get machine\n");
153		return -1;
154	}
155
156	callchain_param.record_mode = CALLCHAIN_DWARF;
157
158	if (init_live_machine(machine)) {
159		pr_err("Could not init machine\n");
160		goto out;
161	}
162
163	if (verbose > 1)
164		machine__fprintf(machine, stderr);
165
166	thread = machine__find_thread(machine, getpid(), getpid());
167	if (!thread) {
168		pr_err("Could not get thread\n");
169		goto out;
170	}
171
172	err = krava_1(thread);
173
174 out:
175	machine__delete_threads(machine);
176	machine__exit(machine);
177	machines__exit(&machines);
178	return err;
179}
180